irrelon-reactor-autonet/es5/class/AutoNet.js

A module for automatically creating groups of self-networking services.

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _request = require('request');

var _request2 = _interopRequireDefault(_request);

var _async = require('async');

var _async2 = _interopRequireDefault(_async);

var _forerunnerdb = require('forerunnerdb');

var _forerunnerdb2 = _interopRequireDefault(_forerunnerdb);

var _polo = require('polo');

var _polo2 = _interopRequireDefault(_polo);

var _Server2 = require('./Server');

var _Server3 = _interopRequireDefault(_Server2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var AutoNet = function (_Server) {
	_inherits(AutoNet, _Server);

	function AutoNet(name) {
		_classCallCheck(this, AutoNet);

		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(AutoNet).call(this, name));

		_this.fdb = new _forerunnerdb2.default();
		_this.db = _this.fdb.db('broadcast');

		_this.peer = _this.db.collection('peer', {
			primaryKey: 'name'
		});

		_this.client = _this.db.collection('client', {
			primaryKey: 'name'
		});

		_this._started = false;
		_this._lastAdvert = 0;
		_this._discover = [];
		_this._zeroConfig = (0, _polo2.default)();
		return _this;
	}

	_createClass(AutoNet, [{
		key: 'discover',
		value: function discover(arr) {
			if (arr !== undefined) {
				if (arr instanceof Array) {
					this._discover = this._discover.concat(arr);
				} else {
					this._discover.push(arr);
				}

				return this;
			}

			return this._discover;
		}
	}, {
		key: 'advertise',
		value: function advertise(data, callback) {
			var self = this,
			    packet,
			    doAdvert;

			doAdvert = function doAdvert() {
				packet = self.encodePacket(data);

				if (!self.checkForPeer(packet)) {
					self.peer.insert(packet);
				}

				self._advertise(packet, callback);
			};

			if (self._started === true) {
				doAdvert();
			} else {
				self.on('started', function () {
					doAdvert();
				});
			}
		}
	}, {
		key: 'encodePacket',
		value: function encodePacket(data) {
			var packet = {
				"name": data._id,
				"data": data,
				"port": this._port,
				"endPoints": this._routes
			};

			return packet;
		}
	}, {
		key: 'decodePacket',
		value: function decodePacket(packet) {
			return packet.data;
		}
	}, {
		key: '_advertise',
		value: function _advertise(packet, callback) {
			var self = this;

			self.__advertise = function () {
				//self.log('Advertising existence...');
				self._zeroConfig.put(packet);
			};

			self.__advertise();

			if (callback) {
				callback(false);
			}
		}
	}, {
		key: 'start',
		value: function start(host, port, callback) {
			var self = this;

			if (!host) {
				// No host specified, use all available IPs
				host = '0.0.0.0';
			}

			if (port === undefined) {
				// Find the next available port
				port = 0;
			}

			_get(Object.getPrototypeOf(AutoNet.prototype), 'start', this).call(this, host, port, function (err, serverAddress) {
				if (!err) {
					self._port = serverAddress.port;
					self._started = true;

					self._zeroConfig.on('up', function (name, packet) {
						//self.log('Found autonet peer:', packet);

						if (!self.checkForPeer(packet)) {
							self.emit('peerFound', self.decodePacket(packet));
							self.addPeer(packet);
						}

						// Check if this peer is in our discovery query array
						if (self.peer._match(self.decodePacket(packet), { $or: self._discover }) === true) {
							//self.log('Accepting autonet peer:', packet);
							self.addClient(packet);
						}
					});

					self.emit('started');
				}

				callback(err, serverAddress);
			});
		}
	}, {
		key: 'checkForPeer',
		value: function checkForPeer(peer) {
			//console.log('Peer found:', !!this.peer.count(peer));
			return !!this.peer.count({ name: peer.name });
		}
	}, {
		key: 'addPeer',
		value: function addPeer(peer) {
			if (!this.checkForPeer(peer)) {
				this.peer.insert(peer);
				this.emit('peerAdded', this.decodePacket(peer));

				if (this.__advertise) {
					// Advertise ourselves since this peer is new
					this.__advertise();
				}
			}
		}
	}, {
		key: 'removePeer',
		value: function removePeer(peer) {
			this.peer.remove(peer);
			this.emit('peerRemoved', peer);
		}
	}, {
		key: 'checkForClient',
		value: function checkForClient(peer) {
			return !!this.client.count({ name: peer.name });
		}
	}, {
		key: 'addClient',
		value: function addClient(peer) {
			var exists = this.checkForClient(peer);

			if (!exists) {
				this.client.insert(peer);
				this.emit('clientAdded', this.decodePacket(peer));
			}
		}
	}, {
		key: 'removeClient',
		value: function removeClient(peer) {
			this.client.remove(peer);
			this.emit('clientRemoved', this.decodePacket(peer));
		}
	}, {
		key: 'broadcast',
		value: function broadcast(method, path, data, finished) {
			var self = this,
			    peerArr,
			    requestQueue = [],
			    generateRequest,
			    i;

			peerArr = this.client.find();

			generateRequest = function generateRequest(peer, data) {
				requestQueue.push(function (cb) {
					self.sendTo(peer, method, path, data, cb);
				});
			};

			for (i = 0; i < peerArr.length; i++) {
				generateRequest(peerArr[i], data);
			}

			if (requestQueue.length) {
				_async2.default.parallel(requestQueue, finished);
			}
		}
	}, {
		key: 'sendTo',
		value: function sendTo(peer, method, path, data, finished) {
			(0, _request2.default)({
				url: 'http://' + peer.address + path,
				method: method,
				json: data
			}, finished);
		}
	}]);

	return AutoNet;
}(_Server3.default);

exports.default = AutoNet;