karaoke-eternal 1.0.0 → 2.0.0-beta.5

package/build/server/main.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import childProcess from 'child_process';
+import env from './lib/cli.js';
+import path from 'path';
+import { initLogger } from './lib/Log.js';
+import { parsePathIds } from './lib/util.js';
+import { PREFS_PATHS_CHANGED, REQUEST_SCAN, REQUEST_SCAN_STOP, SCANNER_WORKER_EXITED, WATCHER_WORKER_EVENT, WATCHER_WORKER_WATCH, } from '../shared/actionTypes.js';
+const log = initLogger('server', {
+    console: {
+        level: env.KES_SERVER_CONSOLE_LEVEL ?? (env.NODE_ENV === 'development' ? 5 : 4),
+        useStyles: env.KES_CONSOLE_COLORS ?? undefined,
+    },
+    file: {
+        level: env.KES_SERVER_LOG_LEVEL ?? (env.NODE_ENV === 'development' ? 0 : 3),
+    },
+}).scope(`main[${process.pid}]`);
+const refs = {};
+const shutdownHandlers = [];
+let IPC;
+process.on(PREFS_PATHS_CHANGED, startWatcher);
+// 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);
+}
+// handle shutdown gracefully
+['SIGINT', 'SIGTERM', 'SIGUSR1', 'SIGUSR2', 'uncaughtException'].forEach((event) => {
+    process.on(event, shutdown);
+});
+// make sure child processes don't hang around
+process.on('exit', () => Object.values(refs).forEach(ref => ref.kill()));
+// debug: log stack trace for unhandled promise rejections
+process.on('unhandledRejection', (reason) => {
+    log.error('Unhandled Rejection:', reason);
+});
+(async function () {
+    // init database
+    const { open, close } = await import('./lib/Database.js');
+    shutdownHandlers.push(close);
+    await open({
+        file: path.join(env.KES_PATH_DATA, 'database.sqlite3'),
+        ro: false,
+    });
+    // init IPC listener
+    const IPCBridge = await import('./lib/IPCBridge.js');
+    IPC = IPCBridge.default;
+    IPC.use({
+        [WATCHER_WORKER_EVENT]: ({ payload }) => {
+            startScanner(payload.pathId);
+        },
+    });
+    // start web server
+    const serverWorker = await import('./serverWorker.js');
+    serverWorker.default({ env, startScanner, stopScanner, shutdownHandlers });
+    // scanning on startup?
+    const pathIds = parsePathIds(env.KES_SCAN);
+    if (pathIds)
+        startScanner(pathIds);
+    // any paths with watching enabled?
+    const { default: Prefs } = await import('./Prefs/Prefs.js');
+    const { paths } = await Prefs.get();
+    if (paths.result.find(pathId => paths.entities[pathId].prefs?.isWatchingEnabled)) {
+        startWatcher(paths);
+    }
+})();
+function startWatcher(paths) {
+    if (refs.watcher === undefined) {
+        log.info('Starting folder watcher process');
+        refs.watcher = childProcess.fork(path.join(import.meta.dirname, 'watcherWorker.js'), [], {
+            env: { KES_ENV_JSON: JSON.stringify(env), KES_CHILD_PROCESS: 'watcher' },
+            gid: Number.isInteger(env.KES_PGID) ? env.KES_PGID : undefined,
+            uid: Number.isInteger(env.KES_PUID) ? env.KES_PUID : undefined,
+        });
+        refs.watcher.on('exit', (code, signal) => {
+            log.info(`Folder watcher process exited (${signal || code})`);
+            IPC.removeChild(refs.watcher);
+            delete refs.watcher;
+        });
+        IPC.addChild(refs.watcher);
+    }
+    IPC.send({
+        type: WATCHER_WORKER_WATCH,
+        payload: { paths },
+    });
+}
+function startScanner(pathIds) {
+    if (refs.scanner === undefined) {
+        log.info('Starting media scanner process');
+        refs.scanner = childProcess.fork(path.join(import.meta.dirname, 'scannerWorker.js'), [pathIds.toString()], {
+            env: { KES_ENV_JSON: JSON.stringify(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) => {
+            IPC.removeChild(refs.scanner);
+            delete refs.scanner;
+            process.emit(SCANNER_WORKER_EXITED, { signal, code });
+            log.info(`Media scanner process exited (${signal || code})`);
+        });
+        IPC.addChild(refs.scanner);
+    }
+    else {
+        IPC.send({ type: REQUEST_SCAN, payload: { pathIds } });
+    }
+}
+function stopScanner() {
+    if (refs.scanner) {
+        IPC.send({ type: REQUEST_SCAN_STOP });
+    }
+}
+async function shutdown(signal) {
+    log.info('Received %s', signal);
+    await Promise.allSettled(shutdownHandlers.map(f => f()));
+    process.exit(0); // eslint-disable-line n/no-process-exit
+}

package/build/server/scannerWorker.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import { parsePathIds } from './lib/util.js';
+import { initLogger } from './lib/Log.js';
+import { REQUEST_SCAN, REQUEST_SCAN_STOP, SCANNER_WORKER_STATUS, } from '../shared/actionTypes.js';
+const env = JSON.parse(process.env.KES_ENV_JSON);
+const log = initLogger('scanner', {
+    console: {
+        level: env.KES_SCANNER_CONSOLE_LEVEL ?? (env.NODE_ENV === 'development' ? 5 : 4),
+        useStyles: env.KES_CONSOLE_COLORS ?? undefined,
+    },
+    file: {
+        level: env.KES_SCANNER_LOG_LEVEL ?? (env.NODE_ENV === 'development' ? 0 : 3),
+    },
+}).scope(`scanner[${process.pid}]`);
+let IPC;
+(async function () {
+    // init database
+    const { open } = await import('./lib/Database.js');
+    await open({
+        file: path.join(env.KES_PATH_DATA, 'database.sqlite3'),
+        ro: true,
+    });
+    // init IPC listener
+    const IPCBridge = await import('./lib/IPCBridge.js');
+    IPC = IPCBridge.default;
+    IPC.use({
+        [REQUEST_SCAN]: ({ payload }) => {
+            q.queue(payload.pathIds); // no need to await; fire and forget
+        },
+        [REQUEST_SCAN_STOP]: () => {
+            q.stop();
+        },
+    });
+    const { default: ScannerQueue } = await import('./Scanner/ScannerQueue.js');
+    const q = new ScannerQueue(onIteration, onDone);
+    const args = process.argv.slice(2);
+    log.debug('received arguments: %s', args);
+    if (!args.length) {
+        process.exit(1); // eslint-disable-line n/no-process-exit
+    }
+    const pathIds = parsePathIds(args[0]);
+    log.debug('parsed pathIds: %s', pathIds);
+    q.queue(pathIds);
+})();
+// @todo
+function onIteration(stats) {
+    return stats;
+}
+function onDone() {
+    IPC.send({
+        type: SCANNER_WORKER_STATUS,
+        payload: {
+            isScanning: false,
+            pct: 100,
+            text: 'Finished',
+        },
+    });
+    process.exit(0); // eslint-disable-line n/no-process-exit
+}

package/build/server/serverWorker.js

@@ -0,0 +1,219 @@
+import getLogger from './lib/Log.js';
+import path from 'path';
+import getIPAddress from './lib/getIPAddress.js';
+import http from 'http';
+import fs from 'fs';
+import { promisify } from 'util';
+import parseCookie from './lib/parseCookie.js';
+import jsonWebToken from 'jsonwebtoken';
+import Koa from 'koa';
+import koaRouter from '@koa/router';
+import { koaBody } from 'koa-body';
+import koaFavicon from 'koa-favicon';
+import koaLogger from 'koa-logger';
+import koaMount from 'koa-mount';
+import koaRange from 'koa-range';
+import koaStatic from 'koa-static';
+import Media from './Media/Media.js';
+import Prefs from './Prefs/Prefs.js';
+import libraryRouter from './Library/router.js';
+import mediaRouter from './Media/router.js';
+import prefsRouter from './Prefs/router.js';
+import roomsRouter from './Rooms/router.js';
+import userRouter from './User/router.js';
+import pushQueuesAndLibrary from './lib/pushQueuesAndLibrary.js';
+import { Server as SocketIO } from 'socket.io';
+import socketActions from './socket.js';
+import IPC from './lib/IPCBridge.js';
+import IPCLibraryActions from './Library/ipc.js';
+import IPCMediaActions from './Media/ipc.js';
+import { SCANNER_WORKER_EXITED, SERVER_WORKER_STATUS, SERVER_WORKER_ERROR } from '../shared/actionTypes.js';
+const log = getLogger('server');
+const { verify: jwtVerify } = jsonWebToken;
+async function serverWorker({ env, startScanner, stopScanner, shutdownHandlers }) {
+    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.message);
+            process.emit('serverWorker', {
+                type: SERVER_WORKER_ERROR,
+                error: err.message,
+            });
+            // not much we can do without a working server
+            throw err;
+        });
+        // create socket.io server
+        io = new 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 },
+            });
+        });
+        // when scanner exits cleanly
+        process.on(SCANNER_WORKER_EXITED, async ({ code }) => {
+            if (code !== 0)
+                return;
+            await Media.cleanup();
+            await pushQueuesAndLibrary(io);
+        });
+        // handle shutdown gracefully
+        shutdownHandlers.push(() => new Promise((resolve) => {
+            // also calls http server's close method, which ultimately handles the callback
+            io.close(resolve);
+            // HMR keep-alive connections can prevent http server from fully closing
+            server.closeAllConnections();
+        }));
+    }
+    // --------------------
+    // 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 {
+            ctx.user = {
+                dateUpdated: null,
+                isAdmin: false,
+                isGuest: false,
+                name: null,
+                roomId: null,
+                userId: null,
+                username: null,
+            };
+        }
+        // validated
+        ctx.io = io;
+        ctx.startScanner = startScanner;
+        ctx.stopScanner = stopScanner;
+        await next();
+    });
+    // http api endpoints
+    const baseRouter = new 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 { default: webpack } = await import('webpack'); // eslint-disable-line n/no-unpublished-import
+    const { default: webpackConfig } = await import('../config/webpack.config.js'); // eslint-disable-line n/no-unpublished-import
+    const compiler = webpack(webpackConfig);
+    compiler.hooks.done.tap('indexPlugin', async () => {
+        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 { default: webpackDevMiddleware } = await import('webpack-dev-middleware'); // eslint-disable-line n/no-unpublished-import
+    app.use(webpackDevMiddleware.koaWrapper(compiler, { publicPath: urlPath }));
+    const { default: hotMiddleware } = await import('./lib/getHotMiddleware.js');
+    app.use(hotMiddleware(compiler));
+    // serve assets since webpack-dev-server is unaware of this folder
+    app.use(koaMount(`${urlPath}assets`, koaStatic(env.KES_PATH_ASSETS)));
+}
+export default serverWorker;

package/build/server/socket.js

@@ -0,0 +1,134 @@
+import getLogger from './lib/Log.js';
+import jsonWebToken from 'jsonwebtoken';
+import parseCookie from './lib/parseCookie.js';
+import Library from './Library/Library.js';
+import LibrarySocket from './Library/socket.js';
+import PlayerSocket from './Player/socket.js';
+import Prefs from './Prefs/Prefs.js';
+import PrefsSocket from './Prefs/socket.js';
+import Rooms from './Rooms/Rooms.js';
+import RoomsSocket from './Rooms/socket.js';
+import Queue from './Queue/Queue.js';
+import QueueSocket from './Queue/socket.js';
+import { LIBRARY_PUSH, QUEUE_PUSH, STARS_PUSH, STAR_COUNTS_PUSH, PLAYER_STATUS, PLAYER_LEAVE, PREFS_PUSH, SOCKET_AUTH_ERROR, _ERROR, } from '../shared/actionTypes.js';
+const log = getLogger('server');
+const handlers = {
+    ...LibrarySocket,
+    ...QueueSocket,
+    ...PlayerSocket,
+    ...PrefsSocket,
+    ...RoomsSocket,
+};
+const { verify: jwtVerify } = jsonWebToken;
+export default 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/build/server/watcherWorker.js

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import pathLib from 'path';
+import { initLogger } from './lib/Log.js';
+import accumulatedThrottle from './lib/accumulatedThrottle.js';
+import fileTypes from './Media/fileTypes.js';
+import { WATCHER_WORKER_EVENT, WATCHER_WORKER_WATCH, } from '../shared/actionTypes.js';
+const env = JSON.parse(process.env.KES_ENV_JSON);
+const log = initLogger('scanner', {
+    console: {
+        level: env.KES_SCANNER_CONSOLE_LEVEL ?? (env.NODE_ENV === 'development' ? 5 : 4),
+        useStyles: env.KES_CONSOLE_COLORS ?? undefined,
+    },
+    file: {
+        level: env.KES_SCANNER_LOG_LEVEL ?? (env.NODE_ENV === 'development' ? 0 : 3),
+    },
+}).scope(`watcher[${process.pid}]`);
+const refs = [];
+const searchExts = Object.keys(fileTypes).filter(ext => fileTypes[ext].scan !== false);
+(async function () {
+    const { default: IPC } = await import('./lib/IPCBridge.js');
+    IPC.use({
+        [WATCHER_WORKER_WATCH]: ({ payload }) => {
+            while (refs.length) {
+                const ref = refs.shift();
+                ref.close();
+            }
+            const { result, entities } = payload.paths;
+            const pathIds = result.filter(pathId => entities[pathId]?.prefs?.isWatchingEnabled);
+            if (!pathIds.length) {
+                log.info('no paths with watching enabled; exiting');
+                process.exit(0); // eslint-disable-line n/no-process-exit
+            }
+            log.info('watching %s path(s):', pathIds.length);
+            pathIds.forEach((pathId) => {
+                log.info('  => %s', entities[pathId].path);
+                const cb = accumulatedThrottle((events) => {
+                    const event = events.find(([, filename]) => searchExts.includes(pathLib.extname(filename).toLowerCase()));
+                    if (!event)
+                        return;
+                    log.info('event in path: %s (filename=%s) (type=%s)', entities[pathId].path, event[1], event[0]);
+                    IPC.send({
+                        type: WATCHER_WORKER_EVENT,
+                        payload: { pathId },
+                    });
+                }, 1000);
+                const ref = fs.watch(entities[pathId].path, { recursive: true }, cb);
+                refs.push(ref);
+            });
+        },
+    });
+})();