karaoke-eternal 1.0.0 → 2.0.0-beta.6

package/server/main.js

@@ -1,135 +0,0 @@
-#!/usr/bin/env node
-const childProcess = require('child_process')
-const path = require('path')
-const env = require('./lib/cli')
-const { Log } = require('./lib/Log')
-
-const log = new Log('server', {
-  console: Log.resolve(env.KES_CONSOLE_LEVEL, env.NODE_ENV === 'development' ? 5 : 4),
-  file: Log.resolve(env.KES_LOG_LEVEL, env.NODE_ENV === 'development' ? 0 : 3),
-}).setDefaultInstance().logger.scope(`main[${process.pid}]`)
-
-const scannerLog = new Log('scanner', {
-  console: Log.resolve(process.env.KES_SCAN_CONSOLE_LEVEL, process.env.NODE_ENV === 'development' ? 5 : 4),
-  file: Log.resolve(process.env.KES_SCAN_LOG_LEVEL, process.env.NODE_ENV === 'development' ? 0 : 3),
-}).logger.scope('scanner')
-
-const Database = require('./lib/Database')
-const IPC = require('./lib/IPCBridge')
-const refs = {}
-const {
-  SCANNER_CMD_START,
-  SCANNER_CMD_STOP,
-  SERVER_WORKER_ERROR,
-  SCANNER_WORKER_LOG,
-  SERVER_WORKER_STATUS,
-} = require('../shared/actionTypes')
-
-// handle scanner logs
-// @todo: this doesn't need to be async
-IPC.use({
-  [SCANNER_WORKER_LOG]: async (action) => {
-    scannerLog[action.payload.level](action.payload.msg)
-  }
-})
-
-// log non-default settings
-for (const key in env) {
-  if (process.env[key]) log.verbose(`${key}=${process.env[key]}`)
-}
-
-// support PUID/PGID convention (group MUST be set before user!)
-if (Number.isInteger(env.KES_PGID)) {
-  log.verbose(`PGID=${env.KES_PGID}`)
-  process.setgid(env.KES_PGID)
-}
-
-if (Number.isInteger(env.KES_PUID)) {
-  log.verbose(`PUID=${env.KES_PUID}`)
-  process.setuid(env.KES_PUID)
-}
-
-// close db before exiting (can't do async in the 'exit' handler)
-process.on('SIGTERM', shutdown)
-process.on('SIGINT', shutdown)
-
-// make sure child processes don't hang around
-process.on('exit', function () {
-  if (refs.server) refs.server.kill()
-  if (refs.scanner) refs.scanner.kill()
-})
-
-// debug: log stack trace for unhandled promise rejections
-process.on('unhandledRejection', (reason, p) => {
-  log.error('Unhandled Rejection:', p, 'reason:', reason)
-})
-
-// detect electron
-if (process.versions.electron) {
-  refs.electron = require('./lib/electron.js')({ env })
-  env.KES_PATH_DATA = refs.electron.app.getPath('userData')
-}
-
-Database.open({
-  file: path.join(env.KES_PATH_DATA, 'database.sqlite3'),
-  ro: false,
-}).then(db => {
-  if (refs.electron) {
-    process.on('serverWorker', action => {
-      const { type, payload } = action
-
-      if (type === SERVER_WORKER_STATUS) {
-        return refs.electron.setStatus('url', payload.url)
-      } else if (type === SERVER_WORKER_ERROR) {
-        return refs.electron.setError(action.error)
-      }
-    })
-  }
-
-  // start web server
-  require('./serverWorker.js')({ env, startScanner, stopScanner })
-}).catch(err => {
-  log.error(err.message)
-  process.exit(1)
-})
-
-function startScanner (onExit) {
-  if (refs.scanner === undefined) {
-    log.info('Starting media scanner process')
-    refs.scanner = childProcess.fork(path.join(__dirname, 'scannerWorker.js'), [], {
-      env: { ...env, KES_CHILD_PROCESS: 'scanner' },
-      gid: Number.isInteger(env.KES_PGID) ? env.KES_PGID : undefined,
-      uid: Number.isInteger(env.KES_PUID) ? env.KES_PUID : undefined,
-    })
-
-    refs.scanner.on('exit', (code, signal) => {
-      log.info(`Media scanner exited (${signal || code})`)
-      IPC.removeChild(refs.scanner)
-      delete refs.scanner
-
-      if (typeof onExit === 'function') onExit()
-    })
-
-    IPC.addChild(refs.scanner)
-  } else {
-    IPC.send({ type: SCANNER_CMD_START })
-  }
-}
-
-function stopScanner () {
-  if (refs.scanner) {
-    IPC.send({ type: SCANNER_CMD_STOP })
-  }
-}
-
-function shutdown (signal) {
-  log.info('Received %s', signal)
-
-  Database.close().then(() => {
-    log.info('Goodbye for now...')
-    process.exit(0)
-  }).catch(err => {
-    log.error(err.message)
-    process.exit(1)
-  })
-}

package/server/scannerWorker.js

