karaoke-eternal 1.0.0

package/server/lib/IPCBridge.js

@@ -0,0 +1,115 @@
+const log = require('./Log')('IPCBridge')
+const {
+  _ERROR,
+  _SUCCESS,
+} = require('../../shared/actionTypes')
+
+const PROCESS_NAME = process.env.KES_CHILD_PROCESS || 'main'
+const children = []
+let handlers = {}
+const reqs = {}
+const isParent = typeof process.env.KES_CHILD_PROCESS === 'undefined' // @todo
+const isChild = !isParent
+let actionId = 0
+
+class IPCBridge {
+  static send (action) {
+    // log.debug(`${PROCESS_NAME} send: `, action.type)
+
+    if (isChild) {
+      process.send(action)
+      return
+    }
+
+    if (!children.length) throw new Error('no child processes')
+    children.forEach(p => p.send(action))
+  }
+
+  static req (action) {
+    const id = ++actionId
+    const promise = new Promise((resolve, reject) => {
+      reqs[id] = { resolve, reject }
+    })
+
+    action = {
+      ...action,
+      meta: {
+        ...action.meta,
+        ipcId: id,
+        ipcName: PROCESS_NAME,
+      }
+    }
+
+    this.send(action)
+
+    return promise
+  }
+
+  static _handle (action) {
+    const { error, meta, type } = action
+
+    // is it an ACK for an outstanding request?
+    if (meta && meta.ipcName === PROCESS_NAME && reqs[meta.ipcId]) {
+      if (error) {
+        reqs[meta.ipcId].reject(error)
+      } else {
+        reqs[meta.ipcId].resolve(action.payload)
+      }
+
+      // log.debug(`${PROCESS_NAME} ack:`, type)
+
+      delete reqs[meta.ipcId]
+      return
+    }
+
+    // log.debug(`${PROCESS_NAME} rcv:`, type)
+
+    // handle request
+    if (!type || typeof handlers[type] !== 'function') {
+      log.debug(`${PROCESS_NAME} no handler for action: ${type}`)
+      return
+    }
+
+    // @todo handle non-promises?
+    handlers[type](action).then(res => {
+      if (meta && !meta.noAck) {
+        this.send({
+          ...action,
+          type: type + _SUCCESS,
+          payload: res,
+        })
+      }
+    }).catch(err => {
+      this.send({
+        ...action,
+        type: type + _ERROR,
+        error: err,
+      })
+
+      log.debug(`${PROCESS_NAME} error in ipc action ${type}: ${err.message}`)
+    })
+  }
+
+  static addChild (p) {
+    // message from child process
+    p.on('message', action => this._handle(action))
+    children.push(p)
+  }
+
+  static removeChild (p) { children.splice(children.indexOf(p), 1) }
+
+  // @todo make real middleware?
+  static use (obj) {
+    handlers = {
+      ...handlers,
+      ...obj,
+    }
+  }
+}
+
+module.exports = IPCBridge
+
+// make sure IPC channel stays open
+if (isChild) {
+  process.on('message', IPCBridge._handle)
+}

package/server/lib/Log.js

