@fc3/mmcadi 0.1.0

package/src/lib/tcp/connection.ts

@@ -0,0 +1,360 @@
+import Logger from 'lib/logger';
+import {Socket, ConnectionStatus} from 'lib/network';
+import EventEmitter from 'lib/event-emitter';
+import KeyGenerator from 'lib/key-generator';
+import {GenericError, ConflictError} from 'lib/errors';
+import {StringEncoding} from 'lib/string';
+import {TimeInterval} from 'lib/time';
+
+import Channel from 'lib/tcp/channel';
+import Message from 'lib/tcp/type/message';
+import MessageType from 'lib/tcp/enum/message-type';
+import ConnectionEvent from 'lib/tcp/enum/connection-event';
+import ChannelOpenMessage from 'lib/tcp/type/message/channel-open';
+import ChannelCloseMessage from 'lib/tcp/type/message/channel-close';
+
+const HEARTBEAT_CHARACTER = '♥';
+const HEARTBEAT_REGEX = new RegExp(HEARTBEAT_CHARACTER, 'g');
+
+class Connection extends EventEmitter {
+	private id: string;
+	private connection_status: ConnectionStatus;
+	private remainder: string;
+	private channels: Channel[];
+	private socket: Socket;
+	private logger: Logger | undefined;
+	private parsing_enabled: boolean;
+
+	public constructor(socket: Socket) {
+		super();
+
+		this.id = KeyGenerator.generateToken();
+
+		if (socket.connecting) {
+			this.connection_status = ConnectionStatus.CONNECTING;
+		} else if (socket.pending === false && socket.readyState === 'open') {
+			this.connection_status = ConnectionStatus.CONNECTED;
+		} else {
+			this.connection_status = ConnectionStatus.DISCONNECTED;
+		}
+
+		this.remainder = '';
+		this.channels = [];
+		this.parsing_enabled = true;
+
+		this.bindHandlers();
+
+		this.socket = socket;
+		this.coupleToSocket(socket);
+	}
+
+	public sendMessage(message: Message): void {
+		const serialized_message = this.serializeMessage(message);
+
+		return this.sendRawMessage(serialized_message);
+	}
+
+	public sendRawMessage(raw_message: string): void {
+		this.validateCanSend();
+
+		const socket = this.getSocket();
+
+		socket.write(raw_message);
+	}
+
+	public end(): void {
+		const socket = this.getSocket();
+
+		socket.end();
+	}
+
+	public getId(): string {
+		return this.id;
+	}
+
+	public disableParsing(): void {
+		this.parsing_enabled = false;
+	}
+
+	public isConnected(): boolean {
+		const connection_status = this.getConnectionStatus();
+
+		return connection_status === ConnectionStatus.CONNECTED;
+	}
+
+	public getChannelById(channel_id: string): Channel {
+		const channels = this.getChannels();
+
+		const channel = channels.find((channel) => {
+			return channel.getId() === channel_id;
+		});
+
+		if (channel === undefined) {
+			throw new Error(`Unable to find channel ${channel_id}`);
+		}
+
+		return channel;
+	}
+
+	public openChannel(channel_id: string): Channel {
+		this.validateChannelId(channel_id);
+
+		const channel = new Channel(channel_id);
+
+		const message = {
+			id: KeyGenerator.generateToken(),
+			message_type: MessageType.CHANNEL_OPEN,
+			channel_id
+		};
+
+		this.sendMessage(message);
+		this.addChannel(channel);
+
+		return channel;
+	}
+
+	public closeChannel(channel_id: string): void {
+		const channel = this.getChannelById(channel_id);
+
+		const message = {
+			id: KeyGenerator.generateToken(),
+			message_type: MessageType.CHANNEL_CLOSE,
+			channel_id
+		};
+
+		this.sendMessage(message);
+		this.removeChannel(channel);
+	}
+
+	public getConnectionStatus(): ConnectionStatus {
+		return this.connection_status;
+	}
+
+	protected setConnectionStatus(connection_status: ConnectionStatus): void {
+		this.connection_status = connection_status;
+		this.emit(ConnectionEvent.STATUS_CHANGE, connection_status);
+	}
+
+	protected getSocket(): Socket {
+		return this.socket;
+	}
+
+	protected coupleToSocket(socket: Socket): void {
+		socket.on('data', this.handleSocketData);
+		socket.on('end', this.handleSocketEnd);
+		socket.on('error', this.handleSocketError);
+	}
+
+	protected bindHandlers(): void {
+		this.handleSocketData = this.handleSocketData.bind(this);
+		this.handleSocketError = this.handleSocketError.bind(this);
+		this.handleSocketEnd = this.handleSocketEnd.bind(this);
+		this.sendHeartbeat = this.sendHeartbeat.bind(this);
+	}
+
+	protected handleSocketError(error: Error): void {
+		this.emit(ConnectionEvent.ERROR, error);
+	}
+
+	protected handleSocketEnd(): void {
+		this.closeChannels();
+
+		this.setConnectionStatus(ConnectionStatus.DISCONNECTED);
+		this.emit(ConnectionEvent.END);
+	}
+
+	protected handleSocketData(data: Buffer): void {
+		const data_string = data
+			.toString(StringEncoding.UTF8)
+			.replace(HEARTBEAT_REGEX, '');
+
+		if (!this.parsingEnabled()) {
+			if (data_string.length > 0) {
+				this.emit(ConnectionEvent.RAW_MESSAGE, data_string);
+			}
+
+			return;
+		}
+
+		const old_remainder = this.getRemainder();
+		const delimiter = this.getMessageDelimiter();
+
+		let combined_string = `${old_remainder}${data_string}`;
+
+		while (combined_string.includes(delimiter)) {
+			const index = combined_string.indexOf(delimiter);
+			const current_segment = combined_string.slice(0, index);
+
+			combined_string = combined_string.slice(index + 1);
+
+			this.parseMessage(current_segment);
+		}
+
+		this.setRemainder(combined_string);
+	}
+
+	protected getLogger(): Logger {
+		if (this.logger === undefined) {
+			this.logger = new Logger();
+		}
+
+		return this.logger;
+	}
+
+	protected sendHeartbeat(): void {
+		if (!this.isConnected()) {
+			return;
+		}
+
+		this.sendRawMessage(HEARTBEAT_CHARACTER);
+
+		const delay = TimeInterval.ONE_SECOND * 5;
+
+		setTimeout(this.sendHeartbeat, delay);
+	}
+
+	private validateCanSend(): void {
+		if (this.isConnected()) {
+			return;
+		}
+
+		const connection_status = this.getConnectionStatus();
+		const id = this.getId();
+
+		const error = new GenericError(`
+			Cannot send message when connection status is ${connection_status}
+			(id: ${id})
+		`);
+
+		throw error;
+	}
+
+	private serializeMessage(message: Message): string {
+		const serialized_message = JSON.stringify(message);
+		const delimiter = this.getMessageDelimiter();
+
+		return `${serialized_message}${delimiter}`;
+	}
+
+	private getMessageDelimiter(): string {
+		return '\n';
+	}
+
+	private parseMessage(raw_message: string): void {
+		if (raw_message.length === 0) {
+			return;
+		}
+
+		let message: Message;
+
+		try {
+			message = JSON.parse(raw_message);
+		} catch (error) {
+			const logger = this.getLogger();
+
+			logger.warn(`Unable to parse socket message: ${raw_message}`);
+
+			this.destroy();
+
+			return;
+		}
+
+		this.emit(ConnectionEvent.MESSAGE, message);
+
+		switch (message.message_type) {
+			case MessageType.CHANNEL_OPEN:
+				return this.handleChannelOpenMessage(message as ChannelOpenMessage);
+			case MessageType.CHANNEL_CLOSE:
+				return this.handleChannelCloseMessage(message as ChannelCloseMessage);
+		}
+	}
+
+	private handleChannelOpenMessage(message: ChannelOpenMessage): void {
+		this.validateChannelId(message.channel_id);
+
+		const channel = new Channel(message.channel_id);
+
+		this.addChannel(channel);
+
+		this.emit(ConnectionEvent.CHANNEL_OPENED, channel);
+	}
+
+	private handleChannelCloseMessage(message: ChannelCloseMessage): void {
+		const channel = this.getChannelById(message.channel_id);
+
+		this.removeChannel(channel);
+
+		this.emit(ConnectionEvent.CHANNEL_CLOSED, channel);
+	}
+
+	private closeChannels(): void {
+		const channels = this.getChannels();
+
+		channels.forEach((channel) => {
+			this.emit(ConnectionEvent.CHANNEL_CLOSED, channel);
+			this.removeChannel(channel);
+		});
+	}
+
+	private addChannel(channel: Channel): void {
+		const channels = this.getChannels();
+
+		channels.push(channel);
+	}
+
+	private removeChannel(channel: Channel): void {
+		const channels = this.getChannels();
+		const index = channels.indexOf(channel);
+
+		if (index === -1) {
+			const channel_id = channel.getId();
+
+			throw new Error(`
+				Tried to remove channel ${channel_id} from channel list,
+				but it was not found
+			`);
+		}
+
+		channels.splice(index, 1);
+	}
+
+	private validateChannelId(channel_id: string): void {
+		if (this.hasChannelId(channel_id)) {
+			throw new ConflictError(`Channel ${channel_id} was already open`);
+		}
+	}
+
+	private hasChannelId(channel_id: string): boolean {
+		const channels = this.getChannels();
+
+		return channels.some((channel) => {
+			return channel.getId() === channel_id;
+		});
+	}
+
+	private getChannels(): Channel[] {
+		return this.channels;
+	}
+
+	private getRemainder(): string {
+		return this.remainder;
+	}
+
+	private setRemainder(remainder: string): void {
+		this.remainder = remainder;
+	}
+
+	private parsingEnabled(): boolean {
+		return this.parsing_enabled;
+	}
+
+	private destroy(): void {
+		if (this.socket === undefined) {
+			return;
+		}
+
+		this.socket.destroy();
+	}
+}
+
+export default Connection;

