@fc3/mmcadi 0.1.0

package/src/lib/server/tcp.ts

@@ -0,0 +1,53 @@
+import Net from 'net';
+
+import {NetworkProtocol} from 'lib/network';
+import ExecutionContext from 'lib/execution-context';
+import {IncomingConnection} from 'lib/tcp';
+
+import BaseServer from 'lib/server/base';
+import ServerEvent from 'lib/server/enum/server-event';
+import ServerOptions from 'lib/server/type/server-options';
+
+class TcpServer extends BaseServer {
+	private connections: IncomingConnection[];
+
+	public constructor(options: ServerOptions) {
+		const raw_server = Net.createServer();
+
+		super(options, raw_server);
+
+		this.connections = [];
+	}
+
+	protected bindHandlers(): void {
+		const raw_server = this.getRawServer();
+
+		raw_server.on('connection', this.handleSocket.bind(this));
+	}
+
+	protected getProtocol(): NetworkProtocol {
+		return NetworkProtocol.TCP;
+	}
+
+	private handleSocket(socket: Net.Socket): void {
+		const config = this.getConfig();
+		const execution_context = new ExecutionContext(config);
+		const connection = new IncomingConnection(socket, execution_context);
+
+		this.addConnection(connection);
+	}
+
+	private addConnection(connection: IncomingConnection): void {
+		const connections = this.getConnections();
+
+		connections.push(connection);
+
+		this.emit(ServerEvent.CONNECTION, connection);
+	}
+
+	private getConnections(): IncomingConnection[] {
+		return this.connections;
+	}
+}
+
+export default TcpServer;

package/src/lib/server/type/server-options.ts

@@ -0,0 +1,10 @@
+import RuntimeConfig from 'type/runtime-config';
+
+interface ServerOptions {
+	readonly port: number;
+	readonly label: string;
+	readonly id?: string;
+	readonly config: RuntimeConfig;
+}
+
+export default ServerOptions;

package/src/lib/string/calculate-length.ts

@@ -0,0 +1,17 @@
+import AnsiEscapeCode from 'lib/string/enum/ansi-escape-code';
+
+function calculateLength(value: string): number {
+	if (value.indexOf('\x1b') === -1) {
+		return value.length;
+	}
+
+	Object.values(AnsiEscapeCode).forEach((escape_code) => {
+		while (value.indexOf(escape_code) !== -1) {
+			value = value.replace(escape_code, '');
+		}
+	});
+
+	return value.length;
+}
+
+export default calculateLength;

package/src/lib/string/capitalize.ts

@@ -0,0 +1,8 @@
+function capitalize(str: string): string {
+	const first_character = str[0];
+	const remaining_characters = str.slice(1);
+
+	return first_character.toUpperCase() + remaining_characters;
+}
+
+export default capitalize;

package/src/lib/string/create-slug.ts

@@ -0,0 +1,14 @@
+import {InvariantViolation} from 'lib/errors';
+
+function createSlug(message: string): string {
+	if (message === '') {
+		throw new InvariantViolation('Tried to create slug, but message was empty');
+	}
+
+	return message
+		.replace(/[\s_]/g, '-')
+		.replace(/[^A-Za-z0-9-]/g, '')
+		.toLowerCase();
+}
+
+export default createSlug;

package/src/lib/string/enum/ansi-escape-code.ts

@@ -0,0 +1,14 @@
+enum AnsiEscapeCode {
+	BLACK = '\x1b[30m',
+	RED = '\x1b[31m',
+	GREEN = '\x1b[32m',
+	YELLOW = '\x1b[33m',
+	BLUE = '\x1b[34m',
+	MAGENTA = '\x1b[35m',
+	CYAN = '\x1b[36m',
+	WHITE = '\x1b[37m',
+	GREY = '\x1b[38m',
+	RESET = '\x1b[39;49m'
+}
+
+export default AnsiEscapeCode;

package/src/lib/string/enum/string-encoding.ts

@@ -0,0 +1,9 @@
+enum StringEncoding {
+	ASCII = 'ascii',
+	BASE64 = 'base64',
+	BINARY = 'binary',
+	HEX = 'hex',
+	UTF8 = 'utf8'
+}
+
+export default StringEncoding;

package/src/lib/string/hyphenate.ts

@@ -0,0 +1,5 @@
+function hyphenate(text: string): string {
+	return text.replace(/[_\s]/g, '-');
+}
+
+export default hyphenate;

package/src/lib/string/index.ts

@@ -0,0 +1,3 @@
+export {default as createSlug} from 'lib/string/create-slug';
+export {default as capitalize} from 'lib/string/capitalize';
+export {default as StringEncoding} from 'lib/string/enum/string-encoding';

package/src/lib/string/pad.ts