@@ -0,0 +1,71 @@
+const util = require('util')
+const _levels = [false, 'error', 'warn', 'info', 'verbose', 'debug']
+let _defaultInstance
+
+class Log {
+  constructor (logId, cfg) {
+    this.logger = require('electron-log').create(logId)
+
+    // defaults
+    this.logger.transports.console.level = 'debug'
+    this.logger.transports.file.level = false
+    this.logger.transports.file.fileName = logId + '.log'
+
+    for (const transport in cfg) {
+      this.logger.transports[transport].level = cfg[transport]
+    }
+  }
+
+  setDefaultInstance () {
+    _defaultInstance = this
+    return this
+  }
+
+  static resolve (userLevel, defaultLevel) {
+    return typeof _levels[userLevel] === 'undefined'
+      ? _levels[defaultLevel]
+      : _levels[userLevel]
+  }
+}
+
+class IPCLog {
+  constructor (scope = '') {
+    const IPC = require('./IPCBridge')
+    const { SCANNER_WORKER_LOG } = require('../../shared/actionTypes')
+    const send = (level, str, ...args) => {
+      IPC.send({
+        type: SCANNER_WORKER_LOG,
+        payload: {
+          level,
+          msg: `${scope ? scope + ': ' : ''}${util.format(str, ...args)}`,
+        },
+        meta: {
+          noAck: true,
+        }
+      })
+    }
+
+    return {
+      error: send.bind(this, 'error'),
+      warn: send.bind(this, 'warn'),
+      info: send.bind(this, 'info'),
+      verbose: send.bind(this, 'verbose'),
+      debug: send.bind(this, 'debug'),
+    }
+  }
+}
+
+function getLogger (scope = '') {
+  if (!_defaultInstance) throw new Error('no default logger instance')
+  return _defaultInstance.logger.scope(scope)
+}
+
+function getIPCLogger (scope = '') {
+  return new IPCLog(scope)
+}
+
+// default export
+module.exports = process.env.KES_CHILD_PROCESS ? getIPCLogger : getLogger
+
+// used by main.js to instantiate the loggers
+module.exports.Log = Log

package/server/lib/bcrypt.js

@@ -0,0 +1,24 @@
+const bcrypt = require('bcrypt')
+
+function hash (myPlaintextPassword, saltRounds) {
+  return new Promise(function (resolve, reject) {
+    bcrypt.hash(myPlaintextPassword, saltRounds, function (err, hash) {
+      if (err) { return reject(err) }
+      return resolve(hash)
+    })
+  })
+}
+
+function compare (data, hash) {
+  return new Promise(function (resolve, reject) {
+    bcrypt.compare(data, hash, function (err, matched) {
+      if (err) { return reject(err) }
+      return resolve(matched)
+    })
+  })
+}
+
+module.exports = {
+  hash,
+  compare,
+}

package/server/lib/cli.js

