wirc-backend.git

@@ -1,5 +1,9 @@

 {

 	"port": 7979,

-	"verbosity": 1

+	"verbosity": 1,

+	"cleaning": {

+		"timeout_in_seconds": 120,

+		"worker_interval_in_seconds": 60

+	}

 }

@@ -34,10 +34,17 @@ Example: `curl 'http://localhost:7979' -d '{"id":"foo1bar2",action":"send","data

 - output type: `boolean`

-### `send`

+### `send_channel`

-- description: sends a message

-- input type: `record<channel:string,message:string>`

+- description: sends a message to a channel

+- input type: `record<channel:string,content:string>`

+- output type: `void`

+

+

+### `send_query`

+

+- description: sends a message to a query

+- input type: `record<receiver:string,content:string>`

 - output type: `void`

@@ -3,6 +3,11 @@

 A simple mediator between an IRC server and a web application

+# Dependencies

+

+- [node irc](https://node-irc.readthedocs.io/en/latest/)

+

+

 # Licence

 - model: GPLv3

@@ -31,4 +36,7 @@ After building just execute `cd build && ./wirc`!

 # Plans and ToDos

 - support commands (e.g. `/nick new_name`)

+- support for actions (e.g. `/me smiles`)

+- add join and part events to `fetch`

+- support topic

@@ -1,3 +1,22 @@

+declare var setInterval: any;

+

+

+type type_conf =

+(

+	null

+	|

+	{

+		port: int;

+		verbosity: int;

+		cleaning:

+		{

+			timeout_in_seconds: int;

+			worker_interval_in_seconds: int;

+		};

+	}

+);

+

+

 type type_event =

 {

 	timestamp: int;

@@ -15,15 +34,25 @@ type type_user =

 type type_connection =

 {

-	events: Array<type_event>;

-	users: Array<type_user>;

 	client: any;

+	eventqueue: Array<type_event>;

+	termination: (null | int);

+};

+

+

+type type_id = string;

+

+

+type type_model =

+{

+	counter: int;

+	connections: Record<type_id, type_connection>;

 };

 type type_internal_request =

 {

-	id: (null | string);

+	id: (null | type_id);

 	action: string;

 	data: any;

 };

@@ -32,66 +61,128 @@ type type_internal_request =

 type type_internal_response = any;

-function get_timestamp(): int

+/**

+ * the node module "irc"

+ */

+var nm_irc: any;

+

+

+/**

+ * gets the current UNIX timestamp

+ */

+function get_timestamp

+(

+): int

 {

 	return Math.floor(Date.now()/1000);

 }

-function generate_id(): string

+

+/**

+ * generates a unique 8 digit long string

+ */

+function generate_id

+(

+	model: type_model

+): type_id

 {

-	return (Math.random() * (1 << 24)).toFixed(0).padStart(8, '0');

+	model.counter += 1;

+	return model.counter.toFixed(0).padStart(8, '0');

 }

-var nm_irc: any = require("irc");

-

-

-var _connections: Record<string, type_connection> = {};

-

-

-var _conf: any = {};

+/**

+ * writes a message to stderr

+ */

+function log

+(

+	conf: type_conf,

+	level: int,

+	incident: string,

+	details: Record<string, any> = {}

+): void

+{

+	if (level <= conf.verbosity)

+	{

+		process.stderr.write(`-- ${incident} | ${lib_json.encode(details)}\n`);

+	}

+	else

+	{

+		// do nothing

+	}

+}

-function log(level: int, incident: string, details: Record<string, any> = {}): void

+/**

+ * updates the termination timestamp of a connection, prolonging its lifetime

+ */

+function connection_touch

+(

+	conf: type_conf,

+	connection: type_connection

+): void

 {

-	if (level <= _conf["verbosity"])

+	if (conf.cleaning.timeout_in_seconds !== null)

 	{

-		process.stderr.write(`-- ${incident} | ${lib_json.encode(details)}\n`);

+		connection.termination = (get_timestamp() + conf.cleaning.timeout_in_seconds);

+	}

+	else

+	{

+		connection.termination = null;

 	}

 }

-function get_connection(id: string): type_connection

+/**

+ * gets a connection by its ID

+ */

+function get_connection

+(

+	conf: type_conf,

+	model: type_model,

+	id: type_id

+): type_connection

 {

-	if (! _connections.hasOwnProperty(id))

+	if (! model.connections.hasOwnProperty(id))

 	{

-		throw (new Error("no connection for ID '" + id + "'"));

+		throw (new Error(`no connection for ID '${id}'`));

 	}

 	else

 	{

-		return _connections[id];

+		const connection: type_connection = model.connections[id];

+		connection_touch(conf, connection);

+		return connection;

 	}

 }

-async function execute(internal_request: type_internal_request, ip_address: string): Promise<type_internal_response>

+/**

+ * executes a request

+ */

+async function execute

+(

+	conf: type_conf,

+	model: type_model,

+	internal_request: type_internal_request,

+	ip_address: string

+): Promise<type_internal_response>

 {

 	switch (internal_request.action)

 	{

 		default:

 		{

-			throw (new Error("unhandled action: " + internal_request.action));

+			throw (new Error(`unhandled action '${internal_request.action}'`));

 			break;

 		}

 		case "connect":

 		{

-			if (_connections.hasOwnProperty(internal_request.id))

+			if (model.connections.hasOwnProperty(internal_request.id))

 			{

 				throw (new Error("already connected"));

 			}

 			else

 			{

-				const id: string = generate_id();

+				const id: type_id = generate_id(model);

 				const client = new nm_irc.Client

 				(

 					internal_request.data["server"],

@@ -107,32 +198,32 @@ async function execute(internal_request: type_internal_request, ip_address: stri

 				let connection: type_connection =

 				{

 					"client": client,

-					"events": [],

-					"users": [],

+					"eventqueue": [],

+					"termination": null,

 				};

 				client.addListener

 				(

-					"message",

-					(from, to, message) =>

+					"message#",

+					(nick, to, text, message) =>

 					{

-						connection.events.push

+						connection.eventqueue.push

 						({

 							"timestamp": get_timestamp(),

-							"kind": "channel_message",

-							"data": {"from": from, "to": to, "message": message}

+							"kind": "message_channel",

+							"data": {"channel": to, "sender": nick, "content": text}

 						});

 					}

 				);

 				client.addListener

 				(

 					"pm",

-					(from, message) =>

+					(nick, text, message) =>

 					{

-						connection.events.push

+						connection.eventqueue.push

 						({

 							"timestamp": get_timestamp(),

-							"kind": "private_message",

-							"data": {"from": from, "message": message}

+							"kind": "message_query",

+							"data": {"user_name": nick, "sender": nick, "content": text}

 						});

 					}

 				);

@@ -141,7 +232,13 @@ async function execute(internal_request: type_internal_request, ip_address: stri

 					"names",

 					(channel, users) =>

 					{

-						connection.users = Object.entries(users).map(([key, value]) => ({"name": key, "role": value.toString()}));

+						

+						connection.eventqueue.push

+						({

+							"timestamp": get_timestamp(),

+							"kind": "userlist",

+							"data": {"channel": channel, "users": Object.entries(users).map(([name, role]) => ({"name": name, "role": role}))}

+						});

 					}

 				);

 				client.addListener

@@ -149,7 +246,7 @@ async function execute(internal_request: type_internal_request, ip_address: stri

 					"error",

 					(error) =>

 					{

-						log(0, "irc_error", {"reason": error.message});

+						log(conf, 0, "irc_error", {"reason": error.message});

 					}

 				);

 				client.connect

@@ -157,7 +254,8 @@ async function execute(internal_request: type_internal_request, ip_address: stri

 					3,

 					() =>

 					{

-						_connections[id] = connection;

+						model.connections[id] = connection;

+						connection_touch(conf, connection);

 					}

 				);

 				return Promise.resolve<type_internal_response>(id);

@@ -168,7 +266,7 @@ async function execute(internal_request: type_internal_request, ip_address: stri

 		{

 			try

 			{

-				get_connection(internal_request.id);

+				get_connection(conf, model, internal_request.id);

 				return Promise.resolve<type_internal_response>(true);

 			}

 			catch (error)

@@ -179,51 +277,91 @@ async function execute(internal_request: type_internal_request, ip_address: stri

 		}

 		case "disconnect":

 		{

-			const connection: type_connection = get_connection(internal_request.id);

-			delete _connections[internal_request.id];

+			const connection: type_connection = get_connection(conf, model, internal_request.id);

+			delete model.connections[internal_request.id];

 			connection.client.disconnect("", () => {});

 			return Promise.resolve<type_internal_response>(null);

 			break;

 		}

-		case "send":

+		case "send_channel":

 		{

-			const connection: type_connection = get_connection(internal_request.id);

-			connection.client.say(internal_request.data["channel"], internal_request.data["message"]);

+			const connection: type_connection = get_connection(conf, model, internal_request.id);

+			connection.client.say(internal_request.data["channel"], internal_request.data["content"]);

 			return Promise.resolve<type_internal_response>(null);

 			break;

 		}

-		case "fetch":

+		case "send_query":

 		{

-			const connection: type_connection = get_connection(internal_request.id);

-			const internal_response: type_internal_response =

+			const connection: type_connection = get_connection(conf, model, internal_request.id);

+			connection.client.say(internal_request.data["receiver"], internal_request.data["content"]);

+			return Promise.resolve<type_internal_response>(null);

+			break;

+		}

+		case "fetch":

 		{

-				"users": connection.users,

-				"events": connection.events,

-			};

-			connection.events = [];

+			const connection: type_connection = get_connection(conf, model, internal_request.id);

+			const internal_response: type_internal_response = connection.eventqueue;

+			connection.eventqueue = [];

 			return Promise.resolve<type_internal_response>(internal_response);

 			break;

 		}

 	}

 }

-async function main(): Promise<void>

+

+/**

+ * sets up the worker for terminating old connections

+ */

+function setup_cleaner

+(

+	conf: type_conf,

+	model: type_model

+): Promise<void>

+{

+	setInterval

+	(

+		() =>

+		{

+			const now: int = get_timestamp();

+			for (const [id, connection] of Object.entries(model.connections))

+			{

+				if ((connection.termination !== null) && (now > connection.termination))

+				{

+					delete model.connections[id];

+					connection.client.disconnect("timeout", () => {});

+					log(conf, 1, "connection terminated after timeout", {"id": id});

+				}

+			}

+		},

+		(conf.cleaning.worker_interval_in_seconds * 1000)

+	);

+	return Promise.resolve<void>(undefined);

+}

+

+

+/**

+ * sets up the server, accepting HTTP request

+ */

+function setup_server

+(

+	conf: type_conf,

+	model: type_model

+): Promise<void>

 {

-	_conf = await lib_plankton.file.read("conf.json").then<any>(x => lib_json.decode(x));

 	const server: lib_server.class_server = new lib_server.class_server

 	(

-		_conf["port"],

+		conf.port,

 		async (input: string, metadata?: lib_server.type_metadata): Promise<string> =>

 		{

 			const http_request: lib_http.type_request = lib_http.decode_request(input);

-			log(2, "http_request", http_request);

+			log(conf, 2, "http_request", http_request);

 			const internal_request: type_internal_request = lib_json.decode(http_request.body);

-			log(1, "internal_request", internal_request);

+			log(conf, 1, "internal_request", internal_request);

 			let internal_response: type_internal_response;

 			let error: (null | Error);

 			try

 			{

-				internal_response = await execute(internal_request, metadata.ip_address);

+				internal_response = await execute(conf, model, internal_request, metadata.ip_address);

 				error = null;

 			}

 			catch (error_)

@@ -231,32 +369,58 @@ async function main(): Promise<void>

 				internal_response = null;

 				error = error_;

 			}

+			let http_response: lib_http.type_response;

 			if (error !== null)

 			{

-				log(0, "error_in_execution", {"reason": error.toString()});

-			}

-			const http_response: lib_http.type_response =

-			(

-				(error !== null)

-				? {

+				log(conf, 0, "error_in_execution", {"reason": error.toString()});

+				http_response =

+				{

 					"statuscode": 500,

 					"headers": {"Access-Control-Allow-Origin": "*", "Content-Type": "text/plain"},

 					"body": "error executing the request; check the server logs for details",

+				};

 			}

-				: {

+			else

+			{

+				log(conf, 1, "internal_response", {"value": internal_response});

+				http_response =

+				{

 					"statuscode": 200,

 					"headers": {"Access-Control-Allow-Origin": "*", "Content-Type": "application/json"},

 					"body": lib_json.encode(internal_response)

 				}

-			);

-			log(2, "http_response", http_response);

+			}

+			log(conf, 2, "http_response", http_response);

 			const output: string = lib_http.encode_response(http_response);

 			return Promise.resolve<string>(output);

 		}

 	);

-	return server.start();

+	server.start();

+	return Promise.resolve<void>(undefined);

+}

+

+

+/**

+ * initializes and starts the whole system

+ */

+async function main

+(

+): Promise<void>

+{

+	nm_irc = require("irc");

+	const conf: type_conf = await lib_plankton.file.read("conf.json").then<type_conf>(lib_json.decode);

+	let model: type_model =

+	{

+		"counter": 0,

+		"connections": {},

+	};

+	await Promise.all([

+		setup_cleaner(conf, model),

+		setup_server(conf, model),

+	]);

+	return Promise.resolve<void>(undefined);

 }

-main();

+main().then(() => {}).catch((reason) => process.stderr.write(reason.toString()));