path: root/socket.js

// Tools for hosting an MTUI party over a socket server. Comparable in idea to
// telnet.js, but for interfacing over commands rather than hosting all client
// UIs on one server. The intent of the code in this file is to allow clients
// to connect and interface with each other, while still running all processes
// involved in mtui on their own machines -- so mtui will download and play
// music using each connected machine's own internet connection and speakers.

// TODO: Option to display listing items which aren't available on all
// connected devices.

'use strict' // single quotes & no semicolons time babey

const EventEmitter = require('events')
const net = require('net')

const {
  saveBackend,
  restoreBackend,
  updateRestoredTracksUsingPlaylists
} = require('./serialized-backend')

function serializeCommandToData(command) {
  // Turn a command into a string/buffer that can be sent over a socket.
  return JSON.stringify(command)
}

function deserializeDataToCommand(data) {
  // Turn data received from a socket into a command that can be processed as
  // an action to apply to the mtui backend.
  return JSON.parse(data)
}

function validateCommand(command) {
  // TODO: Could be used to validate "against" a backend, but for now it just
  // checks data types.

  if (typeof command !== 'object') {
    return false
  }

  if (!['server', 'client'].includes(command.sender)) {
    return false
  }

  switch (command.sender) {
    case 'server':
      switch (command.code) {
        case 'initialize-backend':
          return typeof command.backend === 'object'
      }
      // No break here; servers can send commands which typically come from
      // clients too.
    case 'client':
      switch (command.code) {
        case 'seek-to':
          return (
            typeof command.queuePlayer === 'string' &&
            typeof command.time === 'number'
          )
        case 'set-pause':
          return (
            typeof command.queuePlayer === 'string' &&
            typeof command.paused === 'boolean'
          )
        case 'status':
          return typeof command.status === 'string'
      }
      break
  }

  return false
}

function makeSocketServer() {
  // The socket server has two functions: to maintain a "canonical" backend
  // and synchronize newly connected clients with the relevent data in this
  // backend, and to receive command data from clients and relay this to
  // other clients.
  //
  // makeSocketServer doesn't actually start the server listening on a port;
  // that's the responsibility of the caller (use server.listen()).

  const server = new net.Server()
  const sockets = []

  server.canonicalBackend = null

  function receivedData(socket, data) {
    // Parse data as a command and validate it. If invalid, drop this data.

    let command
    try {
      command = deserializeDataToCommand(data)
    } catch (error) {
      return
    }

    command.sender = 'client'

    if (!validateCommand(command)) {
      return
    }

    // If it's a status command, respond appropriately, and return so that it
    // is not relayed.

    if (command.code === 'status') {
      switch (command.status) {
        case 'sync-playback':
          for (const QP of server.canonicalBackend.queuePlayers) {
            if (QP.timeData) {
              socket.write(JSON.stringify({
                sender: 'server',
                code: 'seek-to',
                queuePlayer: QP.id,
                time: QP.timeData.curSecTotal
              }) + '\n')
              socket.write(JSON.stringify({
                sender: 'server',
                code: 'set-pause',
                queuePlayer: QP.id,
                paused: false
              }))
            }
          }

          break
      }

      return
    }

    // Relay the data to client sockets.

    for (const socket of sockets) {
      socket.write(JSON.stringify(command))
    }
  }

  server.on('connection', socket => {
    sockets.push(socket)

    socket.on('close', () => {
      if (sockets.includes(socket)) {
        sockets.splice(sockets.indexOf(socket), 1)
      }
    })

    socket.on('data', data => receivedData(socket, data))

    const savedBackend = saveBackend(server.canonicalBackend)

    for (const qpData of savedBackend.queuePlayers) {
      if (qpData.playerInfo) {
        qpData.playerInfo.isPaused = true
      }
    }

    socket.write(JSON.stringify({
      sender: 'server',
      code: 'initialize-backend',
      backend: savedBackend
    }))
  })

  return server
}

function makeSocketClient() {
  // The socket client connects to a server and sends/receives commands to/from
  // that server. This doesn't actually connect the socket to a port/host; that
  // is the caller's responsibility (use client.socket.connect()).

  const client = new EventEmitter()
  client.socket = new net.Socket()

  client.sendCommand = function(command) {
    const data = serializeCommandToData(command)
    client.socket.write(data)
  }

  client.socket.on('data', data => {
    // Same sort of "guarding" deserialization/validation as in the server
    // code, because it's possible the client and server backends mismatch.

    for (const line of data.toString().split('\n')) {
      let command
      try {
        command = deserializeDataToCommand(line)
      } catch (error) {
        return
      }

      if (!validateCommand(command)) {
        return
      }

      client.emit('command', command)
    }
  })

  return client
}

function attachBackendToSocketClient(backend, client, {
  getPlaylistSources
}) {
  // All actual logic for instances of the mtui backend interacting with each
  // other through commands lives here.

  client.on('command', async command => {
    switch (command.sender) {
      case 'server':
        switch (command.code) {
          case 'initialize-backend':
            await restoreBackend(backend, command.backend)
            // TODO: does this need to be called here?
            updateRestoredTracksUsingPlaylists(backend, getPlaylistSources())
            backend.on('playing', QP => {
              QP.once('received time data', () => {
                client.sendCommand({code: 'status', status: 'sync-playback'})
              })
            })
            return
        }
        // Again, no pause. Client commands can come from the server.
      case 'client': {
        let QP = (
          command.queuePlayer &&
          backend.queuePlayers.find(QP => QP.id === command.queuePlayer)
        )

        switch (command.code) {
          case 'seek-to':
            if (QP) QP.seekTo(command.time)
            return
          case 'set-pause':
            if (QP) QP.setPause(command.paused)
            return
        }
      }
    }
  })

  backend.on('toggle-pause', queuePlayer => {
    client.sendCommand({
      code: 'set-pause',
      queuePlayer: queuePlayer.id,
      paused: queuePlayer.player.isPaused
    })
  })

  function handleSeek(queuePlayer) {
    client.sendCommand({
      code: 'seek-to',
      queuePlayer: queuePlayer.id,
      time: queuePlayer.time
    })
  }

  backend.on('seek-ahead', handleSeek)
  backend.on('seek-back', handleSeek)
  backend.on('seek-to', handleSeek)
}

function attachSocketServerToBackend(server, backend) {
  // Unlike the function for attaching a backend to follow commands from a
  // client (attachBackendToSocketClient), this function is minimalistic.
  // It just sets the associated "canonical" backend. Actual logic for
  // de/serialization lives in serialized-backend.js.
  server.canonicalBackend = backend
}

Object.assign(module.exports, {
  makeSocketServer,
  makeSocketClient,
  attachBackendToSocketClient,
  attachSocketServerToBackend
})