@@ -0,0 +1,14 @@
+import calculateLength from 'lib/string/calculate-length';
+
+function pad(value: string, desired_length: number, character = ' '): string {
+	let actual_length = calculateLength(value);
+
+	while (actual_length < desired_length) {
+		value += character;
+		actual_length += 1;
+	}
+
+	return value;
+}
+
+export default pad;

package/src/lib/string/trim-multiline.ts

@@ -0,0 +1,21 @@
+function trimMultiline(value: string): string {
+	value = value.trim();
+
+	const lines = value.split('\n');
+
+	let result = '';
+
+	lines.forEach((line) => {
+		line = line.replace(/\s+/g, ' ');
+
+		if (line.trim() === '') {
+			result += '\n';
+		} else {
+			result += line;
+		}
+	});
+
+	return result;
+}
+
+export default trimMultiline;

package/src/lib/string/trim.ts

@@ -0,0 +1,8 @@
+function trim(value: string): string {
+	value = value.replace(/^[\s\t\n]+/g, '');
+	value = value.replace(/[\s\t\n]+$/g, '');
+
+	return value;
+}
+
+export default trim;

package/src/lib/tcp/channel.ts

@@ -0,0 +1,13 @@
+class Channel {
+	private id: string;
+
+	public constructor(id: string) {
+		this.id = id;
+	}
+
+	public getId(): string {
+		return this.id;
+	}
+}
+
+export default Channel;

package/src/lib/tcp/connection/incoming.ts

@@ -0,0 +1,72 @@
+import {Socket} from 'lib/network';
+import ExecutionContext from 'lib/execution-context';
+
+import Connection from 'lib/tcp/connection';
+
+class IncomingConnection extends Connection {
+	private paused: boolean;
+	private execution_context: ExecutionContext;
+	private data_queue: Buffer[] | undefined;
+
+	public constructor(socket: Socket, execution_context: ExecutionContext) {
+		super(socket);
+
+		this.paused = false;
+		this.execution_context = execution_context;
+
+		this.sendHeartbeat();
+	}
+
+	public enqueueData(data: Buffer): void {
+		const queue = this.getDataQueue();
+
+		queue.push(data);
+	}
+
+	public pause(): void {
+		this.paused = true;
+	}
+
+	public resume(): void {
+		this.paused = false;
+		this.emptyQueue();
+	}
+
+	public getExecutionContext(): ExecutionContext {
+		return this.execution_context;
+	}
+
+	protected handleSocketData(data: Buffer): void {
+		if (this.isPaused()) {
+			this.enqueueData(data);
+		} else {
+			super.handleSocketData(data);
+		}
+	}
+
+	private emptyQueue(): void {
+		const queue = this.getDataQueue();
+
+		while (queue.length) {
+			const data = queue.shift();
+
+			if (data) {
+				this.handleSocketData(data);
+			}
+		}
+	}
+
+	private isPaused(): boolean {
+		return this.paused;
+	}
+
+	private getDataQueue(): Buffer[] {
+		if (this.data_queue === undefined) {
+			this.data_queue = [];
+		}
+
+		return this.data_queue;
+	}
+}
+
+export default IncomingConnection;

package/src/lib/tcp/connection/outgoing.ts

