wirc-backend.git

1) declare var setInterval: any;
2) 
3) 
4) type type_conf =
5) (
6) 	null
7) 	|
8) 	{
9) 		port: int;
10) 		verbosity: int;
11) 		cleaning:
12) 		{
13) 			timeout_in_seconds: int;
14) 			worker_interval_in_seconds: int;
15) 		};
16) 	}
17) );
18) 
19) 

20) type type_event =
21) {

22) 	timestamp: int;
23) 	kind: string;
24) 	data: any;
25) };
26) 
27) 

28) type type_user =
29) {

30) 	name: string;
31) 	role: string;
32) };
33) 
34) 

35) type type_connection =
36) {

37) 	client: any;

38) 	eventqueue: Array<type_event>;
39) 	termination: (null | int);
40) };
41) 
42) 
43) type type_id = string;
44) 
45) 
46) type type_model =
47) {
48) 	counter: int;
49) 	connections: Record<type_id, type_connection>;

50) };
51) 
52) 

53) type type_internal_request =

54) {

55) 	id: (null | type_id);

56) 	action: string;
57) 	data: any;
58) };
59) 

60) 

61) type type_internal_response = any;

62) 

63) 

64) /**
65)  * the node module "irc"
66)  */
67) var nm_irc: any;
68) 
69) 
70) /**
71)  * gets the current UNIX timestamp
72)  */
73) function get_timestamp
74) (
75) ): int

76) {

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

78) }
79) 

80) 
81) /**
82)  * generates a unique 8 digit long string
83)  */
84) function generate_id
85) (
86) 	model: type_model
87) ): type_id

88) {

89) 	model.counter += 1;
90) 	return model.counter.toFixed(0).padStart(8, '0');

91) }
92) 
93) 

94) /**
95)  * writes a message to stderr
96)  */
97) function log
98) (
99) 	conf: type_conf,
100) 	level: int,
101) 	incident: string,
102) 	details: Record<string, any> = {}
103) ): void
104) {
105) 	if (level <= conf.verbosity)
106) 	{
107) 		process.stderr.write(`-- ${incident} | ${lib_json.encode(details)}\n`);
108) 	}
109) 	else
110) 	{
111) 		// do nothing
112) 	}
113) }

114) 
115) 

116) /**
117)  * updates the termination timestamp of a connection, prolonging its lifetime
118)  */
119) function connection_touch
120) (
121) 	conf: type_conf,
122) 	connection: type_connection
123) ): void

124) {

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

126) 	{

127) 		connection.termination = (get_timestamp() + conf.cleaning.timeout_in_seconds);
128) 	}
129) 	else
130) 	{
131) 		connection.termination = null;

132) 	}
133) }

134) 
135) 

136) /**
137)  * gets a connection by its ID
138)  */
139) function get_connection
140) (
141) 	conf: type_conf,
142) 	model: type_model,
143) 	id: type_id
144) ): type_connection

145) {

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

147) 	{

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

149) 	}

150) 	else
151) 	{

152) 		const connection: type_connection = model.connections[id];
153) 		connection_touch(conf, connection);
154) 		return connection;

155) 	}
156) }
157) 
158) 

159) /**
160)  * executes a request
161)  */
162) async function execute
163) (
164) 	conf: type_conf,
165) 	model: type_model,
166) 	internal_request: type_internal_request,
167) 	ip_address: string
168) ): Promise<type_internal_response>

169) {

170) 	switch (internal_request.action)
171) 	{
172) 		default:
173) 		{

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

175) 			break;
176) 		}
177) 		case "connect":
178) 		{

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

180) 			{
181) 				throw (new Error("already connected"));
182) 			}
183) 			else
184) 			{

185) 				const id: type_id = generate_id(model);

186) 				const client = new nm_irc.Client
187) 				(
188) 					internal_request.data["server"],
189) 					internal_request.data["nickname"],
190) 					{

191) 						"realName": "webirc",

192) 						"userName": lib_sha256.get(ip_address).slice(0, 8),
193) 						"channels": internal_request.data["channels"],
194) 						"showErrors": true,
195) 						"autoConnect": false,

196) 					}

197) 				);

198) 				let connection: type_connection =

199) 				{
200) 					"client": client,

201) 					"eventqueue": [],
202) 					"termination": null,

203) 				};
204) 				client.addListener
205) 				(

206) 					"message#",
207) 					(nick, to, text, message) =>

208) 					{

209) 						connection.eventqueue.push

210) 						({
211) 							"timestamp": get_timestamp(),

212) 							"kind": "message_channel",
213) 							"data": {"channel": to, "sender": nick, "content": text}

214) 						});

215) 					}

216) 				);
217) 				client.addListener
218) 				(
219) 					"pm",

220) 					(nick, text, message) =>

221) 					{

222) 						connection.eventqueue.push

223) 						({
224) 							"timestamp": get_timestamp(),

225) 							"kind": "message_query",
226) 							"data": {"user_name": nick, "sender": nick, "content": text}

227) 						});

228) 					}

229) 				);
230) 				client.addListener
231) 				(
232) 					"names",
233) 					(channel, users) =>
234) 					{

235) 						
236) 						connection.eventqueue.push
237) 						({
238) 							"timestamp": get_timestamp(),
239) 							"kind": "userlist",
240) 							"data": {"channel": channel, "users": Object.entries(users).map(([name, role]) => ({"name": name, "role": role}))}
241) 						});