@@ -1,58 +0,0 @@
-const path = require('path')
-const log = require('./lib/Log')(`scanner[${process.pid}]`)
-const Database = require('./lib/Database')
-const IPC = require('./lib/IPCBridge')
-const {
-  SCANNER_CMD_START,
-  SCANNER_CMD_STOP,
-} = require('../shared/actionTypes')
-
-let FileScanner, Prefs
-let _Scanner
-let _isScanQueued = true
-
-Database.open({
-  file: path.join(process.env.KES_PATH_DATA, 'database.sqlite3'),
-  ro: true,
-}).then(db => {
-  Prefs = require('./Prefs')
-  FileScanner = require('./Scanner/FileScanner')
-
-  IPC.use({
-    [SCANNER_CMD_START]: async () => {
-      log.info('Media scan requested (restarting)')
-      _isScanQueued = true
-      cancelScan()
-    },
-    [SCANNER_CMD_STOP]: async () => {
-      log.info('Stopping media scan (user requested)')
-      _isScanQueued = false
-      cancelScan()
-    }
-  })
-
-  startScan()
-}).catch(err => {
-  log.error(err.message)
-  process.exit(1)
-})
-
-async function startScan () {
-  log.info('Starting media scan')
-
-  while (_isScanQueued) {
-    _isScanQueued = false
-
-    const prefs = await Prefs.get()
-    _Scanner = new FileScanner(prefs)
-    await _Scanner.scan()
-  } // end while
-
-  process.exit(0)
-}
-
-function cancelScan () {
-  if (_Scanner) {
-    _Scanner.cancel()
-  }
-}

package/server/serverWorker.js