@@ -0,0 +1,219 @@
+
+import {Socket, SocketOptions, ConnectionStatus} from 'lib/network';
+import {GenericError} from 'lib/errors';
+import PromiseWrapper from 'lib/promise-wrapper';
+
+import Connection from 'lib/tcp/connection';
+import ConnectionParameters from 'lib/tcp/type/connection-parameters';
+
+class OutgoingConnection extends Connection {
+	private connection_parameters: ConnectionParameters;
+	private connect_promise_wrapper: PromiseWrapper<void> | undefined;
+	private disconnect_promise_wrapper: PromiseWrapper<void> | undefined;
+
+	public constructor(
+		socket: Socket,
+		connection_parameters: ConnectionParameters
+	) {
+		super(socket);
+
+		this.connection_parameters = connection_parameters;
+	}
+
+	public async connect(): Promise<void> {
+		if (!this.canConnect()) {
+			this.throwUnableToConnectError();
+		}
+
+		this.setConnectionStatus(ConnectionStatus.CONNECTING);
+
+		const promise_wrapper = new PromiseWrapper<void>();
+		const socket = this.getSocket();
+		const socket_options = this.getSocketOptions();
+
+		this.setConnectPromiseWrapper(promise_wrapper);
+		this.logConnecting();
+
+		socket.connect(socket_options);
+
+		return promise_wrapper.getPromise();
+	}
+
+	public async disconnect(): Promise<void> {
+		if (!this.canDisconnect()) {
+			this.throwUnableToDisconnectError();
+		}
+
+		this.setConnectionStatus(ConnectionStatus.DISCONNECTING);
+
+		const promise_wrapper = new PromiseWrapper<void>();
+		const socket = this.getSocket();
+
+		this.setDisconnectPromiseWrapper(promise_wrapper);
+		this.logDisconnecting();
+
+		socket.end();
+
+		return promise_wrapper.getPromise();
+	}
+
+	protected bindHandlers(): void {
+		this.handleSocketConnected = this.handleSocketConnected.bind(this);
+
+		super.bindHandlers();
+	}
+
+	protected coupleToSocket(socket: Socket): void {
+		socket.on('connect', this.handleSocketConnected);
+
+		super.coupleToSocket(socket);
+	}
+
+	protected handleSocketError(error: Error): void {
+		const connect_promise_wrapper = this.clearConnectPromiseWrapper();
+
+		if (connect_promise_wrapper !== undefined) {
+			connect_promise_wrapper.reject(error);
+		}
+
+		const disconnect_promise_wrapper = this.clearDisconnectPromiseWrapper();
+
+		if (disconnect_promise_wrapper !== undefined) {
+			disconnect_promise_wrapper.reject(error);
+		}
+
+		super.handleSocketError(error);
+	}
+
+	protected handleSocketEnd(): void {
+		const promise_wrapper = this.clearDisconnectPromiseWrapper();
+
+		if (promise_wrapper !== undefined) {
+			promise_wrapper.resolve();
+		}
+
+		this.logDisconnected();
+
+		super.handleSocketEnd();
+	}
+
+	private canConnect(): boolean {
+		const connection_status = this.getConnectionStatus();
+
+		return connection_status === ConnectionStatus.DISCONNECTED;
+	}
+
+	private canDisconnect(): boolean {
+		const connection_status = this.getConnectionStatus();
+
+		return connection_status === ConnectionStatus.CONNECTED;
+	}
+
+	private handleSocketConnected(): void {
+		this.setConnectionStatus(ConnectionStatus.CONNECTED);
+
+		const promise_wrapper = this.clearConnectPromiseWrapper();
+
+		if (promise_wrapper !== undefined) {
+			promise_wrapper.resolve();
+		}
+
+		this.sendHeartbeat();
+		this.logConnected();
+	}
+
+	private throwUnableToConnectError(): Promise<void> {
+		const connection_status = this.getConnectionStatus();
+
+		throw new GenericError(`Unable to connect (status: ${connection_status})`);
+	}
+
+	private throwUnableToDisconnectError(): Promise<void> {
+		const connection_status = this.getConnectionStatus();
+
+		throw new GenericError(
+			`Unable to disconnect (status: ${connection_status})`
+		);
+	}
+
+	private getSocketOptions(): SocketOptions {
+		const connection_parameters = this.getConnectionParameters();
+
+		return {
+			port: connection_parameters.port,
+			host: connection_parameters.hostname
+		};
+	}
+
+	private serializeConnectionParameters(): string {
+		const {hostname, port} = this.getConnectionParameters();
+
+		return `${hostname}:${port}`;
+	}
+
+	private getConnectionParameters(): ConnectionParameters {
+		return this.connection_parameters;
+	}
+
+	private logConnecting(): void {
+		this.logConnectionMessage('Connecting to ', '...');
+	}
+
+	private logConnected(): void {
+		this.logConnectionMessage('Connected to ', '.');
+	}
+
+	private logDisconnecting(): void {
+		this.logConnectionMessage('Disconnecting from ', '...');
+	}
+
+	private logDisconnected(): void {
+		this.logConnectionMessage('Disconnected from ', '.');
+	}
+
+	private logConnectionMessage(prefix: string, suffix: string): void {
+		const id = this.getId();
+		const logger = this.getLogger();
+		const serialized_parameters = this.serializeConnectionParameters();
+
+		logger.info(`[${id}] ${prefix}${serialized_parameters}${suffix}`);
+	}
+
+	private setConnectPromiseWrapper(
+		promise_wrapper: PromiseWrapper<void>
+	): void {
+		this.connect_promise_wrapper = promise_wrapper;
+	}
+
+	private setDisconnectPromiseWrapper(
+		promise_wrapper: PromiseWrapper<void>
+	): void {
+		this.disconnect_promise_wrapper = promise_wrapper;
+	}
+
+	private clearConnectPromiseWrapper(): PromiseWrapper<void> | void {
+		if (this.connect_promise_wrapper === undefined) {
+			return undefined;
+		}
+
+		const promise_wrapper = this.connect_promise_wrapper;
+
+		this.connect_promise_wrapper = undefined;
+
+		return promise_wrapper;
+	}
+
+	private clearDisconnectPromiseWrapper(): PromiseWrapper<void> | void {
+		if (this.disconnect_promise_wrapper === undefined) {
+			return undefined;
+		}
+
+		const promise_wrapper = this.disconnect_promise_wrapper;
+
+		this.disconnect_promise_wrapper = undefined;
+
+		return promise_wrapper;
+	}
+}
+
+export default OutgoingConnection;