@harperfast/harper 5.0.0-alpha.10 → 5.0.0-beta.1

package/bin/restart.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const minimist = require('minimist');
+const { isMainThread, parentPort } = require('worker_threads');
+const hdbTerms = require('../utility/hdbTerms.ts');
+const hdbLogger = require('../utility/logging/harper_logger.js');
+const processMan = require('../utility/processManagement/processManagement.js');
+const { compactOnStart } = require('./copyDb.ts');
+const { restartWorkers, onMessageByType, shutdownWorkersNow } = require('../server/threads/manageThreads.js');
+const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
+const { HTTP_STATUS_CODES } = hdbErrors;
+const envMgr = require('../utility/environment/environmentManager.js');
+const path = require('node:path');
+const { unlinkSync } = require('node:fs');
+envMgr.initSync();
+
+const RESTART_RESPONSE = `Restarting Harper. This may take up to ${hdbTerms.RESTART_TIMEOUT_MS / 1000} seconds.`;
+const INVALID_SERVICE_ERR = 'Invalid service';
+
+let calledFromCli;
+
+module.exports = {
+	restart,
+	restartService,
+};
+
+// Add ITC event listener to main thread which will be called from child that receives restart request.
+if (isMainThread) {
+	onMessageByType(hdbTerms.ITC_EVENT_TYPES.RESTART, async (message, port) => {
+		if (message.workerType) await restartService({ service: message.workerType });
+		else restart({ operation: 'restart' });
+		port.postMessage({ type: 'restart-complete' });
+	});
+}
+
+/**
+ * Restart Harper.
+ * It will restart all the child threads and the hub and leaf server processes.
+ * @param req
+ * @returns {Promise<string>}
+ */
+async function restart(req) {
+	calledFromCli = Object.keys(req).length === 0;
+
+	const cliArgs = minimist(process.argv);
+	if (cliArgs.service) {
+		await restartService(cliArgs);
+		return;
+	}
+
+	if (calledFromCli) {
+		const hdbPid = processMan.getHdbPid();
+		console.error(hdbPid ? 'Restarting Harper...' : 'Starting Harper...');
+		require('./run.js').launch(true);
+		return RESTART_RESPONSE;
+	}
+
+	if (isMainThread) {
+		hdbLogger.notify(RESTART_RESPONSE);
+
+		if (envMgr.get(hdbTerms.CONFIG_PARAMS.STORAGE_COMPACTONSTART)) await compactOnStart();
+
+		if (process.env.HARPER_EXIT_ON_RESTART) {
+			// use this to exit the process so that it will be restarted by the
+			// PM/container/orchestrator.
+			hdbLogger.warn('Exiting Harper process to trigger a container restart');
+			process.exit(0);
+		}
+		setTimeout(async () => {
+			// It seems like you should just be able to start the other process and kill this process and everything should
+			// be cleaned up, however that doesn't work for some reason; the socket listening fds somehow get transferred to the
+			// child process if they are not explicitly closed. And when transferred they are orphaned listening, accepting
+			// connections and hanging. So we need to explicitly close down all the workers and then start the new process
+			// and shut down.
+			hdbLogger.debug('Shutdown workers');
+			await shutdownWorkersNow();
+			await processMan.cleanupChildrenProcesses(false);
+			// remove pid file so it doesn't trip up the launch
+			await unlinkSync(path.join(envMgr.get(hdbTerms.CONFIG_PARAMS.ROOTPATH), hdbTerms.HDB_PID_FILE), `${process.pid}`);
+			hdbLogger.debug('Starting new process...');
+			// now launch the new process and exit this process
+			require('./run.js').launch(true);
+		}, 50); // can't await this because it is going to do an exit()
+	} else {
+		// Post msg to main parent thread requesting it restart (so the main thread can process.exit())
+		parentPort.postMessage({
+			type: hdbTerms.ITC_EVENT_TYPES.RESTART,
+		});
+	}
+
+	return RESTART_RESPONSE;
+}
+
+/**
+ * Used to restart a particular service, services includes - httpWorkers
+ * @param req
+ * @returns {Promise<string>}
+ */
+async function restartService(req) {
+	let { service } = req;
+	if (hdbTerms.HDB_PROCESS_SERVICES[service] === undefined) {
+		throw handleHDBError(new Error(), INVALID_SERVICE_ERR, HTTP_STATUS_CODES.BAD_REQUEST, undefined, undefined, true);
+	}
+	processMan.expectedRestartOfChildren();
+	if (!isMainThread) {
+		if (req.replicated) {
+			server.replication.monitorNodeCAs(); // get all the CAs from the nodes we know about
+		}
+		parentPort.postMessage({
+			type: hdbTerms.ITC_EVENT_TYPES.RESTART,
+			workerType: service,
+		});
+		parentPort.ref(); // don't let the parent thread exit until we're done
+		await new Promise((resolve) => {
+			parentPort.on('message', (msg) => {
+				if (msg.type === 'restart-complete') {
+					resolve();
+					parentPort.unref();
+				}
+			});
+		});
+		let replicatedResponses;
+		if (req.replicated) {
+			req.replicated = false; // don't send a replicated flag to the nodes we are sending to
+			replicatedResponses = [];
+			for (let node of server.nodes) {
+				if (node.name === server.replication.getThisNodeName()) continue;
+				// for now, only one at a time
+				let job_id;
+				try {
+					({ job_id } = await server.replication.sendOperationToNode(node, req));
+				} catch (err) {
+					// If request to node fails, add the error to the response and continue to the next node
+					replicatedResponses.push({ node: node.name, message: err.message });
+					continue;
+				}
+				// wait for the job to finish by polling for the completion of the job
+				replicatedResponses.push(
+					await new Promise((resolve, reject) => {
+						const RETRY_INTERVAL = 250;
+						let retriesLeft = 2400; // 10 minutes
+						let interval = setInterval(async () => {
+							if (retriesLeft-- <= 0) {
+								clearInterval(interval);
+								let error = new Error('Timed out waiting for restart job to complete');
+								error.replicated = replicatedResponses; // report the finished restarts
+								reject(error);
+							}
+							let response = await server.replication.sendOperationToNode(node, {
+								operation: 'get_job',
+								id: job_id,
+							});
+							const jobResult = response.results[0];
+							if (jobResult.status === 'COMPLETE') {
+								clearInterval(interval);
+								resolve({ node: node.name, message: jobResult.message });
+							}
+							if (jobResult.status === 'ERROR') {
+								clearInterval(interval);
+								let error = new Error(jobResult.message);
+								error.replicated = replicatedResponses; // report the finished restarts
+								reject(error);
+							}
+						}, RETRY_INTERVAL);
+					})
+				);
+			}
+			return { replicated: replicatedResponses };
+		}
+		return;
+	}
+
+	let errMsg;
+	switch (service) {
+		case 'custom_functions':
+		case 'custom functions':
+		case hdbTerms.HDB_PROCESS_SERVICES.harperdb:
+		case hdbTerms.HDB_PROCESS_SERVICES.http_workers:
+		case hdbTerms.HDB_PROCESS_SERVICES.http:
+			if (calledFromCli) console.log(`Restarting httpWorkers`);
+			hdbLogger.notify('Restarting http_workers');
+
+			if (calledFromCli) {
+				await processMan.restart(hdbTerms.PROCESS_DESCRIPTORS.HDB);
+			} else {
+				await restartWorkers('http');
+			}
+			break;
+		default:
+			errMsg = `Unrecognized service: ${service}`;
+			break;
+	}
+
+	if (errMsg) {
+		hdbLogger.error(errMsg);
+		if (calledFromCli) console.error(errMsg);
+		return errMsg;
+	}
+	if (service === 'custom_functions') service = 'Custom Functions';
+	return `Restarting ${service}`;
+}