@@ -1,242 +0,0 @@
-const log = require('./lib/Log')('server')
-const path = require('path')
-const getIPAddress = require('./lib/getIPAddress')
-const http = require('http')
-const fs = require('fs')
-const { promisify } = require('util')
-const parseCookie = require('./lib/parseCookie')
-const jwtVerify = require('jsonwebtoken').verify
-const Koa = require('koa')
-const koaRouter = require('koa-router')
-const koaBody = require('koa-body')
-const koaFavicon = require('koa-favicon')
-const koaLogger = require('koa-logger')
-const koaMount = require('koa-mount')
-const koaRange = require('koa-range')
-const koaStatic = require('koa-static')
-
-const Prefs = require('./Prefs')
-const libraryRouter = require('./Library/router')
-const mediaRouter = require('./Media/router')
-const prefsRouter = require('./Prefs/router')
-const roomsRouter = require('./Rooms/router')
-const userRouter = require('./User/router')
-const pushQueuesAndLibrary = require('./lib/pushQueuesAndLibrary')
-const SocketIO = require('socket.io')
-const socketActions = require('./socket')
-const IPC = require('./lib/IPCBridge')
-const IPCLibraryActions = require('./Library/ipc')
-const IPCMediaActions = require('./Media/ipc')
-const {
-  SERVER_WORKER_STATUS,
-  SERVER_WORKER_ERROR,
-} = require('../shared/actionTypes')
-
-async function serverWorker ({ env, startScanner, stopScanner }) {
-  const indexFile = path.join(env.KES_PATH_WEBROOT, 'index.html')
-  const urlPath = env.KES_URL_PATH.replace(/\/?$/, '/') // force trailing slash
-  const jwtKey = await Prefs.getJwtKey(env.KES_ROTATE_KEY)
-  const app = new Koa()
-  let server, io
-
-  // called when middleware is finalized
-  function createServer () {
-    server = http.createServer(app.callback())
-
-    // http server error handler
-    server.on('error', function (err) {
-      log.error(err)
-
-      process.emit('serverWorker', {
-        type: SERVER_WORKER_ERROR,
-        error: err.message,
-      })
-
-      // not much we can do without a working server
-      process.exit(1)
-    })
-
-    // create socket.io server
-    io = SocketIO(server, {
-      path: urlPath + 'socket.io',
-      serveClient: false,
-    })
-
-    // attach socket.io handlers
-    socketActions(io, jwtKey)
-
-    // attach IPC action handlers
-    IPC.use(IPCLibraryActions(io))
-    IPC.use(IPCMediaActions(io))
-
-    // success callback in 3rd arg
-    server.listen(env.KES_PORT, () => {
-      const port = server.address().port
-      const url = `http://${getIPAddress()}${port === 80 ? '' : ':' + port}${urlPath}`
-      log.info(`Web server running at ${url}`)
-
-      process.emit('serverWorker', {
-        type: SERVER_WORKER_STATUS,
-        payload: { url },
-      })
-
-      // scanning on startup?
-      if (env.KES_SCAN) startScanner(() => pushQueuesAndLibrary(io))
-    })
-  }
-
-  // --------------------
-  // Begin Koa middleware
-  // --------------------
-
-  // server error handler
-  app.on('error', (err, ctx) => {
-    if (err.code === 'EPIPE') {
-      // these are common since browsers make multiple requests for media files
-      log.verbose(err.message)
-      return
-    }
-
-    // silence 4xx response "errors" (koa-logger should show these anyway)
-    if (ctx.response && ctx.response.status.toString().startsWith('4')) {
-      return
-    }
-
-    if (err.stack) log.error(err.stack)
-    else log.error(err)
-  })
-
-  // middleware error handler
-  app.use(async (ctx, next) => {
-    try {
-      await next()
-    } catch (err) {
-      ctx.status = err.status || 500
-      ctx.body = err.message
-      ctx.app.emit('error', err, ctx)
-    }
-  })
-
-  // http request/response logging
-  app.use(koaLogger((str, args) => (args.length === 6 && args[3] >= 500) ? log.error(str) : log.debug(str)))
-
-  app.use(koaFavicon(path.join(env.KES_PATH_ASSETS, 'favicon.ico')))
-  app.use(koaRange)
-  app.use(koaBody({ multipart: true }))
-
-  // all http requests
-  app.use(async (ctx, next) => {
-    ctx.jwtKey = jwtKey // used by login route
-
-    // skip JWT/session validation if non-API request or logging in/out
-    if (!ctx.request.path.startsWith(`${urlPath}api/`) ||
-      ctx.request.path === `${urlPath}api/login` ||
-      ctx.request.path === `${urlPath}api/logout`) {
-      return next()
-    }
-
-    // verify JWT
-    try {
-      const { keToken } = parseCookie(ctx.request.header.cookie)
-      ctx.user = jwtVerify(keToken, jwtKey)
-    } catch (err) {
-      ctx.user = {
-        dateUpdated: null,
-        isAdmin: false,
-        name: null,
-        roomId: null,
-        userId: null,
-        username: null,
-      }
-    }
-
-    // validated
-    ctx.io = io
-    ctx.startScanner = () => startScanner(() => pushQueuesAndLibrary(io))
-    ctx.stopScanner = stopScanner
-
-    await next()
-  })
-
-  // http api endpoints
-  const baseRouter = koaRouter({
-    prefix: urlPath.replace(/\/$/, '') // avoid double slashes with /api prefix
-  })
-
-  baseRouter.use(libraryRouter.routes())
-  baseRouter.use(mediaRouter.routes())
-  baseRouter.use(prefsRouter.routes())
-  baseRouter.use(roomsRouter.routes())
-  baseRouter.use(userRouter.routes())
-  app.use(baseRouter.routes())
-
-  // serve index.html with dynamic base tag at the main SPA routes
-  const createIndexMiddleware = content => {
-    const indexRoutes = [
-      urlPath,
-      ...['account', 'library', 'queue', 'player'].map(r => urlPath + r + '/')
-    ]
-
-    content = content.replace('<base href="/">', `<base href="${urlPath}">`)
-
-    return async (ctx, next) => {
-      // use a trailing slash for matching purposes
-      const reqPath = ctx.request.path.replace(/\/?$/, '/')
-
-      if (!indexRoutes.includes(reqPath)) {
-        return next()
-      }
-
-      ctx.set('content-type', 'text/html')
-      ctx.body = content
-      ctx.status = 200
-    }
-  }
-
-  if (env.NODE_ENV !== 'development') {
-    // make sure we handle index.html before koaStatic,
-    // otherwise it'll be served without dynamic base tag
-    app.use(createIndexMiddleware(await promisify(fs.readFile)(indexFile, 'utf8')))
-
-    // serve build and asset folders
-    app.use(koaMount(urlPath, koaStatic(env.KES_PATH_WEBROOT)))
-    app.use(koaMount(`${urlPath}assets`, koaStatic(env.KES_PATH_ASSETS)))
-
-    createServer()
-    return
-  }
-
-  // ----------------------
-  // Development middleware
-  // ----------------------
-  log.info('Enabling webpack dev and HMR middleware')
-  const webpack = require('webpack')
-  const webpackConfig = require('../config/webpack.config')
-  const compiler = webpack(webpackConfig)
-
-  compiler.hooks.done.tap('indexPlugin', async (params) => {
-    const indexContent = await new Promise((resolve, reject) => {
-      compiler.outputFileSystem.readFile(indexFile, 'utf8', (err, result) => {
-        if (err) return reject(err)
-        return resolve(result)
-      })
-    })
-
-    // @todo make this less hacky
-    if (!server) {
-      app.use(createIndexMiddleware(indexContent))
-      createServer()
-    }
-  })
-
-  const devMiddleware = require('./lib/getDevMiddleware')(compiler, { publicPath: urlPath })
-  app.use(devMiddleware)
-
-  const hotMiddleware = require('./lib/getHotMiddleware')(compiler)
-  app.use(hotMiddleware)
-
-  // serve assets since webpack-dev-server is unaware of this folder
-  app.use(koaMount(`${urlPath}assets`, koaStatic(env.KES_PATH_ASSETS)))
-}
-
-module.exports = serverWorker

package/server/socket.js

@@ -1,173 +0,0 @@
-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),
-    })
-  })
-}