@fc3/mmcadi 0.1.0 → 0.1.2

package/src/lib/server/tcp.ts

@@ -1,53 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

package/src/lib/string/hyphenate.ts

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

package/src/lib/string/index.ts

@@ -1,3 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,219 +0,0 @@
-
-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;