kopia/app/public/server.js

import { ipcMain } from 'electron';
const path = await import('path');
const https = await import('https');

import { defaultServerBinary } from './utils.js';
import { spawn } from 'child_process';
import log from "electron-log";
import { configDir, isPortableConfig } from './config.js';

let servers = {};

function newServerForRepo(repoID) {
    let runningServerProcess = null;
    let runningServerCertSHA256 = "";
    let runningServerPassword = "";
    let runningServerControlPassword = "";
    let runningServerAddress = "";
    let runningServerCertificate = "";
    let runningServerStatusDetails = {
        startingUp: true,
    };
    let serverLog = [];

    const maxLogLines = 100;

    return {
        actuateServer() {
            log.info('actuating Server', repoID);
            this.stopServer();
            this.startServer();
        },

        startServer() {
            let kopiaPath = defaultServerBinary();
            let args = [];

            args.push('server', 'start', '--ui',
                '--tls-print-server-cert',
                '--tls-generate-cert-name=127.0.0.1',
                '--random-password',
                '--random-server-control-password',
                '--tls-generate-cert',
                '--async-repo-connect',
                '--error-notifications=always',
                '--kopiaui-notifications', // will print notification JSON to stderr
                '--shutdown-on-stdin', // shutdown the server when parent dies
                '--address=127.0.0.1:0');


            args.push("--config-file", path.resolve(configDir(), repoID + ".config"));
            if (isPortableConfig()) {
                const cacheDir = path.resolve(configDir(), "cache", repoID);
                const logsDir = path.resolve(configDir(), "logs", repoID);
                args.push("--cache-directory", cacheDir);
                args.push("--log-dir", logsDir);
            }

            log.info(`spawning ${kopiaPath} ${args.join(' ')}`);
            runningServerProcess = spawn(kopiaPath, args, {
            });
            this.raiseStatusUpdatedEvent();

            runningServerProcess.stdout.on('data', this.appendToLog.bind(this));
            runningServerProcess.stderr.on('data', this.detectServerParam.bind(this));

            const p = runningServerProcess;

            log.info('starting polling loop');

            const statusUpdated = this.raiseStatusUpdatedEvent.bind(this);

            const pollInterval = 3000;

            function pollOnce() {
                if (!runningServerAddress || !runningServerCertificate || !runningServerPassword || !runningServerControlPassword) {
                    return;
                }

                const req = https.request({
                    ca: [runningServerCertificate],
                    host: "127.0.0.1",
                    port: parseInt(new URL(runningServerAddress).port),
                    method: "GET",
                    path: "/api/v1/control/status",
                    timeout: pollInterval,
                    headers: {
                        'Authorization': 'Basic ' + Buffer.from("server-control" + ':' + runningServerControlPassword).toString('base64')
                    }
                }, (resp) => {
                    if (resp.statusCode === 200) {
                        resp.on('data', x => {
                            try {
                                const newDetails = JSON.parse(x);
                                if (JSON.stringify(newDetails) != JSON.stringify(runningServerStatusDetails)) {
                                    runningServerStatusDetails = newDetails;
                                    statusUpdated();
                                }
                            } catch (e) {
                                log.warn('unable to parse status JSON', e);
                            }
                        });
                    } else {
                        log.warn('error fetching status', resp.statusMessage);
                    }
                });
                req.on('error', (e) => {
                    log.info('error fetching status', e);
                });
                req.end();
            }

            const statusPollInterval = setInterval(pollOnce, pollInterval);

            runningServerProcess.on('close', (code, signal) => {
                this.appendToLog(`child process exited with code ${code} and signal ${signal}`);
                if (runningServerProcess === p) {
                    clearInterval(statusPollInterval);

                    runningServerAddress = "";
                    runningServerPassword = "";
                    runningServerControlPassword = "";
                    runningServerCertSHA256 = "";
                    runningServerProcess = null;
                    this.raiseStatusUpdatedEvent();
                }
            });
        },

        detectServerParam(data) {
            let lines = (data + '').split('\n');
            for (let i = 0; i < lines.length; i++) {
                const p = lines[i].indexOf(": ");
                if (p < 0) {
                    continue
                }

                const key = lines[i].substring(0, p);
                const value = lines[i].substring(p + 2);
                switch (key) {
                    case "SERVER PASSWORD":
                        runningServerPassword = value;
                        this.raiseStatusUpdatedEvent();
                        break;

                    case "SERVER CONTROL PASSWORD":
                        runningServerControlPassword = value;
                        this.raiseStatusUpdatedEvent();
                        break;

                    case "SERVER CERT SHA256":
                        runningServerCertSHA256 = value;
                        this.raiseStatusUpdatedEvent();
                        break;

                    case "SERVER CERTIFICATE":
                        runningServerCertificate = Buffer.from(value, 'base64').toString('ascii');
                        this.raiseStatusUpdatedEvent();
                        break;

                    case "SERVER ADDRESS":
                        runningServerAddress = value;
                        this.raiseStatusUpdatedEvent();
                        break;

                    case "NOTIFICATION":
                        try {
                            this.raiseNotificationEvent(JSON.parse(value));
                        } catch (e) {
                            log.warn('unable to parse notification JSON', e);
                        }
                        break;
                }
            }

            this.appendToLog(data);
        },

        appendToLog(data) {
            const l = serverLog.push(data);
            if (l > maxLogLines) {
                serverLog.splice(0, 1);
            }

            ipcMain.emit('logs-updated-event', {
                repoID: repoID,
                logs: serverLog.join(''),
            });
            log.info(`${data}`);
        },

        stopServer() {
            if (!runningServerProcess) {
                log.info('stopServer: server not started');
                return;
            }

            runningServerProcess.kill();
            runningServerAddress = "";
            runningServerPassword = "";
            runningServerCertSHA256 = "";
            runningServerCertificate = "";
            runningServerProcess = null;
            this.raiseStatusUpdatedEvent();
        },

        getServerAddress() {
            return runningServerAddress;
        },

        getServerCertSHA256() {
            return runningServerCertSHA256;
        },

        getServerPassword() {
            return runningServerPassword;
        },

        getServerStatusDetails() {
            return runningServerStatusDetails;
        },

        getServerStatus() {
            if (!runningServerProcess) {
                return "Stopped";
            }

            if (runningServerCertSHA256 && runningServerAddress && runningServerPassword) {
                return "Running";
            }

            return "Starting";
        },

        raiseStatusUpdatedEvent() {
            const args = {
                repoID: repoID,
                status: this.getServerStatus(),
                serverAddress: this.getServerAddress() || "<pending>",
                serverCertSHA256: this.getServerCertSHA256() || "<pending>",
            };

            ipcMain.emit('status-updated-event', args);
        },

        raiseNotificationEvent(notification) {
            const args = {
                repoID: repoID,
                notification: notification,
            };

            ipcMain.emit('repo-notification-event', args);
        },
    };
};

ipcMain.on('status-fetch', (event, args) => {
    const repoID = args.repoID;
    const s = servers[repoID]
    if (s) {
        s.raiseStatusUpdatedEvent();
    }
})

export function serverForRepo(repoID) {
    let s = servers[repoID];
    if (s) {
        return s;
    }

    s = newServerForRepo(repoID);
    servers[repoID] = s;
    return s;
}