package/src/lib/tcp/enum/connection-event.ts

@@ -0,0 +1,12 @@
+enum ConnectionEvent {
+	CHANNEL_CLOSED = 'channel_closed',
+	CHANNEL_OPENED = 'channel_opened',
+	CONNECT = 'connect',
+	END = 'end',
+	ERROR = 'error',
+	RAW_MESSAGE = 'raw_message',
+	MESSAGE = 'message',
+	STATUS_CHANGE = 'status_change'
+}
+
+export default ConnectionEvent;

package/src/lib/tcp/enum/message-type.ts

@@ -0,0 +1,9 @@
+enum MessageType {
+	CHANNEL_OPEN = 'channel_open',
+	CHANNEL_CLOSE = 'channel_close',
+	COMMAND = 'command',
+	EVENT = 'event',
+	REQUEST = 'request'
+}
+
+export default MessageType;

package/src/lib/tcp/index.ts

@@ -0,0 +1 @@
+export {default as IncomingConnection} from 'lib/tcp/connection/incoming';

package/src/lib/tcp/type/connection-parameters.ts

@@ -0,0 +1,6 @@
+interface ConnectionParameters {
+	readonly port: number;
+	readonly hostname: string;
+}
+
+export default ConnectionParameters;

package/src/lib/tcp/type/message/channel-close.ts