package/bin/run.js

@@ -0,0 +1,409 @@
+'use strict';
+
+const env = require('../utility/environment/environmentManager.js');
+env.initSync();
+
+// This unused restart require is here so that main thread loads ITC event listener defined in restart file. Do not remove.
+require('./restart.js');
+const terms = require('../utility/hdbTerms.ts');
+const { CONFIG_PARAMS } = terms;
+const hdbLogger = require('../utility/logging/harper_logger.js');
+const fs = require('fs-extra');
+const path = require('path');
+const checkJwtTokens = require('../utility/install/checkJWTTokensExist.js');
+const { install } = require('../utility/install/installer.js');
+const chalk = require('chalk');
+const { packageJson } = require('../utility/packageUtils.js');
+const hdbUtils = require('../utility/common_utils.js');
+const installation = require('../utility/installation.ts');
+const configUtils = require('../config/configUtils.js');
+const assignCMDENVVariables = require('../utility/assignCmdEnvVariables.js');
+const upgrade = require('./upgrade.js');
+const { compactOnStart } = require('./copyDb.ts');
+const minimist = require('minimist');
+const keys = require('../security/keys.js');
+const { startHTTPThreads } = require('../server/threads/socketRouter.ts');
+const hdbInfoController = require('../dataLayer/hdbInfoController.js');
+const hdbTerms = require('../utility/hdbTerms.ts');
+const { getHdbPid, isProcessRunning } = require('../utility/processManagement/processManagement.js');
+const { PACKAGE_ROOT } = require('../utility/packageUtils');
+
+let pmUtils;
+let cmdArgs;
+let skipExitListeners = false;
+
+const UPGRADE_COMPLETE_MSG = 'Upgrade complete. Starting Harper.';
+const UPGRADE_ERR = 'Got an error while trying to upgrade your Harper instance. Exiting Harper.';
+const HDB_NOT_FOUND_MSG = 'Harper not found, starting install process.';
+const INSTALL_ERR = 'There was an error during install, check install_log.log for more details. Exiting.';
+const HDB_STARTED = 'Harper successfully started.';
+
+function addUnhandleRejectionListener() {
+	process.on('unhandledRejection', (reason, promise) => {
+		hdbLogger.error('Unhandled promise rejection: Promise', promise, 'reason:', reason);
+	});
+}
+
+function addExitListeners() {
+	if (!skipExitListeners) {
+		const removeHdbPid = () => {
+			fs.removeSync(path.join(env.get(terms.CONFIG_PARAMS.ROOTPATH), terms.HDB_PID_FILE));
+			process.exit(0);
+		};
+		process.on('exit', () => {
+			removeHdbPid();
+		});
+		process.on('SIGINT', () => {
+			removeHdbPid();
+		});
+		process.on('SIGQUIT', () => {
+			removeHdbPid();
+		});
+		process.on('SIGTERM', () => {
+			removeHdbPid();
+		});
+	}
+}
+
+/**
+ * Do the initial checks and potential upgrades/installation
+ * @param calledByInstall
+ * @param calledByMain
+ * @returns {Promise<void>}
+ */
+async function initialize(calledByInstall = false, calledByMain = false) {
+	// Check to see if HDB is installed, if it isn't we call install.
+	console.log(chalk.magenta('Starting Harper...'));
+
+	addUnhandleRejectionListener();
+
+	hdbLogger.suppressLogging?.(() => {
+		console.log(chalk.magenta('' + fs.readFileSync(path.join(PACKAGE_ROOT, 'static/ascii_logo.txt'))));
+	});
+	hdbLogger.debug('Checking to make sure hdb is installed');
+	if (installation.isHdbInstalled(env, hdbLogger) === false) {
+		console.log(HDB_NOT_FOUND_MSG);
+		try {
+			await install();
+		} catch (err) {
+			console.error(INSTALL_ERR, err);
+			hdbLogger.error(err);
+			process.exit(1);
+		}
+	}
+
+	// The called by install check is here because if cmd/env args are passed to install (which calls run when done)
+	// we do not need to update/backup the config file on run.
+	if (!calledByInstall) {
+		// If run is called with cmd/env vars we create a backup of config and update config file.
+		let parsedArgs = assignCMDENVVariables(Object.keys(terms.CONFIG_PARAM_MAP), true);
+
+		// If HARPER_SET_CONFIG is present, filter out any config keys that are set in it
+		// to prevent individual env vars from overriding explicit runtime configuration
+		const { filterArgsAgainstRuntimeConfig } = require('../config/harperConfigEnvVars.ts');
+		parsedArgs = filterArgsAgainstRuntimeConfig(parsedArgs);
+
+		if (!hdbUtils.isEmpty(parsedArgs) && !hdbUtils.isEmptyOrZeroLength(Object.keys(parsedArgs))) {
+			configUtils.updateConfigValue(undefined, undefined, parsedArgs, true, true);
+		}
+	}
+
+	// if this process is Harper restarting, the parent could still be compacting RocksDB on exit,
+	// so we need to wait for the parent to exit
+	if (process.env.HARPER_PARENT_PROCESS_PID) {
+		const prevProcessPid = parseInt(process.env.HARPER_PARENT_PROCESS_PID);
+		delete process.env.HARPER_PARENT_PROCESS_PID;
+		if (isProcessRunning(prevProcessPid)) {
+			hdbLogger.info(`Previous process ${prevProcessPid} is still running, waiting up to 15 seconds...`);
+			// check if the previous process is still running, and if so, wait up to 15 seconds before timing out
+			const timeout = setTimeout(() => {
+				console.error(`Previous process ${prevProcessPid} is still running, exiting.`);
+				process.exit(1);
+			}, 15000);
+			while (isProcessRunning(prevProcessPid)) {
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			}
+			hdbLogger.info(`Previous process ${prevProcessPid} has exited`);
+			clearTimeout(timeout);
+		}
+	}
+
+	// Check to see if Harper is already running by checking for a pid file
+	// If found confirm it matches a currently running processes
+	let hdbPid = getHdbPid();
+	if (hdbPid) {
+		hdbLogger.debug('Error: Harper is already running');
+		console.error(`Error: Harper is already running (pid: ${hdbPid})`);
+		process.exit(4);
+	}
+
+	addExitListeners();
+
+	if (calledByMain) {
+		// Write Harper PID to file for tracking purposes
+		await fs.writeFile(path.join(env.get(hdbTerms.CONFIG_PARAMS.ROOTPATH), hdbTerms.HDB_PID_FILE), `${process.pid}`);
+	}
+	hdbLogger.info('Harper PID', process.pid);
+
+	// Check to see if an upgrade is needed based on existing hdbInfo data. If so, we need to force the user to upgrade
+	// before the server can be started.
+	let upgradeVers;
+	try {
+		const updateObj = await hdbInfoController.getVersionUpdateInfo();
+		if (updateObj !== undefined) {
+			upgradeVers = updateObj[terms.UPGRADE_JSON_FIELD_NAMES_ENUM.UPGRADE_VERSION];
+			await upgrade.upgrade(updateObj);
+			console.log(UPGRADE_COMPLETE_MSG);
+		}
+	} catch (err) {
+		if (upgradeVers) {
+			console.error(
+				`Got an error while trying to upgrade your Harper instance to version ${upgradeVers}. Exiting Harper.`,
+				err
+			);
+			hdbLogger.error(err);
+		} else {
+			console.error(UPGRADE_ERR, err);
+			hdbLogger.error(err);
+		}
+		process.exit(1);
+	}
+
+	checkJwtTokens();
+
+	await keys.reviewSelfSignedCert();
+}
+/**
+ * Starts Harper DB threads
+ * If the hdbBootProps file is not found, it is assumed an install needs to be performed.
+ * @param calledByInstall - If run is called by install we want to ignore any
+ * cmd/env args as they would have already been written to config on install.
+ * @returns {Promise<void>}
+ */
+async function main(calledByInstall = false) {
+	try {
+		cmdArgs = minimist(process.argv);
+		if (cmdArgs.ROOTPATH) {
+			let harperConfigPath = path.join(cmdArgs.ROOTPATH, hdbTerms.HARPER_CONFIG_FILE);
+			if (!fs.existsSync(harperConfigPath) && fs.existsSync(path.join(cmdArgs.ROOTPATH, hdbTerms.HARPER_CONFIG_FILE)))
+				harperConfigPath = path.join(cmdArgs.ROOTPATH, hdbTerms.HDB_CONFIG_FILE);
+			configUtils.updateConfigObject('settings_path', harperConfigPath);
+		}
+		await initialize(calledByInstall, true);
+
+		if (env.get(terms.CONFIG_PARAMS.STORAGE_COMPACTONSTART)) await compactOnStart();
+
+		const isScripted = process.env.IS_SCRIPTED_SERVICE && !cmdArgs.service;
+
+		await startHTTPThreads(
+			process.env.DEV_MODE
+				? 1
+				: (env.get(hdbTerms.CONFIG_PARAMS.THREADS_COUNT) ?? env.get(hdbTerms.CONFIG_PARAMS.THREADS))
+		);
+
+		if (!isScripted) started();
+	} catch (err) {
+		console.error(err);
+		hdbLogger.error(err);
+		process.exit(1);
+	}
+}
+function started() {
+	// Console log Harper dog logo
+	hdbLogger.suppressLogging(() => {
+		console.log(chalk.magenta(`Harper ${packageJson.version} successfully started`));
+	});
+	hdbLogger.notify(HDB_STARTED);
+}
+/**
+ * Launches a separate process for Harper and then exits. This is an unusual practice and is anathema
+ * to the way processes are typically handled, both in terminal and for services (systemd), but this functionality
+ * is retained for legacy purposes.
+ * @returns {Promise<void>} // ha ha, it doesn't!
+ */
+async function launch(exit = true) {
+	skipExitListeners = !exit;
+	try {
+		if (pmUtils === undefined) pmUtils = require('../utility/processManagement/processManagement.js');
+		hdbLogger.debug('initializing processManagement...');
+		await initialize();
+		hdbLogger.debug('Starting new main process');
+
+		await pmUtils.startService(terms.PROCESS_DESCRIPTORS.HDB, true);
+		started();
+		if (exit) process.exit(0);
+	} catch (err) {
+		console.error(err);
+		hdbLogger.error(err);
+		process.exit(1);
+	}
+}
+
+exports.launch = launch;
+exports.main = main;
+exports.startupLog = startupLog;
+
+/**
+ * Logs running services and relevant ports/information.
+ * Called by worker thread 1 once all servers have started
+ * @param portResolutions
+ */
+function startupLog(portResolutions) {
+	// Adds padding to a string
+	const padding = 20;
+	const pad = (param) => param.padEnd(padding);
+	let logMsg = '\n';
+
+	logMsg += `${pad('Hostname:')}${env.get(CONFIG_PARAMS.NODE_HOSTNAME)}\n`;
+
+	logMsg += `${pad('Worker Threads:')}${env.get(CONFIG_PARAMS.THREADS_COUNT)}\n`;
+
+	logMsg += `${pad('Root Path:')}${env.get(CONFIG_PARAMS.ROOTPATH)}\n`;
+
+	if (env.get(CONFIG_PARAMS.THREADS_DEBUG) !== false) {
+		logMsg += `${pad('Debugging:')}enabled: true`;
+		logMsg += env.get(CONFIG_PARAMS.THREADS_DEBUG_PORT)
+			? `, TCP: ${env.get(CONFIG_PARAMS.THREADS_DEBUG_PORT)}\n`
+			: '\n';
+	}
+	const logFilePath = path.join(env.get(CONFIG_PARAMS.LOGGING_ROOT), 'hdb.log');
+	logMsg += `${pad('Logging:')}level: ${env.get(CONFIG_PARAMS.LOGGING_LEVEL)}, location: ${
+		logFilePath + (env.get(CONFIG_PARAMS.LOGGING_STDSTREAMS) ? ', stdout/err' : '')
+	}\n`;
+
+	// Database Log aka Applications API aka http (in config)
+	logMsg += pad('Default:');
+	logMsg += env.get(CONFIG_PARAMS.HTTP_PORT) ? `HTTP (and WS): ${env.get(CONFIG_PARAMS.HTTP_PORT)}, ` : '';
+	logMsg += env.get(CONFIG_PARAMS.HTTP_SECUREPORT) ? `HTTPS (and WS): ${env.get(CONFIG_PARAMS.HTTP_SECUREPORT)}, ` : '';
+	logMsg += `CORS: ${
+		env.get(CONFIG_PARAMS.HTTP_CORS) ? `enabled for ${env.get(CONFIG_PARAMS.HTTP_CORSACCESSLIST)}` : 'disabled'
+	}\n`;
+
+	// Operations API Log
+	logMsg += pad('Operations API:');
+	logMsg += env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_PORT)
+		? `HTTP: ${env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_PORT)}, `
+		: '';
+	logMsg += env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_SECUREPORT)
+		? `HTTPS: ${env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_SECUREPORT)}, `
+		: '';
+	logMsg += `CORS: ${
+		env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_CORS)
+			? `enabled for ${env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_CORSACCESSLIST)}`
+			: 'disabled'
+	}`;
+	logMsg += `, unix socket: ${env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_DOMAINSOCKET)}\n`;
+	if (env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_PORT)) {
+		logMsg +=
+			pad('') +
+			'http://' +
+			env.get(CONFIG_PARAMS.NODE_HOSTNAME) +
+			':' +
+			env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_PORT) +
+			'/\n';
+	}
+	if (env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_SECUREPORT)) {
+		logMsg +=
+			'\n' +
+			pad('') +
+			'https://' +
+			env.get(CONFIG_PARAMS.NODE_HOSTNAME) +
+			':' +
+			env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_SECUREPORT) +
+			'/\n';
+	}
+
+	// MQTT Log
+	logMsg += pad('MQTT:');
+	logMsg += env.get(CONFIG_PARAMS.MQTT_NETWORK_PORT) ? `TCP: ${env.get(CONFIG_PARAMS.MQTT_NETWORK_PORT)}, ` : '';
+	logMsg += env.get(CONFIG_PARAMS.MQTT_NETWORK_SECUREPORT)
+		? `TLS: ${env.get(CONFIG_PARAMS.MQTT_NETWORK_SECUREPORT)}`
+		: '';
+	logMsg +=
+		env.get(CONFIG_PARAMS.MQTT_WEBSOCKET) && env.get(CONFIG_PARAMS.HTTP_PORT)
+			? `, WS: ${env.get(CONFIG_PARAMS.HTTP_PORT)}`
+			: '';
+	logMsg +=
+		env.get(CONFIG_PARAMS.MQTT_WEBSOCKET) && env.get(CONFIG_PARAMS.HTTP_SECUREPORT)
+			? `, WSS: ${env.get(CONFIG_PARAMS.HTTP_SECUREPORT)}\n`
+			: '\n';
+
+	if (env.get(CONFIG_PARAMS.REPLICATION_URL)) {
+		let repLog = `${pad('Replication:')}\n`;
+
+		repLog += `${pad('Replication Url:')}${env.get(CONFIG_PARAMS.REPLICATION_URL)}\n`;
+		// Replication log
+		const replicationPort =
+			env.get(CONFIG_PARAMS.REPLICATION_PORT) ?? env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_PORT);
+		const replicationSecurePort =
+			env.get(CONFIG_PARAMS.REPLICATION_SECUREPORT) ?? env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_SECUREPORT);
+
+		repLog += replicationPort ? `WS: ${replicationPort}, ` : '';
+		repLog += replicationSecurePort ? `WSS: ${replicationSecurePort} ` : '';
+		logMsg += `${repLog.slice(0, -2)}\n`;
+	}
+
+	// Extract all non-default components from the config file
+	let components = [];
+	const configObj = configUtils.getConfigObj();
+	for (const cfg in configObj) {
+		if (configObj[cfg].package) components.push(cfg);
+	}
+
+	// portResolutions is a Map of port to protocol name and component name built in threadServer.js
+	// we iterate through the map to build a log for REST and for any components that are using custom ports
+	let comps = {};
+	let restHostnames = [];
+	let restLog = `${pad('REST:')}`;
+	for (const [key, values] of portResolutions) {
+		for (const value of values) {
+			const name = value.name;
+			const pair = `${value.protocol_name}: ${key}, `;
+			if (!restLog.includes(pair) && name === 'rest') {
+				restLog += pair;
+				if (value.protocol_name === 'HTTP' || value.protocol_name === 'HTTPS') {
+					restHostnames.push(`${value.protocol_name.toLowerCase()}://${env.get(CONFIG_PARAMS.NODE_HOSTNAME)}:${key}/`);
+				}
+			}
+
+			if (components.includes(name)) {
+				if (comps[name]) {
+					comps[name] += pair;
+				} else {
+					comps[name] = pair;
+				}
+			}
+		}
+	}
+
+	// Remove the trailing comma and space
+	if (restLog.length > padding + 1) {
+		restLog = restLog.slice(0, -2);
+		logMsg += `${restLog}\n`;
+		for (const restHostname of restHostnames) {
+			logMsg += pad('') + restHostname + '\n';
+		}
+	}
+
+	let appPortsLog = env.get(CONFIG_PARAMS.HTTP_PORT) ? `HTTP: ${env.get(CONFIG_PARAMS.HTTP_PORT)}, ` : '';
+	appPortsLog += env.get(CONFIG_PARAMS.HTTP_SECUREPORT) ? `HTTPS: ${env.get(CONFIG_PARAMS.HTTP_SECUREPORT)}, ` : '';
+	if (appPortsLog.length > padding + 1) appPortsLog = appPortsLog.slice(0, -2);
+
+	// Build logs for all components
+	for (const c of components) {
+		if (comps[c]) {
+			logMsg += `${pad(c + ': ')}${comps[c].slice(0, -2)}\n`;
+		} else {
+			logMsg += `${pad(c + ': ')}${appPortsLog}\n`;
+		}
+	}
+
+	console.log(logMsg);
+	if (env.get(CONFIG_PARAMS.LOGGING_STDSTREAMS) && hdbLogger.logsAtLevel('info')) {
+		hdbLogger.suppressLogging(() => {
+			console.log(
+				`Note that log messages are being sent to the console (stdout and stderr) in addition to the log file ${logFilePath}. This can be disabled by setting logging.stdStreams to false, and the log file can be directly monitored/tailed.`
+			);
+		});
+	}
+}

