karaoke-eternal 1.0.0

package/server/lib/schemas/001-initial-schema.sql

@@ -0,0 +1,98 @@
+-- Up
+CREATE TABLE IF NOT EXISTS "artists" (
+  "artistId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "name" text NOT NULL COLLATE NOCASE,
+  "nameNorm" text NOT NULL COLLATE NOCASE
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idxNameNorm ON "artists" ("nameNorm" ASC);
+
+CREATE TABLE IF NOT EXISTS "media" (
+  mediaId integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  songId integer NOT NULL REFERENCES songs(songId) DEFERRABLE INITIALLY DEFERRED,
+  pathId integer NOT NULL,
+  relPath text NOT NULL,
+  duration integer NOT NULL,
+  isPreferred integer(1) NOT NULL DEFAULT(0),
+  dateAdded integer NOT NULL DEFAULT(0),
+  dateUpdated integer NOT NULL DEFAULT(0)
+);
+
+CREATE INDEX IF NOT EXISTS idxSong ON "media" ("songId" ASC);
+
+CREATE TABLE IF NOT EXISTS "paths" (
+  "pathId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "path" text NOT NULL,
+  "priority" integer NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS "prefs" (
+  "key" text PRIMARY KEY NOT NULL,
+  "data" text NOT NULL
+);
+
+INSERT INTO prefs (key,data) VALUES ('isFirstRun','true');
+
+CREATE TABLE IF NOT EXISTS "queue" (
+  "queueId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "roomId" integer NOT NULL REFERENCES rooms(roomId) DEFERRABLE INITIALLY DEFERRED,
+  "songId" integer NOT NULL,
+  "userId" integer NOT NULL REFERENCES users(userId) DEFERRABLE INITIALLY DEFERRED
+);
+
+CREATE INDEX IF NOT EXISTS idxRoom ON "queue" ("roomId" ASC);
+
+CREATE TABLE IF NOT EXISTS "rooms" (
+  "roomId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "name" text NOT NULL,
+  "status" text NOT NULL,
+  "password" text,
+  "dateCreated" text NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS "songs" (
+  "songId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "artistId" integer NOT NULL REFERENCES artists(artistId) DEFERRABLE INITIALLY DEFERRED,
+  "title" text NOT NULL COLLATE NOCASE,
+  "titleNorm" text NOT NULL COLLATE NOCASE
+);
+
+CREATE INDEX IF NOT EXISTS idxTitleNorm ON "songs" ("titleNorm" ASC);
+
+CREATE TABLE IF NOT EXISTS "artistStars" (
+  "userId" integer NOT NULL REFERENCES users(userId) DEFERRABLE INITIALLY DEFERRED,
+  "artistId" integer NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idxUserArtist ON "artistStars" ("userId" ASC, "artistId" ASC);
+
+CREATE TABLE IF NOT EXISTS "songStars" (
+  "userId" integer NOT NULL REFERENCES users(userId) DEFERRABLE INITIALLY DEFERRED,
+  "songId" integer NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idxUserSong ON "songStars" ("userId" ASC, "songId" ASC);
+
+CREATE TABLE IF NOT EXISTS "users" (
+  "userId" integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  "username" text NOT NULL,
+  "password" text NOT NULL,
+  "name" text NOT NULL,
+  "isAdmin" integer(1) NOT NULL,
+  "image" blob,
+  "dateCreated" integer NOT NULL DEFAULT(0),
+  "dateUpdated" integer NOT NULL DEFAULT(0)
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idxUsername ON "users" ("username" ASC);
+
+-- Down
+DROP TABLE artists;
+DROP TABLE media;
+DROP TABLE prefs;
+DROP TABLE queue;
+DROP TABLE rooms;
+DROP TABLE songs;
+DROP TABLE artistStars;
+DROP TABLE songStars;
+DROP TABLE users;

package/server/lib/schemas/002-replaygain.sql

@@ -0,0 +1,9 @@
+-- Up
+ALTER TABLE "media" ADD COLUMN "rgTrackGain" REAL;
+ALTER TABLE "media" ADD COLUMN "rgTrackPeak" REAL;
+
+INSERT OR IGNORE INTO prefs (key,data) VALUES ('isReplayGainEnabled','false');
+
+-- Down
+ALTER TABLE "media" DROP COLUMN "rgTrackGain";
+ALTER TABLE "media" DROP COLUMN "rgTrackPeak";

package/server/lib/schemas/003-queue-linked-list.sql

@@ -0,0 +1,16 @@
+-- Up
+ALTER TABLE "queue" ADD COLUMN "prevQueueId" INTEGER REFERENCES queue(queueId) DEFERRABLE INITIALLY DEFERRED;
+
+CREATE INDEX IF NOT EXISTS idxPrevQueueId ON "queue" ("prevQueueId" ASC);
+
+UPDATE queue
+SET prevQueueId = (
+	SELECT MAX(q.queueId)
+	FROM queue q
+	WHERE q.queueId < queue.queueId AND q.roomId = queue.roomId
+);
+
+-- Down
+DROP INDEX IF EXISTS idxPrevQueueId;
+
+ALTER TABLE "queue" DROP COLUMN "prevQueueId";

package/server/main.js

@@ -0,0 +1,135 @@
+#!/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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,242 @@
+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