@@ -0,0 +1,136 @@
+const os = require('os')
+const path = require('path')
+const baseDir = path.resolve(path.dirname(require.main.filename), '..')
+
+const env = {
+  NODE_ENV: process.env.NODE_ENV,
+  KES_CONSOLE_LEVEL: parseInt(process.env.KES_CONSOLE_LEVEL, 10),
+  KES_LOG_LEVEL: parseInt(process.env.KES_LOG_LEVEL, 10),
+  KES_PATH_ASSETS: path.join(baseDir, 'assets'),
+  KES_PATH_DATA: process.env.KES_PATH_DATA || getAppPath('Karaoke Eternal Server'),
+  KES_PATH_WEBROOT: path.join(baseDir, 'build'),
+  KES_PORT: parseInt(process.env.KES_PORT, 10) || 0,
+  KES_ROTATE_KEY: ['1', 'true'].includes(process.env.KES_ROTATE_KEY?.toLowerCase()),
+  KES_SCAN: ['1', 'true'].includes(process.env.KES_SCAN?.toLowerCase()),
+  KES_SCAN_CONSOLE_LEVEL: parseInt(process.env.KES_SCAN_CONSOLE_LEVEL, 10),
+  KES_SCAN_LOG_LEVEL: parseInt(process.env.KES_SCAN_LOG_LEVEL, 10),
+  KES_URL_PATH: process.env.KES_URL_PATH || '/',
+  // support PUID/PGID convention
+  KES_PUID: parseInt(process.env.PUID, 10),
+  KES_PGID: parseInt(process.env.PGID, 10),
+}
+
+const yargs = require('yargs')
+  .version(false) // disable default handler
+  .option('consoleLevel', {
+    describe: 'Web server console output level (default=4)',
+    number: true,
+    requiresArg: true,
+  })
+  .option('data', {
+    describe: 'Absolute path of folder for database files',
+    requiresArg: true,
+    type: 'string',
+  })
+  .option('logLevel', {
+    describe: 'Web server log file level (default=3)',
+    number: true,
+    requiresArg: true,
+  })
+  .option('p', {
+    alias: 'port',
+    describe: 'Web server port (default=0/auto)',
+    number: true,
+    requiresArg: true,
+  })
+  .option('rotateKey', {
+    describe: 'Rotate the session key at startup',
+  })
+  .option('scan', {
+    describe: 'Run the media scanner at startup',
+  })
+  .option('scanConsoleLevel', {
+    describe: 'Media scanner console output level (default=4)',
+    number: true,
+    requiresArg: true,
+  })
+  .option('scanLogLevel', {
+    describe: 'Media scanner log file level (default=3)',
+    number: true,
+    requiresArg: true,
+  })
+  .option('urlPath', {
+    describe: 'Web server URL base path (default=/)',
+    requiresArg: true,
+    type: 'string',
+  })
+  .option('v', {
+    alias: 'version',
+    describe: 'Output the Karaoke Eternal Server version and exit',
+  })
+  .usage('$0')
+  .usage('  Logging options use the following numeric levels:')
+  .usage('  0=off, 1=error, 2=warn, 3=info, 4=verbose, 5=debug')
+
+let argv = yargs.argv
+
+let _app
+if (process.versions.electron) {
+  _app = require('electron').app
+
+  // see https://github.com/yargs/yargs/blob/master/docs/api.md#argv
+  if (_app.isPackaged) {
+    argv = yargs.parse(process.argv.slice(1))
+  }
+}
+
+if (argv.version) {
+  console.log(_app ? _app.getVersion() : process.env.npm_package_version)
+  process.exit(0)
+}
+
+// CLI options take precendence over env vars
+if (argv.scan) {
+  env.KES_SCAN = true
+}
+
+if (argv.rotateKey) {
+  env.KES_ROTATE_KEY = true
+}
+
+const opts = {
+  data: 'KES_PATH_DATA',
+  port: 'KES_PORT',
+  scanConsoleLevel: 'KES_SCAN_CONSOLE_LEVEL',
+  scanLogLevel: 'KES_SCAN_LOG_LEVEL',
+  serverConsoleLevel: 'KES_CONSOLE_LEVEL',
+  serverLogLevel: 'KES_LOG_LEVEL',
+  urlPath: 'KES_URL_PATH',
+}
+
+for (const opt in opts) {
+  if (typeof argv[opt] !== 'undefined') {
+    env[opts[opt]] = argv[opt]
+    process.env[opts[opt]] = argv[opt]
+  }
+}
+
+module.exports = env
+
+function getAppPath (appName) {
+  const home = os.homedir ? os.homedir() : process.env.HOME
+
+  switch (process.platform) {
+    case 'darwin': {
+      return path.join(home, 'Library', 'Application Support', appName)
+    }
+
+    case 'win32': {
+      return process.env.APPDATA || path.join(home, 'AppData', 'Roaming', appName)
+    }
+
+    default: {
+      return process.env.XDG_CONFIG_HOME || path.join(home, '.config', appName)
+    }
+  }
+}

package/server/lib/electron.js

@@ -0,0 +1,81 @@
+const { app, shell, clipboard, dialog, BrowserWindow, Tray, Menu } = require('electron')
+const path = require('path')
+const log = require('./Log')(`main:electron[${process.pid}]`)
+
+// Keep a global reference of the window object, if you don't, the window will
+// be closed automatically when the JavaScript object is garbage collected.
+let win
+let tray = null
+const status = {
+  url: '',
+}
+
+module.exports = ({ env }) => {
+  // event handlers
+  app.on('ready', createWindow)
+  app.on('quit', (e, code) => { log.info(`exiting (${code})`) })
+
+  function createWindow () {
+    win = new BrowserWindow({
+      show: false,
+      skipTaskbar: true, // windows
+    })
+
+    // macOS
+    if (app.dock) {
+      app.dock.hide()
+    }
+
+    if (process.platform === 'win32') {
+      // white 32x32
+      tray = new Tray(path.join(env.KES_PATH_ASSETS, 'mic-white@2x.png'))
+    } else {
+      // blackish 32x32 (template works in light and dark macOS modes)
+      tray = new Tray(path.join(env.KES_PATH_ASSETS, 'mic-blackTemplate.png'))
+      tray.setPressedImage(path.join(env.KES_PATH_ASSETS, 'mic-white.png'))
+    }
+
+    tray.setToolTip('Karaoke Eternal Server v' + app.getVersion())
+    tray.on('double-click', launchBrowser)
+    updateMenu()
+
+    // Emitted when the window is closed.
+    win.on('closed', () => {
+      win = null
+      tray = null
+    })
+  }
+
+  function launchBrowser () {
+    if (status.url) {
+      shell.openExternal(status.url)
+    }
+  }
+
+  function setError (msg) {
+    dialog.showErrorBox('Karaoke Eternal Server', `Error: ${msg}`)
+  }
+
+  function setStatus (key, val) {
+    status[key] = val
+    updateMenu()
+  }
+
+  function updateMenu () {
+    if (!tray) return
+
+    const menu = [
+      { label: 'Karaoke Eternal Server v' + app.getVersion(), enabled: false },
+      { label: status.url, enabled: false },
+      { type: 'separator' },
+      { label: 'Open in browser', click: launchBrowser },
+      { label: 'Copy URL', click: () => clipboard.writeText(status.url) },
+      { type: 'separator' },
+      { label: 'Quit Karaoke Eternal Server', role: 'quit' },
+    ]
+
+    tray.setContextMenu(Menu.buildFromTemplate(menu))
+  }
+
+  return { app, setStatus, setError }
+}