package/bin/status.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const YAML = require('yaml');
+
+const hdbTerms = require('../utility/hdbTerms.ts');
+const hdbLog = require('../utility/logging/harper_logger.js');
+const sysInfo = require('../utility/environment/systemInformation.js');
+const envMgr = require('../utility/environment/environmentManager.js');
+const installation = require('../utility/installation.ts');
+envMgr.initSync();
+
+const STATUSES = {
+	RUNNING: 'running',
+	STOPPED: 'stopped',
+	ERRORED: 'errored',
+	NOT_INSTALLED: 'not installed',
+};
+
+let hdbRoot;
+
+module.exports = status;
+
+async function status() {
+	let status = {
+		harperdb: {
+			status: STATUSES.STOPPED,
+		},
+	};
+
+	if (!installation.isHdbInstalled(envMgr, hdbLog)) {
+		status.harperdb.status = STATUSES.NOT_INSTALLED;
+		console.log(YAML.stringify(status));
+		return;
+	}
+
+	hdbRoot = envMgr.get(hdbTerms.CONFIG_PARAMS.ROOTPATH);
+	let hdbPid;
+	try {
+		hdbPid = Number.parseInt(await fs.readFile(path.join(hdbRoot, hdbTerms.HDB_PID_FILE), 'utf8'));
+	} catch (err) {
+		if (err.code === hdbTerms.NODE_ERROR_CODES.ENOENT) {
+			hdbLog.info('`harperdb status` did not find a hdb.pid file');
+			status.harperdb.status = STATUSES.STOPPED;
+			console.log(YAML.stringify(status));
+			return;
+		}
+
+		throw err;
+	}
+
+	// Check the saved pid against any running hdb processes
+	const hdbSysInfo = await sysInfo.getHDBProcessInfo();
+	for (const proc of hdbSysInfo.core) {
+		if (proc.pid === hdbPid) {
+			status.harperdb.status = STATUSES.RUNNING;
+			status.harperdb.pid = hdbPid;
+			break;
+		}
+	}
+
+	console.log(YAML.stringify(status));
+	process.exit();
+}

package/bin/stop.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const hdbLogger = require('../utility/logging/harper_logger.js');
+const util = require('util');
+const childProcess = require('child_process');
+const exec = util.promisify(childProcess.exec);
+const sysInfo = require('../utility/environment/systemInformation.js');
+
+const STOP_MSG = 'Stopping Harper.';
+
+module.exports = stop;
+
+async function stop() {
+	console.log(STOP_MSG);
+	hdbLogger.notify(STOP_MSG);
+
+	const processes = await sysInfo.getHDBProcessInfo();
+
+	processes.core.forEach((p) => {
+		exec(`kill ${p.pid}`);
+	});
+}