@@ -0,0 +1,9 @@
+import Message from 'lib/tcp/type/message';
+import MessageType from 'lib/tcp/enum/message-type';
+
+interface ChannelCloseMessage extends Message {
+	readonly message_type: MessageType.CHANNEL_CLOSE;
+	readonly channel_id: string;
+}
+
+export default ChannelCloseMessage;

package/src/lib/tcp/type/message/channel-open.ts

@@ -0,0 +1,9 @@
+import Message from 'lib/tcp/type/message';
+import MessageType from 'lib/tcp/enum/message-type';
+
+interface ChannelOpenMessage extends Message {
+	readonly message_type: MessageType.CHANNEL_OPEN;
+	readonly channel_id: string;
+}
+
+export default ChannelOpenMessage;

package/src/lib/tcp/type/message.ts

@@ -0,0 +1,10 @@
+import MessageType from 'lib/tcp/enum/message-type';
+
+interface Message {
+	readonly message_type: MessageType;
+	readonly id: string;
+	readonly connection_id?: string;
+	readonly channel_id?: string;
+}
+
+export default Message;

package/src/lib/test/index.ts

@@ -0,0 +1,2 @@
+export {default as buildExecutionContext} from 'lib/test/utility/build-execution-context';
+export {default as buildConfig} from 'lib/test/utility/build-config';

