@fc3/mmcadi 0.1.0

package/src/lib/process/execute.ts

@@ -0,0 +1,77 @@
+import ChildProcess from 'child_process';
+
+import Logger from 'lib/logger';
+import ProcessError from 'lib/process/error';
+import PromiseWrapper from 'lib/promise-wrapper';
+import CommandOptions from 'lib/process/type/command-options';
+
+let LOGGER: Logger | undefined;
+
+function getLogger(): Logger {
+	if (LOGGER === undefined) {
+		LOGGER = new Logger();
+	}
+
+	return LOGGER;
+}
+
+function execute(command: string, options?: CommandOptions): Promise<string> {
+	const promise_wrapper = new PromiseWrapper<string>();
+
+	options = {
+		...options
+	};
+
+	const cwd = options.cwd || process.cwd();
+	const logger = getLogger();
+
+	if (!options.silent) {
+		logger.info(`${cwd} > ${command}`);
+	}
+
+	function reject(error: string | Error): void {
+		// TODO: Interestingly, the error being passed in is not necessarily an
+		// instance of the base Error class... are there separate base error
+		// classes in play here? That sounds dangerous (given that we do
+		// instanceof Error checks in various places...). Needs investigation.
+		if (typeof error === 'string') {
+			error = new ProcessError(error);
+		}
+
+		promise_wrapper.reject(error);
+	}
+
+	// TODO: Figure out what is the appropriate thing to do with stderr...
+	// Maybe for now just throw an exception if it is present?
+	ChildProcess.exec(
+		command,
+		options,
+		(error: Error | null, stdout: string, stderr: string) => {
+			if (error === null) {
+				promise_wrapper.resolve(stdout);
+				return;
+			}
+
+			// Sometimes the process will emit output on stdout, and then return
+			// a non-zero exit code (eg, `service status xxx` when the service isn't
+			// currently running). When that happens, return an error with stdout:
+			if (!stderr && stdout) {
+				return reject(stdout);
+			}
+
+			if (error.message.includes('Command failed:') === false) {
+				return reject(error);
+			}
+
+			if (stderr) {
+				return reject(stderr);
+			}
+
+			return reject(error);
+		}
+	);
+
+	return promise_wrapper.getPromise();
+}
+
+export default execute;

package/src/lib/process/index.ts

@@ -0,0 +1,4 @@
+export {default as ProcessSignal} from 'lib/process/enum/process-signal';
+export {default as PosixErrorCode} from 'lib/process/enum/posix-error-code';
+export {default as bindProcessLifespanTo} from 'lib/process/utility/bind-process-lifespan-to';
+export {default as execute} from 'lib/process/execute';

package/src/lib/process/type/command-options.ts

@@ -0,0 +1,9 @@
+interface CommandOptions {
+	readonly cwd?: string;
+	readonly uid?: number;
+	readonly gid?: number;
+	readonly stream?: boolean;
+	readonly silent?: boolean;
+}
+
+export default CommandOptions;

package/src/lib/process/utility/bind-process-lifespan-to.ts

@@ -0,0 +1,10 @@
+import Logger from 'lib/logger';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function bindProcessLifespanTo(promise: Promise<any>): void {
+	const logger = new Logger();
+
+	promise.then(logger.successAndExit).catch(logger.errorAndExit);
+}
+
+export default bindProcessLifespanTo;

package/src/lib/promise-wrapper/index.ts

@@ -0,0 +1,3 @@
+import PromiseWrapper from 'lib/promise-wrapper/promise-wrapper';
+
+export default PromiseWrapper;

package/src/lib/promise-wrapper/promise-wrapper.ts

@@ -0,0 +1,51 @@
+interface Callback<T> {
+	(error: Error | undefined | null, result: T): void;
+}
+
+class PromiseWrapper<T> {
+	// TODO: Remove this and just use sleep()
+	public static resolveAfterDelay(delay: number): Promise<void> {
+		const promise_wrapper = new PromiseWrapper<void>();
+
+		setTimeout(() => {
+			promise_wrapper.resolve();
+		}, delay);
+
+		return promise_wrapper.getPromise();
+	}
+
+	private promise: Promise<T>;
+	private resolver!: (result: T) => void;
+	private rejector!: (error: Error) => void;
+
+	public constructor() {
+		this.promise = new Promise<T>((resolver, rejector) => {
+			this.resolver = resolver;
+			this.rejector = rejector;
+		});
+	}
+
+	public getPromise(): Promise<T> {
+		return this.promise;
+	}
+
+	public getCallback(): Callback<T> {
+		return (error: Error | undefined | null, result: T) => {
+			if (error) {
+				this.reject(error);
+			} else {
+				this.resolve(result);
+			}
+		};
+	}
+
+	public resolve(result?: T): void {
+		this.resolver(result as T);
+	}
+
+	public reject(error: Error): void {
+		this.rejector(error);
+	}
+}
+
+export default PromiseWrapper;

