karaoke-eternal 1.0.0

package/server/socket.js

@@ -0,0 +1,173 @@
+const log = require('./lib/Log')('server')
+const jwtVerify = require('jsonwebtoken').verify
+
+const parseCookie = require('./lib/parseCookie')
+const Library = require('./Library')
+const LibrarySocket = require('./Library/socket')
+const PlayerSocket = require('./Player/socket')
+const Prefs = require('./Prefs')
+const PrefsSocket = require('./Prefs/socket')
+const Rooms = require('./Rooms')
+const Queue = require('./Queue')
+const QueueSocket = require('./Queue/socket')
+const {
+  LIBRARY_PUSH,
+  QUEUE_PUSH,
+  STARS_PUSH,
+  STAR_COUNTS_PUSH,
+  PLAYER_STATUS,
+  PLAYER_LEAVE,
+  PREFS_PUSH,
+  SOCKET_AUTH_ERROR,
+  _ERROR,
+} = require('../shared/actionTypes')
+
+const handlers = {
+  ...LibrarySocket,
+  ...QueueSocket,
+  ...PlayerSocket,
+  ...PrefsSocket,
+}
+
+module.exports = function (io, jwtKey) {
+  io.on('connection', async (sock) => {
+    const { keToken } = parseCookie(sock.handshake.headers.cookie)
+    const clientLibraryVersion = parseInt(sock.handshake.query.library, 10)
+    const clientStarsVersion = parseInt(sock.handshake.query.stars, 10)
+
+    // authenticate the JWT sent via cookie in http handshake
+    try {
+      sock.user = jwtVerify(keToken, jwtKey)
+
+      // success
+      log.verbose('%s (%s) connected from %s', sock.user.name, sock.id, sock.handshake.address)
+    } catch (err) {
+      io.to(sock.id).emit('action', {
+        type: SOCKET_AUTH_ERROR,
+      })
+
+      sock.user = null
+      sock.disconnect()
+      log.verbose('disconnected %s (%s)', sock.handshake.address, err.message)
+      return
+    }
+
+    // attach disconnect handler
+    sock.on('disconnect', reason => {
+      log.verbose('%s (%s) disconnected (%s)',
+        sock.user.name, sock.id, reason
+      )
+
+      if (typeof sock.user.roomId !== 'number') return
+
+      // beyond this point assumes there is a room
+
+      log.verbose('%s (%s) left room %s (%s; %s in room)',
+        sock.user.name, sock.id, sock.user.roomId, reason, sock.adapter.rooms.size
+      )
+
+      // any players left in room?
+      if (!Rooms.isPlayerPresent(io, sock.user.roomId)) {
+        io.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+          type: PLAYER_LEAVE,
+          payload: { socketId: sock.id },
+        })
+      }
+    })
+
+    // attach action handler
+    sock.on('action', async (action, acknowledge) => {
+      const { type } = action
+
+      if (!sock.user) {
+        return acknowledge({
+          type: SOCKET_AUTH_ERROR,
+        })
+      }
+
+      if (typeof handlers[type] !== 'function') {
+        log.error('No handler for socket action: %s', type)
+        return
+      }
+
+      try {
+        await handlers[type](sock, action, acknowledge)
+      } catch (err) {
+        log.error(err)
+
+        return acknowledge({
+          type: type + _ERROR,
+          error: `Error in ${type}: ${err.message}`,
+        })
+      }
+    })
+
+    // push prefs (admin only)
+    if (sock.user.isAdmin) {
+      log.verbose('pushing prefs to %s (%s)', sock.user.name, sock.id)
+      io.to(sock.id).emit('action', {
+        type: PREFS_PUSH,
+        payload: await Prefs.get(),
+      })
+    }
+
+    // push library (only if client's is outdated)
+    if (clientLibraryVersion !== Library.cache.version) {
+      log.verbose('pushing library to %s (%s) (client=%s, server=%s)',
+        sock.user.name, sock.id, clientLibraryVersion, Library.cache.version)
+
+      io.to(sock.id).emit('action', {
+        type: LIBRARY_PUSH,
+        payload: await Library.get(),
+      })
+    }
+
+    // push user's stars
+    io.to(sock.id).emit('action', {
+      type: STARS_PUSH,
+      payload: await Library.getUserStars(sock.user.userId),
+    })
+
+    // push star counts (only if client's is outdated)
+    if (clientStarsVersion !== Library.starCountsCache.version) {
+      log.verbose('pushing star counts to %s (%s) (client=%s, server=%s)',
+        sock.user.name, sock.id, clientStarsVersion, Library.starCountsCache.version)
+
+      io.to(sock.id).emit('action', {
+        type: STAR_COUNTS_PUSH,
+        payload: await Library.getStarCounts(),
+      })
+    }
+
+    // it's possible for an admin to not be in a room
+    if (typeof sock.user.roomId !== 'number') return
+
+    // beyond this point assumes there is a room
+
+    // add user to room
+    sock.join(Rooms.prefix(sock.user.roomId))
+
+    // if there's a player in room, emit its last known status
+    // @todo this just emits the first status found
+    for (const s of io.of('/').sockets.values()) {
+      if (s.user && s.user.roomId === sock.user.roomId && s._lastPlayerStatus) {
+        io.to(sock.id).emit('action', {
+          type: PLAYER_STATUS,
+          payload: s._lastPlayerStatus,
+        })
+
+        break
+      }
+    }
+
+    log.verbose('%s (%s) joined room %s (%s in room)',
+      sock.user.name, sock.id, sock.user.roomId, sock.adapter.rooms.size
+    )
+
+    // send room's queue
+    io.to(sock.id).emit('action', {
+      type: QUEUE_PUSH,
+      payload: await Queue.get(sock.user.roomId),
+    })
+  })
+}

