Differential D15700 Diff 37843 support/aphlict/server/lib/AphlictAdminServer.js

Changeset View

Standalone View

support/aphlict/server/lib/AphlictAdminServer.js

	'use strict';			'use strict';

	var JX = require('./javelin').JX;			var JX = require('./javelin').JX;

	require('./AphlictListenerList');			require('./AphlictListenerList');

	var http = require('http');			var http = require('http');
	var url = require('url');			var url = require('url');

	JX.install('AphlictAdminServer', {			JX.install('AphlictAdminServer', {

	construct: function() {			construct: function(server) {
	this.setLogger(new JX.AphlictLog());

	this._startTime = new Date().getTime();			this._startTime = new Date().getTime();
	this._messagesIn = 0;			this._messagesIn = 0;
	this._messagesOut = 0;			this._messagesOut = 0;

	var handler = this._handler.bind(this);			server.on('request', JX.bind(this, this._onrequest));
	this._server = http.createServer(handler);			this._server = server;
				this._clientServers = [];
				},

				properties: {
				clientServers: null,
				logger: null,
	},			},

	members: {			members: {
	_messagesIn: null,			_messagesIn: null,
	_messagesOut: null,			_messagesOut: null,
	_server: null,			_server: null,
	_startTime: null,			_startTime: null,

	getListenerList: function(instance) {			getListenerLists: function(instance) {
	return this.getClientServer().getListenerList(instance);			var clients = this.getClientServers();

				var lists = [];
				for (var ii = 0; ii < clients.length; ii++) {
				lists.push(clients[ii].getListenerList(instance));
				}
				return lists;
				},

				log: function() {
				var logger = this.getLogger();
				if (!logger) {
				return;
				}

				logger.log.apply(logger, arguments);

				return this;
	},			},

	listen: function() {			listen: function() {
	return this._server.listen.apply(this._server, arguments);			return this._server.listen.apply(this._server, arguments);
	},			},

	_handler: function(request, response) {			_onrequest: function(request, response) {
	var self = this;			var self = this;
	var u = url.parse(request.url, true);			var u = url.parse(request.url, true);
	var instance = u.query.instance \|\| '/';			var instance = u.query.instance \|\| '/';

	// Publishing a notification.			// Publishing a notification.
	if (u.pathname == '/') {			if (u.pathname == '/') {
	if (request.method == 'POST') {			if (request.method == 'POST') {
	var body = '';			var body = '';

	request.on('data', function(data) {			request.on('data', function(data) {
	body += data;			body += data;
	});			});

	request.on('end', function() {			request.on('end', function() {
	try {			try {
	var msg = JSON.parse(body);			var msg = JSON.parse(body);

	self.getLogger().log(			self.log(
	'Received notification (' + instance + '): ' +			'Received notification (' + instance + '): ' +
	JSON.stringify(msg));			JSON.stringify(msg));
	++self._messagesIn;			++self._messagesIn;

	try {			try {
	self._transmit(instance, msg);			self._transmit(instance, msg);
	response.writeHead(200, {'Content-Type': 'text/plain'});			response.writeHead(200, {'Content-Type': 'text/plain'});
	} catch (err) {			} catch (err) {
	self.getLogger().log(			self.log(
	'<%s> Internal Server Error! %s',			'<%s> Internal Server Error! %s',
	request.socket.remoteAddress,			request.socket.remoteAddress,
	err);			err);
	response.writeHead(500, 'Internal Server Error');			response.writeHead(500, 'Internal Server Error');
	}			}
	} catch (err) {			} catch (err) {
	self.getLogger().log(			self.log(
	'<%s> Bad Request! %s',			'<%s> Bad Request! %s',
	request.socket.remoteAddress,			request.socket.remoteAddress,
	err);			err);
	response.writeHead(400, 'Bad Request');			response.writeHead(400, 'Bad Request');
	} finally {			} finally {
	response.end();			response.end();
	}			}
	});			});
	} else {			} else {
	response.writeHead(405, 'Method Not Allowed');			response.writeHead(405, 'Method Not Allowed');
	response.end();			response.end();
	}			}
	} else if (u.pathname == '/status/') {			} else if (u.pathname == '/status/') {
	var status = {			this._handleStatusRequest(request, response, instance);
				} else {
				response.writeHead(404, 'Not Found');
				response.end();
				}
				},

				_handleStatusRequest: function(request, response, instance) {
				var active_count = 0;
				var total_count = 0;

				var lists = this.getListenerLists(instance);
				for (var ii = 0; ii < lists.length; ii++) {
				var list = lists[ii];
				active_count += list.getActiveListenerCount();
				total_count += list.getTotalListenerCount();
				}

				var server_status = {
	'instance': instance,			'instance': instance,
	'uptime': (new Date().getTime() - this._startTime),			'uptime': (new Date().getTime() - this._startTime),
	'clients.active': this.getListenerList(instance)			'clients.active': active_count,
	.getActiveListenerCount(),			'clients.total': total_count,
	'clients.total': this.getListenerList(instance)
	.getTotalListenerCount(),
	'messages.in': this._messagesIn,			'messages.in': this._messagesIn,
	'messages.out': this._messagesOut,			'messages.out': this._messagesOut,
	'version': 7			'version': 7
	};			};

	response.writeHead(200, {'Content-Type': 'application/json'});			response.writeHead(200, {'Content-Type': 'application/json'});
	response.write(JSON.stringify(status));			response.write(JSON.stringify(server_status));
	response.end();			response.end();
	} else {
	response.writeHead(404, 'Not Found');
	response.end();
	}
	},			},

	/**			/**
	* Transmits a message to all subscribed listeners.			* Transmits a message to all subscribed listeners.
	*/			*/
	_transmit: function(instance, message) {			_transmit: function(instance, message) {
	var listeners = this.getListenerList(instance)			var lists = this.getListenerLists(instance);
	.getListeners()
	.filter(function(client) {			for (var ii = 0; ii < lists.length; ii++) {
	return client.isSubscribedToAny(message.subscribers);			var list = lists[ii];
	});			var listeners = list.getListeners();
				this._transmitToListeners(list, listeners, message);
				}
				},

	for (var i = 0; i < listeners.length; i++) {			_transmitToListeners: function(list, listeners, message) {
	var listener = listeners[i];			for (var ii = 0; ii < listeners.length; ii++) {
				var listener = listeners[ii];

				if (!listener.isSubscribedToAny(message.subscribers)) {
				continue;
				}

	try {			try {
	listener.writeMessage(message);			listener.writeMessage(message);

	++this._messagesOut;			++this._messagesOut;
	this.getLogger().log(			this.log(
	'<%s> Wrote Message',			'<%s> Wrote Message',
	listener.getDescription());			listener.getDescription());
	} catch (error) {			} catch (error) {
	this.getListenerList(instance).removeListener(listener);			list.removeListener(listener);
	this.getLogger().log(
				this.log(
	'<%s> Write Error: %s',			'<%s> Write Error: %s',
	listener.getDescription(),			listener.getDescription(),
	error);			error);
	}			}
	}			}
	},			}
	},

	properties: {
	clientServer: null,
	logger: null,
	}			}

	});			});