242) 					}

243) 				);
244) 				client.addListener
245) 				(
246) 					"error",
247) 					(error) =>
248) 					{

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

250) 					}

251) 				);
252) 				client.connect
253) 				(
254) 					3,
255) 					() =>
256) 					{

257) 						model.connections[id] = connection;
258) 						connection_touch(conf, connection);

259) 					}
260) 				);
261) 				return Promise.resolve<type_internal_response>(id);
262) 			}
263) 			break;
264) 		}
265) 		case "check":
266) 		{
267) 			try
268) 			{

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

270) 				return Promise.resolve<type_internal_response>(true);
271) 			}
272) 			catch (error)
273) 			{
274) 				return Promise.resolve<type_internal_response>(false);
275) 			}
276) 			break;
277) 		}
278) 		case "disconnect":
279) 		{

280) 			const connection: type_connection = get_connection(conf, model, internal_request.id);
281) 			delete model.connections[internal_request.id];

282) 			connection.client.disconnect("", () => {});
283) 			return Promise.resolve<type_internal_response>(null);
284) 			break;
285) 		}

286) 		case "send_channel":

287) 		{

288) 			const connection: type_connection = get_connection(conf, model, internal_request.id);
289) 			connection.client.say(internal_request.data["channel"], internal_request.data["content"]);
290) 			return Promise.resolve<type_internal_response>(null);
291) 			break;
292) 		}
293) 		case "send_query":
294) 		{
295) 			const connection: type_connection = get_connection(conf, model, internal_request.id);
296) 			connection.client.say(internal_request.data["receiver"], internal_request.data["content"]);

297) 			return Promise.resolve<type_internal_response>(null);
298) 			break;
299) 		}
300) 		case "fetch":
301) 		{

302) 			const connection: type_connection = get_connection(conf, model, internal_request.id);
303) 			const internal_response: type_internal_response = connection.eventqueue;
304) 			connection.eventqueue = [];

305) 			return Promise.resolve<type_internal_response>(internal_response);
306) 			break;
307) 		}
308) 	}
309) }
310) 

311) 
312) /**
313)  * sets up the worker for terminating old connections
314)  */
315) function setup_cleaner
316) (
317) 	conf: type_conf,
318) 	model: type_model
319) ): Promise<void>
320) {
321) 	setInterval
322) 	(
323) 		() =>
324) 		{
325) 			const now: int = get_timestamp();
326) 			for (const [id, connection] of Object.entries(model.connections))
327) 			{
328) 				if ((connection.termination !== null) && (now > connection.termination))
329) 				{
330) 					delete model.connections[id];
331) 					connection.client.disconnect("timeout", () => {});
332) 					log(conf, 1, "connection terminated after timeout", {"id": id});
333) 				}
334) 			}
335) 		},
336) 		(conf.cleaning.worker_interval_in_seconds * 1000)
337) 	);
338) 	return Promise.resolve<void>(undefined);
339) }
340) 
341) 
342) /**
343)  * sets up the server, accepting HTTP request
344)  */
345) function setup_server
346) (
347) 	conf: type_conf,
348) 	model: type_model
349) ): Promise<void>

350) {
351) 	const server: lib_server.class_server = new lib_server.class_server
352) 	(

353) 		conf.port,

354) 		async (input: string, metadata?: lib_server.type_metadata): Promise<string> =>
355) 		{
356) 			const http_request: lib_http.type_request = lib_http.decode_request(input);

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

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

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

360) 			let internal_response: type_internal_response;
361) 			let error: (null | Error);
362) 			try
363) 			{

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

365) 				error = null;
366) 			}

367) 			catch (error_)
368) 			{
369) 				internal_response = null;

370) 				error = error_;
371) 			}

372) 			let http_response: lib_http.type_response;

373) 			if (error !== null)
374) 			{

375) 				log(conf, 0, "error_in_execution", {"reason": error.toString()});
376) 				http_response =
377) 				{

378) 					"statuscode": 500,

379) 					"headers": {"Access-Control-Allow-Origin": "*", "Content-Type": "text/plain"},
380) 					"body": "error executing the request; check the server logs for details",

381) 				};
382) 			}
383) 			else
384) 			{
385) 				log(conf, 1, "internal_response", {"value": internal_response});
386) 				http_response =
387) 				{

388) 					"statuscode": 200,

389) 					"headers": {"Access-Control-Allow-Origin": "*", "Content-Type": "application/json"},
390) 					"body": lib_json.encode(internal_response)

391) 				}

392) 			}
393) 			log(conf, 2, "http_response", http_response);

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

395) 			return Promise.resolve<string>(output);
396) 		}
397) 	);

398) 	server.start();
399) 	return Promise.resolve<void>(undefined);
400) }
401) 
402) 
403) /**
404)  * initializes and starts the whole system
405)  */
406) async function main
407) (
408) ): Promise<void>
409) {
410) 	nm_irc = require("irc");
411) 	const conf: type_conf = await lib_plankton.file.read("conf.json").then<type_conf>(lib_json.decode);
412) 	let model: type_model =
413) 	{
414) 		"counter": 0,
415) 		"connections": {},
416) 	};
417) 	await Promise.all([
418) 		setup_cleaner(conf, model),
419) 		setup_server(conf, model),
420) 	]);
421) 	return Promise.resolve<void>(undefined);

422) }
423) 

424) 

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