package/shared/actionTypes.js

@@ -0,0 +1,103 @@
+module.exports = {
+  // sockets
+  SOCKET_REQUEST_CONNECT: 'user/SOCKET_REQUEST_CONNECT',
+  SOCKET_AUTH_ERROR: 'user/SOCKET_AUTH_ERROR',
+  // library
+  LIBRARY_FILTER_STRING: 'library/FILTER_KEYWORD',
+  LIBRARY_FILTER_STRING_RESET: 'library/FILTER_KEYWORD_CLEAR',
+  LIBRARY_FILTER_TOGGLE_STARRED: 'library/TOGGLE_FILTER_STARRED',
+  TOGGLE_ARTIST_EXPANDED: 'library/TOGGLE_ARTIST_EXPANDED',
+  TOGGLE_ARTIST_RESULT_EXPANDED: 'library/TOGGLE_ARTIST_RESULT_EXPANDED',
+  SCROLL_ARTISTS: 'library/SCROLL_ARTISTS',
+  SONG_STARRED: 'library/SONG_STARRED',
+  SONG_UNSTARRED: 'library/SONG_UNSTARRED',
+  STAR_COUNTS_PUSH: 'library/STAR_COUNTS_PUSH',
+  LIBRARY_PUSH: 'library/PUSH',
+  LIBRARY_PUSH_SONG: 'library/PUSH_SONG',
+  // queue
+  QUEUE_ADD: 'server/QUEUE_ADD',
+  QUEUE_MOVE: 'server/QUEUE_MOVE',
+  QUEUE_PUSH: 'queue/PUSH',
+  QUEUE_REMOVE: 'server/QUEUE_REMOVE',
+  // player internal
+  PLAYER_UPDATE: 'player/UPDATE',
+  // player room commands
+  PLAYER_CMD_OPTIONS: 'player/CMD_OPTIONS',
+  PLAYER_CMD_NEXT: 'player/CMD_NEXT',
+  PLAYER_CMD_PAUSE: 'player/CMD_PAUSE',
+  PLAYER_CMD_PLAY: 'player/CMD_PLAY',
+  PLAYER_CMD_VOLUME: 'player/CMD_VOLUME',
+  PLAYER_REQ_OPTIONS: 'server/PLAYER_REQ_OPTIONS',
+  PLAYER_REQ_PLAY: 'server/PLAYER_REQ_PLAY',
+  PLAYER_REQ_PAUSE: 'server/PLAYER_REQ_PAUSE',
+  PLAYER_REQ_NEXT: 'server/PLAYER_REQ_NEXT',
+  PLAYER_REQ_VOLUME: 'server/PLAYER_REQ_VOLUME',
+  PLAYER_EMIT_STATUS: 'server/PLAYER_EMIT_STATUS',
+  PLAYER_EMIT_LEAVE: 'server/PLAYER_EMIT_LEAVE',
+  // player events
+  PLAYER_STATUS: 'status/PLAYER_STATUS',
+  PLAYER_ERROR: 'status/PLAYER_ERROR',
+  PLAYER_LEAVE: 'status/PLAYER_LEAVE',
+  PLAYER_LOAD: 'status/PLAYER_LOAD',
+  PLAYER_PLAY: 'status/PLAYER_PLAY',
+  PLAYER_VISUALIZER_ERROR: 'status/PLAYER_VISUALIZER_ERROR',
+  // user
+  LOGIN: 'user/LOGIN',
+  LOGOUT: 'user/LOGOUT',
+  CREATE_ACCOUNT: 'user/CREATE_ACCOUNT',
+  UPDATE_ACCOUNT: 'user/UPDATE_ACCOUNT',
+  REQUEST_ACCOUNT: 'user/REQUEST_ACCOUNT',
+  REQUEST_ROOMS: 'rooms/REQUEST_ROOMS',
+  ROOM_UPDATE: 'rooms/UPDATE',
+  ROOM_CREATE: 'rooms/CREATE',
+  ROOM_REMOVE: 'rooms/REMOVE',
+  ROOM_EDITOR_OPEN: 'rooms/EDITOR_OPEN',
+  ROOM_EDITOR_CLOSE: 'rooms/EDITOR_CLOSE',
+  ROOM_FILTER_STATUS: 'rooms/TOGGLE_SHOW_ALL',
+  STAR_SONG: 'server/STAR_SONG',
+  UNSTAR_SONG: 'server/UNSTAR_SONG',
+  STARS_PUSH: 'user/STARS_PUSH',
+  // prefs
+  PREFS_RECEIVE: 'prefs/RECEIVE',
+  PREFS_REQUEST: 'prefs/REQUEST',
+  PREFS_SET: 'server/PREFS_SET',
+  PREFS_SET_PATH_PRIORITY: 'server/PREFS_SET_PATH_PRIORITY',
+  PREFS_PUSH: 'prefs/PREFS_PUSH',
+  PREFS_REQ_SCANNER_START: 'prefs/REQ_SCANNER_START',
+  PREFS_REQ_SCANNER_STOP: 'prefs/REQ_SCANNER_STOP',
+  // user management
+  USERS_CREATE: 'users/CREATE',
+  USERS_EDITOR_OPEN: 'users/EDITOR_OPEN',
+  USERS_EDITOR_CLOSE: 'users/EDITOR_CLOSE',
+  USERS_FILTER_ONLINE: 'users/FILTER_ONLINE',
+  USERS_FILTER_ROOM_ID: 'users/FILTER_ROOM_ID',
+  USERS_RECEIVE: 'users/RECEIVE',
+  USERS_REMOVE: 'users/REMOVE',
+  USERS_REQUEST: 'users/REQUEST',
+  USERS_UPDATE: 'users/UPDATE',
+  // ui
+  HEADER_HEIGHT_CHANGE: 'ui/HEADER_HEIGHT_CHANGE',
+  FOOTER_HEIGHT_CHANGE: 'ui/FOOTER_HEIGHT_CHANGE',
+  SHOW_ERROR_MESSAGE: 'ui/SHOW_ERROR_MESSAGE',
+  CLEAR_ERROR_MESSAGE: 'ui/CLEAR_ERROR_MESSAGE',
+  UI_WINDOW_RESIZE: 'ui/WINDOW_RESIZE',
+  // songInfo
+  SONG_INFO_REQUEST: 'songInfo/SONG_INFO_REQUEST',
+  SONG_INFO_SET_PREFERRED: 'songInfo/SET_PREFERRED',
+  SONG_INFO_CLOSE: 'songInfo/SONG_INFO_CLOSE',
+  // IPC messages
+  SCANNER_CMD_START: 'scannerWorker/CMD_START',
+  SCANNER_CMD_STOP: 'scannerWorker/CMD_STOP',
+  SCANNER_WORKER_LOG: 'scannerWorker/LOG',
+  SCANNER_WORKER_STATUS: 'scannerWorker/STATUS',
+  SERVER_WORKER_STATUS: 'serverWorker/STATUS',
+  SERVER_WORKER_ERROR: 'serverWorker/ERROR',
+  LIBRARY_MATCH_SONG: 'scannerWorker/LIBRARY_MATCH_SONG',
+  MEDIA_ADD: 'scannerWorker/MEDIA_ADD',
+  MEDIA_CLEANUP: 'scannerWorker/MEDIA_CLEANUP',
+  MEDIA_REMOVE: 'scannerWorker/MEDIA_REMOVE',
+  MEDIA_UPDATE: 'scannerWorker/MEDIA_UPDATE',
+  // misc
+  _SUCCESS: '_SUCCESS',
+  _ERROR: '_ERROR',
+}