package/server/lib/getCdgName.js

@@ -0,0 +1,20 @@
+const { promisify } = require('util')
+const fs = require('fs')
+const stat = promisify(fs.stat)
+const getPerms = require('./getPermutations')
+
+module.exports = async function getCdgName (file) {
+  // upper and lowercase permutations since fs may be case-sensitive
+  for (const ext of getPerms('cdg')) {
+    const cdg = file.substring(0, file.lastIndexOf('.') + 1) + ext
+
+    try {
+      await stat(cdg)
+      return cdg
+    } catch (err) {
+      // try another permutation
+    }
+  } // end for
+
+  return false
+}

package/server/lib/getDevMiddleware.js

@@ -0,0 +1,51 @@
+/*
+  Copyright © 2016 Andrew Powell
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of this Source Code Form.
+*/
+const webpackDevMiddleware = require('webpack-dev-middleware')
+
+module.exports = (compiler, opts) => {
+  const middleware = webpackDevMiddleware(compiler, opts)
+
+  return (ctx, next) => {
+    // wait for webpack-dev-middleware to signal that the build is ready
+    const ready = new Promise((resolve, reject) => {
+      for (const comp of [].concat(compiler.compilers || compiler)) {
+        comp.hooks.failed.tap('KoaWebpack', (error) => {
+          reject(error)
+        })
+      }
+
+      middleware.waitUntilValid(() => {
+        resolve(true)
+      })
+    })
+
+    // tell webpack-dev-middleware to handle the request
+    const init = new Promise((resolve) => {
+      // call express-style middleware
+      middleware(
+        ctx.req,
+        {
+          end: (content) => {
+            // eslint-disable-next-line no-param-reassign
+            ctx.body = content
+            resolve()
+          },
+          getHeader: ctx.get.bind(ctx),
+          setHeader: ctx.set.bind(ctx),
+          locals: ctx.state
+        },
+        () => resolve(next())
+      )
+    })
+
+    return Promise.all([ready, init])
+  }
+}

package/server/lib/getFolders.js

@@ -0,0 +1,10 @@
+const path = require('path')
+const fs = require('fs')
+const { promisify } = require('util')
+const readdir = promisify(fs.readdir)
+
+const getFolders = dir => readdir(dir, { withFileTypes: true })
+  .then(list => Promise.all(list.map(ent => ent.isDirectory() ? path.resolve(dir, ent.name) : null)))
+  .then(list => list.filter(f => !!f).sort())
+
+module.exports = getFolders

package/server/lib/getHotMiddleware.js