package/src/lib/test/utility/build-config.ts

@@ -0,0 +1,17 @@
+import MemoryRepository from 'server/repository/memory';
+import RuntimeConfig from 'type/runtime-config';
+
+function buildConfig(): RuntimeConfig {
+	const public_directory = '/tmp/public';
+	const repository = new MemoryRepository();
+
+	return {
+		public_directory,
+		repository,
+		roles: [],
+		providers: [],
+		hydrate: undefined
+	};
+}
+
+export default buildConfig;

package/src/lib/test/utility/build-execution-context.ts

@@ -0,0 +1,11 @@
+import ExecutionContext from 'lib/execution-context';
+
+import buildConfig from  'lib/test/utility/build-config';
+
+function buildExecutionContext(): ExecutionContext {
+	const config = buildConfig();
+
+	return new ExecutionContext(config);
+}
+
+export default buildExecutionContext;

package/src/lib/time/bootstrap.ts

@@ -0,0 +1 @@
+throw new Error('Not implemented');

package/src/lib/time/enum/time-interval.ts

@@ -0,0 +1,12 @@
+enum TimeInterval {
+	ONE_FRAME = 16,
+	ONE_SECOND = 1000,
+	ONE_MINUTE = 1000 * 60,
+	ONE_HOUR = 1000 * 60 * 60,
+	ONE_DAY = 1000 * 60 * 60 * 24,
+	ONE_WEEK = 1000 * 60 * 60 * 24 * 7,
+	ONE_MONTH = 1000 * 60 * 60 * 24 * 30,
+	ONE_YEAR = 1000 * 60 * 60 * 24 * 365
+}
+
+export default TimeInterval;

package/src/lib/time/index.ts

@@ -0,0 +1,4 @@
+export {default as TimeInterval} from 'lib/time/enum/time-interval';
+export {default as sleep} from 'lib/time/utility/sleep';
+export {default as formatRelativeDuration} from 'lib/time/utility/format-relative-duration';
+export {default as formatDuration} from 'lib/time/utility/format-duration';

package/src/lib/time/utility/format-duration.ts