package/src/lib/random/chance.ts

@@ -0,0 +1,5 @@
+function randomChance(percentage: number): boolean {
+	return Math.random() <= percentage;
+}
+
+export default randomChance;

package/src/lib/random/element.ts

@@ -0,0 +1,7 @@
+function randomElement<T>(elements: T[]): T | undefined {
+	const index = Math.floor(Math.random() * elements.length);
+
+	return elements[index];
+}
+
+export default randomElement;

package/src/lib/random/elements.ts

@@ -0,0 +1,12 @@
+import {clone} from 'lib/array';
+
+function randomElements<T>(elements: T[]): T[] {
+	const count = Math.floor(Math.random() * elements.length);
+	const randomized_elements = clone(elements).sort(() => {
+		return Math.random() - 0.5;
+	});
+
+	return randomized_elements.slice(0, count);
+}
+
+export default randomElements;

package/src/lib/random/enum.ts

@@ -0,0 +1,34 @@
+import randomElement from 'lib/random/element';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function randomEnum<T>(enum_values: object): T {
+	interface IndexableEnum {
+		[key: string]: T;
+	}
+
+	const keys = Object.keys(enum_values);
+	const key = randomElement(keys) as string;
+	const numeric_key = (key as unknown) as number;
+
+	// The way that Typescript transpiles enums with numeric-values into objects
+	// is dangerous. It creates reverse mappings between the values and the keys,
+	// whereas with a string-value enum, it does not. This is unintuitive and a
+	// potential footgun, so I'm opting to just raise a hard exception here.
+	if (isNaN(numeric_key) === false) {
+		throw new Error('Do not use randomEnum() on numeric-value enums');
+	}
+
+	const coerced_values = enum_values as IndexableEnum;
+	const value = coerced_values[key];
+	const numeric_value = (value as unknown) as number;
+
+	// Same note as above; here we're accounting for the opposite "lucky" case,
+	// where a string key was selected that points to a numeric value.
+	if (isNaN(numeric_value) === false) {
+		throw new Error('Do not use randomEnum() on numeric-value enums');
+	}
+
+	return value;
+}
+
+export default randomEnum;

package/src/lib/random/enums.ts

@@ -0,0 +1,11 @@
+import randomElements from 'lib/random/elements';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function randomEnum<T>(enum_values: object): T[] {
+	const values = Object.values(enum_values);
+	const random_values = randomElements(values);
+
+	return random_values as T[];
+}
+
+export default randomEnum;

package/src/lib/random/index.ts

@@ -0,0 +1,3 @@
+export {default as randomEnum} from 'lib/random/enum';
+export {default as randomElement} from 'lib/random/element';
+export {default as randomNumber} from 'lib/random/number';

package/src/lib/random/number.ts

@@ -0,0 +1,8 @@
+function randomNumber(min: number, max: number): number {
+	const delta = max - min;
+	const value = Math.round(Math.random() * delta);
+
+	return Math.round(min + value);
+}
+
+export default randomNumber;

package/src/lib/server/base.ts