@@ -0,0 +1,27 @@
+// based on https://github.com/tnnevol/webpack-hot-middleware-for-koa2
+
+const webpackHotMiddleware = require('webpack-hot-middleware')
+
+module.exports = (compiler, opts) => {
+  const middleware = webpackHotMiddleware(compiler, opts)
+
+  return async (ctx, next) => {
+    const { end: originalEnd } = ctx.res
+
+    const runNext = await new Promise(resolve => {
+      ctx.res.end = function () {
+        originalEnd.apply(this, arguments)
+        resolve(false)
+      }
+
+      // call express-style middleware
+      middleware(ctx.req, ctx.res, () => {
+        resolve(true)
+      })
+    })
+
+    if (runNext) {
+      await next()
+    }
+  }
+}

package/server/lib/getIPAddress.js

@@ -0,0 +1,16 @@
+// https://gist.github.com/savokiss/96de34d4ca2d37cbb8e0799798c4c2d3
+module.exports = function () {
+  const interfaces = require('os').networkInterfaces()
+
+  for (const devName in interfaces) {
+    const iface = interfaces[devName]
+
+    for (let i = 0; i < iface.length; i++) {
+      const alias = iface[i]
+
+      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+        return alias.address
+      }
+    }
+  }
+}

package/server/lib/getPermutations.js

@@ -0,0 +1,21 @@
+// return all uppercase and lowercase permutations of str
+// based on https://stackoverflow.com/a/27995370
+function getPermutations (str) {
+  const results = []
+  const arr = str.split('')
+  const len = Math.pow(arr.length, 2)
+
+  for (let i = 0; i < len; i++) {
+    for (let k = 0, j = i; k < arr.length; k++, j >>= 1) {
+      arr[k] = (j & 1) ? arr[k].toUpperCase() : arr[k].toLowerCase()
+    }
+
+    const combo = arr.join('')
+    results.push(combo)
+  }
+
+  // remove duplicates
+  return results.filter((ext, pos, self) => self.indexOf(ext) === pos)
+}
+
+module.exports = getPermutations

package/server/lib/getWindowsDrives.js

@@ -0,0 +1,30 @@
+const childProcess = require('child_process')
+const command = 'wmic logicaldisk get Caption, ProviderName'
+// sample output:
+//
+// Caption  ProviderName
+// C:
+// D:
+// E:       \\vboxsrv\Downloads
+// F:       \\vboxsrv\Karaoke
+
+module.exports = function () {
+  return new Promise((resolve, reject) => {
+    childProcess.exec(command, (err, stdout) => {
+      if (err) {
+        return reject(err)
+      }
+
+      // split to lines
+      const rows = stdout.split(/\r?\n/)
+
+      // first line is heading(s)
+      rows.shift()
+
+      resolve(rows.filter(r => !!r.trim()).map(r => ({
+        path: r.trim().substring(0, 2) + '\\',
+        label: r,
+      })))
+    })
+  })
+}

package/server/lib/parseCookie.js

@@ -0,0 +1,12 @@
+// cookie helper based on
+// http://stackoverflow.com/questions/3393854/get-and-set-a-single-cookie-with-node-js-http-server
+module.exports = function parseCookie (cookie) {
+  const list = {}
+
+  cookie && cookie.split(';').forEach(c => {
+    const parts = c.split('=')
+    list[parts.shift().trim()] = decodeURI(parts.join('='))
+  })
+
+  return list
+}

package/server/lib/pushQueuesAndLibrary.js

@@ -0,0 +1,29 @@
+const Library = require('../Library')
+const Queue = require('../Queue')
+const Rooms = require('../Rooms')
+const {
+  LIBRARY_PUSH,
+  QUEUE_PUSH,
+} = require('../../shared/actionTypes')
+
+async function pushQueuesAndLibrary (io) {
+  // emit (potentially) updated queues to each room
+  // it's important that this happens before the library is pushed,
+  // otherwise queue items might reference newly non-existent songs
+  for (const { room, roomId } of Rooms.getActive(io)) {
+    io.to(room).emit('action', {
+      type: QUEUE_PUSH,
+      payload: await Queue.get(roomId),
+    })
+  }
+
+  // invalidate cache
+  Library.cache.version = null
+
+  io.emit('action', {
+    type: LIBRARY_PUSH,
+    payload: await Library.get(),
+  })
+}
+
+module.exports = pushQueuesAndLibrary