@@ -0,0 +1,139 @@
+import {NounInflector} from 'lib/grammar';
+
+import TimeInterval from 'lib/time/enum/time-interval';
+
+function formatMilliseconds(ms: number, shorthand = false): string {
+	if (shorthand) {
+		return `${ms}ms`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(ms, 'millisecond');
+}
+
+function formatSeconds(ms: number, shorthand = false): string {
+	const seconds = Math.floor(ms / TimeInterval.ONE_SECOND);
+
+	if (shorthand) {
+		return `${seconds}s`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(seconds, 'second');
+}
+
+function formatMinutes(ms: number, shorthand = false): string {
+	const minutes = Math.floor(ms / TimeInterval.ONE_MINUTE);
+
+	if (shorthand) {
+		return `${minutes}m`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(minutes, 'minute');
+}
+
+function formatHours(ms: number, shorthand = false): string {
+	const hours = Math.floor(ms / TimeInterval.ONE_HOUR);
+
+	if (shorthand) {
+		return `${hours}h`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(hours, 'hour');
+}
+
+function formatDays(ms: number, shorthand = false): string {
+	const days = Math.floor(ms / TimeInterval.ONE_DAY);
+
+	if (shorthand) {
+		return `${days}d`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(days, 'day');
+}
+
+function formatWeeks(ms: number, shorthand = false): string {
+	const weeks = Math.floor(ms / TimeInterval.ONE_WEEK);
+
+	if (shorthand) {
+		return `${weeks}w`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(weeks, 'week');
+}
+
+function formatMonths(ms: number, shorthand = false): string {
+	const months = Math.floor(ms / TimeInterval.ONE_MONTH);
+
+	if (shorthand) {
+		return `${months}mo`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(months, 'month');
+}
+
+function formatYears(ms: number, shorthand = false): string {
+	let years = ms / TimeInterval.ONE_YEAR;
+
+	const years_rounded = Math.round(years);
+
+	if (Math.abs(years - years_rounded) < 1 / 24) {
+		years = years_rounded;
+	} else {
+		years = parseFloat(years.toFixed(1));
+	}
+
+	if (shorthand) {
+		return `${years}y`;
+	}
+
+	const inflector = new NounInflector();
+
+	return inflector.singularizeOrPluralize(years, 'year');
+}
+
+function formatDuration(ms: number, shorthand = false): string {
+	if (ms < TimeInterval.ONE_SECOND) {
+		return formatMilliseconds(ms, shorthand);
+	}
+
+	if (ms < TimeInterval.ONE_MINUTE) {
+		return formatSeconds(ms, shorthand);
+	}
+
+	if (ms < TimeInterval.ONE_HOUR) {
+		return formatMinutes(ms, shorthand);
+	}
+
+	if (ms < TimeInterval.ONE_DAY) {
+		return formatHours(ms, shorthand);
+	}
+
+	if (ms < TimeInterval.ONE_WEEK) {
+		return formatDays(ms, shorthand);
+	}
+
+	if (ms < TimeInterval.ONE_MONTH) {
+		return formatWeeks(ms, shorthand);
+	}
+
+	if (ms < TimeInterval.ONE_YEAR) {
+		return formatMonths(ms, shorthand);
+	}
+
+	return formatYears(ms, shorthand);
+}
+
+export default formatDuration;

package/src/lib/time/utility/format-relative-duration.ts

@@ -0,0 +1,22 @@
+import formatDuration from 'lib/time/utility/format-duration';
+
+function formatRelativeDuration(
+	date: number | Date | string,
+	shorthand = false
+): string {
+	let ms: number;
+
+	if (date instanceof Date) {
+		ms = date.getTime();
+	} else if (typeof date === 'string') {
+		ms = new Date(date).getTime();
+	} else {
+		ms = date;
+	}
+
+	const elapsed_time = Date.now() - ms;
+
+	return formatDuration(elapsed_time, shorthand);
+}
+
+export default formatRelativeDuration;

package/src/lib/time/utility/sleep.ts

@@ -0,0 +1,9 @@
+function sleep(duration: number): Promise<void> {
+	return new Promise((resolve) => {
+		setTimeout(() => {
+			resolve();
+		}, duration);
+	});
+}
+
+export default sleep;

package/src/operation.ts

@@ -0,0 +1,18 @@
+import {AutoLoggingOperation} from 'lib/operation';
+import ExecutionContext from 'lib/execution-context';
+
+import RuntimeConfig from 'type/runtime-config';
+
+abstract class BaseOperation<T> extends AutoLoggingOperation<T> {
+	public constructor(execution_context: ExecutionContext) {
+		super(execution_context);
+	}
+
+	protected getConfig(): RuntimeConfig {
+		const execution_context = this.getExecutionContext();
+
+		return execution_context.getConfig();
+	}
+}
+
+export default BaseOperation;