@@ -0,0 +1,194 @@
+import Net from 'net';
+import Util from 'util';
+import {EventEmitter} from 'events';
+
+import RuntimeConfig from 'type/runtime-config';
+
+import Logger from 'lib/logger';
+
+import {GenericError} from 'lib/errors';
+import {NetworkProtocol} from 'lib/network';
+
+import ServerStatus from 'lib/server/enum/server-status';
+import ServerOptions from 'lib/server/type/server-options';
+
+abstract class Server extends EventEmitter {
+	private raw_server: Net.Server;
+	private options: ServerOptions;
+	private status: ServerStatus;
+	private logger: Logger | undefined;
+
+	public constructor(options: ServerOptions, raw_server: Net.Server) {
+		super();
+
+		this.raw_server = raw_server;
+		this.status = ServerStatus.NOT_STARTED;
+		this.options = options;
+
+		this.bindHandlersInternal();
+	}
+
+	public async start(): Promise<void> {
+		this.validateCanStart();
+		this.setStatus(ServerStatus.STARTING);
+
+		const raw_server = this.getRawServer();
+		const logger = this.getLogger();
+		const port = this.getPort();
+		const protocol = this.getProtocol();
+		const label = this.getLabel();
+
+		raw_server.listen(port);
+		logger.info(`${label} ${protocol} server listening on port ${port}`);
+	}
+
+	public async stop(): Promise<void> {
+		const logger = this.getLogger();
+		const label = this.getLabel();
+		const protocol = this.getProtocol();
+
+		if (this.isNotStarted() || this.isStopped()) {
+			return void logger.warn(`
+				${label} ${protocol} server was not running; skipping shutdown...
+			`);
+		}
+
+		logger.info(`Stopping ${label} ${protocol} server...`);
+
+		this.validateCanStop();
+		this.setStatus(ServerStatus.STOPPING);
+
+		const raw_server = this.getRawServer();
+		const close = Util.promisify(raw_server.close.bind(raw_server));
+		const promise = close();
+
+		await promise;
+
+		logger.info(`${label} ${protocol} server was stopped`);
+	}
+
+	public setLogger(logger: Logger): void {
+		this.logger = logger;
+	}
+
+	public canStart(): boolean {
+		const status = this.getStatus();
+
+		return status === ServerStatus.NOT_STARTED;
+	}
+
+	public canStop(): boolean {
+		const status = this.getStatus();
+
+		switch (status) {
+			case ServerStatus.STARTING:
+			case ServerStatus.LISTENING:
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	protected getConfig(): RuntimeConfig {
+		const {config} = this.getServerOptions();
+
+		return config;
+	}
+
+	protected getPort(): number {
+		const {port} = this.getServerOptions();
+
+		return port;
+	}
+
+	protected getLabel(): string {
+		const {label} = this.getServerOptions();
+
+		return label;
+	}
+
+	protected getLogger(): Logger {
+		if (this.logger === undefined) {
+			this.logger = new Logger();
+		}
+
+		return this.logger;
+	}
+
+	protected getRawServer(): Net.Server {
+		return this.raw_server;
+	}
+
+	protected getServerOptions(): ServerOptions {
+		return this.options;
+	}
+
+	private bindHandlersInternal(): void {
+		const raw_server = this.getRawServer();
+
+		raw_server.on('listening', this.handleListening.bind(this));
+		raw_server.on('error', this.handleError.bind(this));
+		raw_server.on('close', this.handleClosed.bind(this));
+
+		this.bindHandlers();
+	}
+
+	private handleListening(): void {
+		this.setStatus(ServerStatus.LISTENING);
+	}
+
+	private handleError(error: Error): void {
+		const logger = this.getLogger();
+
+		logger.error(error);
+	}
+
+	private handleClosed(): void {
+		this.setStatus(ServerStatus.STOPPED);
+	}
+
+	private validateCanStart(): void {
+		if (this.canStart()) {
+			return;
+		}
+
+		const status = this.getStatus();
+
+		throw new GenericError(`Unable to start server in ${status} status`);
+	}
+
+	private validateCanStop(): void {
+		if (this.canStop()) {
+			return;
+		}
+
+		const status = this.getStatus();
+
+		throw new GenericError(`Unable to stop server in ${status} status`);
+	}
+
+	private isNotStarted(): boolean {
+		const status = this.getStatus();
+
+		return status === ServerStatus.NOT_STARTED;
+	}
+
+	private isStopped(): boolean {
+		const status = this.getStatus();
+
+		return status === ServerStatus.STOPPED;
+	}
+
+	private getStatus(): ServerStatus {
+		return this.status;
+	}
+
+	private setStatus(status: ServerStatus): void {
+		this.status = status;
+	}
+
+	protected abstract bindHandlers(): void;
+	protected abstract getProtocol(): NetworkProtocol;
+}
+
+export default Server;

package/src/lib/server/enum/server-event.ts

@@ -0,0 +1,5 @@
+enum ServerEvent {
+	CONNECTION = 'connection'
+}
+
+export default ServerEvent;

package/src/lib/server/enum/server-status.ts

@@ -0,0 +1,10 @@
+enum ServerStatus {
+	NOT_STARTED = 'not_started',
+	STARTING = 'starting',
+	LISTENING = 'listening',
+	STOPPING = 'stopping',
+	STOPPED = 'stopped',
+	CRASHED = 'crashed'
+}
+
+export default ServerStatus;

package/src/lib/server/http/endpoint/ping.ts

@@ -0,0 +1,21 @@
+import {HttpMethod, ContentType} from 'lib/http';
+
+import Endpoint from 'lib/server/http/endpoint';
+
+interface PingResult {
+	status: string;
+}
+
+class PingEndpoint extends Endpoint<unknown, PingResult> {
+	public path = '/ping';
+	public method = HttpMethod.GET;
+	public content_types = [ContentType.JSON];
+
+	protected process(): Promise<PingResult> {
+		return Promise.resolve({
+			status: 'OK'
+		});
+	}
+}
+
+export default PingEndpoint;