github/peerjs-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Migrate to express from restify

Browse Source 
PeerServer is now instance of express application - this allows to combine it with other express applications.
Listen is deferred - because it now method from express (you can call it later and supply callback for start event).
Constructor now not using `new` (because we mixing in methods to express app)

Closes #36
This commit is contained in:
Vsevolod Strukchinsky 2014-04-03 21:23:30 +06:00 committed by lmb
parent 5c9d1a0416
commit 9e0d861715
6 changed files with 609 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -46,13 +46,14 @@ Using HTTPS: Simply pass in PEM-encoded certificate and key.
var fs = require('fs');
var PeerServer = require('peer').PeerServer;
var server = new PeerServer({
port: 9000,
var server = PeerServer({
ssl: {
key: fs.readFileSync('/path/to/your/ssl/key/here.key'),
certificate: fs.readFileSync('/path/to/your/ssl/certificate/here.crt')
}
});
server.listen(9000);
```
### Events

3
bin/peerjs
View File

@ -4,7 +4,7 @@ var path = require('path')
, pkg = require('../package.json')
, fs = require('fs')
, version = pkg.version
, PeerServer = require('../lib/server').PeerServer
, PeerServer = require('../lib')()
, opts = require('optimist')
.usage('Usage: $0')
.options({
@ -76,6 +76,7 @@ process.on('uncaughtException', function(e) {
});
var server = new PeerServer(opts);
server.listen(opts.port);
console.log(
'Started PeerServer, port: ' + opts.port + ', path: ' + (opts.path || '/') + (" (v. %s)"), version
);

62
lib/index.js Normal file
View File

@ -0,0 +1,62 @@
var express = require('express');
var mixin = require('utils-merge');
var proto = require('./server');
exports = module.exports = {
PeerServer: createPeerServer
};
function createPeerServer(options) {
var app = express();
mixin(app, proto);
app.options = {
debug: false,
timeout: 5000,
key: 'peerjs',
ip_limit: 5000,
concurrent_limit: 5000,
ssl: {},
path: '/',
allow_discovery: false
};
mixin(app.options, options);
// Print warning if only one of the two is given.
if (Object.keys(app.options.ssl).length === 1) {
util.prettyError('Warning: PeerServer will not run on an HTTPS server' +
' because either the key or the certificate has not been provided.');
}
app.options.ssl.name = 'PeerServer';
if (app.options.path[0] !== '/') {
app.options.path = '/' + app.options.path;
}
if (app.options.path[app.options.path.length - 1] !== '/') {
app.options.path += '/';
}
// Connected clients
app._clients = {};
// Messages waiting for another peer.
app._outstanding = {};
// Initailize WebSocket server handlers.
app._initializeWSS();
// Initialize HTTP routes. This is only used for the first few milliseconds
// before a socket is opened for a Peer.
app._initializeHTTP();
// Mark concurrent users per ip
app._ips = {};
app._setCleanupIntervals();
return app;
}

143
lib/server.js
View File

@ -1,72 +1,16 @@
var util = require('./util');
var restify = require('restify');
var EventEmitter = require('events').EventEmitter;
var express = require('express');
var WebSocketServer = require('ws').Server;
var url = require('url');
function PeerServer(options) {
if (!(this instanceof PeerServer)) return new PeerServer(options);
EventEmitter.call(this);
this._options = util.extend({
port: 80,
debug: false,
timeout: 5000,
key: 'peerjs',
ip_limit: 5000,
concurrent_limit: 5000,
ssl: {},
path: '/',
allow_discovery: false
}, options);
util.debug = this._options.debug;
// Print warning if only one of the two is given.
if (Object.keys(this._options.ssl).length === 1) {
util.prettyError('Warning: PeerServer will not run on an HTTPS server'
+ ' because either the key or the certificate has not been provided.');
}
this._options.ssl['name'] = 'PeerServer';
if (this._options.path[0] !== '/') {
this._options.path = '/' + this._options.path;
}
if (this._options.path[this._options.path.length - 1] !== '/') {
this._options.path += '/';
}
this._app = restify.createServer(this._options.ssl);
// Connected clients
this._clients = {};
// Messages waiting for another peer.
this._outstanding = {};
// Initailize WebSocket server handlers.
this._initializeWSS();
// Initialize HTTP routes. This is only used for the first few milliseconds
// before a socket is opened for a Peer.
this._initializeHTTP();
// Mark concurrent users per ip
this._ips = {};
this._setCleanupIntervals();
}
util.inherits(PeerServer, EventEmitter);
var app = exports = module.exports = {};
/** Initialize WebSocket server. */
PeerServer.prototype._initializeWSS = function() {
app._initializeWSS = function() {
var self = this;
// Create WebSocket server as well.
this._wss = new WebSocketServer({ path: this._options.path + 'peerjs', server: this._app});
this._wss = new WebSocketServer({ path: this.options.path + 'peerjs', server: this});
this._wss.on('connection', function(socket) {
var query = url.parse(socket.upgradeReq.url, true).query;
@ -100,7 +44,7 @@ PeerServer.prototype._initializeWSS = function() {
});
};
PeerServer.prototype._configureWS = function(socket, key, id, token) {
app._configureWS = function(socket, key, id, token) {
var self = this;
var client = this._clients[key][id];
@ -154,12 +98,12 @@ PeerServer.prototype._configureWS = function(socket, key, id, token) {
this.emit('connection', id);
};
PeerServer.prototype._checkAllowsDiscovery = function(key, cb) {
cb(this._options.allow_discovery);
app._checkAllowsDiscovery = function(key, cb) {
cb(this.options.allow_discovery);
};
PeerServer.prototype._checkKey = function(key, ip, cb) {
if (key == this._options.key) {
app._checkKey = function(key, ip, cb) {
if (key == this.options.key) {
if (!this._clients[key]) {
this._clients[key] = {};
}
@ -170,11 +114,11 @@ PeerServer.prototype._checkKey = function(key, ip, cb) {
this._ips[ip] = 0;
}
// Check concurrent limit
if (Object.keys(this._clients[key]).length >= this._options.concurrent_limit) {
if (Object.keys(this._clients[key]).length >= this.options.concurrent_limit) {
cb('Server has reached its concurrent user limit');
return;
}
if (this._ips[ip] >= this._options.ip_limit) {
if (this._ips[ip] >= this.options.ip_limit) {
cb(ip + ' has reached its concurrent user limit');
return;
}
@ -185,42 +129,21 @@ PeerServer.prototype._checkKey = function(key, ip, cb) {
};
/** Initialize HTTP server routes. */
PeerServer.prototype._initializeHTTP = function() {
app._initializeHTTP = function() {
var self = this;
this._app.use(restify.bodyParser({ mapParams: false }));
this._app.use(restify.queryParser());
this._app.use(util.allowCrossDomain);
/** Hack from https://github.com/mcavage/node-restify/issues/284, until we switch to express */
function unknownMethodHandler(req, res) {
if (req.method.toLowerCase() === 'options') {
var allowHeaders = ['Accept', 'Accept-Version', 'Content-Type', 'Api-Version'];
if (res.methods.indexOf('OPTIONS') === -1) res.methods.push('OPTIONS');
res.header('Access-Control-Allow-Credentials', true);
res.header('Access-Control-Allow-Headers', allowHeaders.join(', '));
res.header('Access-Control-Allow-Methods', res.methods.join(', '));
res.header('Access-Control-Allow-Origin', req.headers.origin);
return res.send(204);
} else {
return res.send(new restify.MethodNotAllowedError());
}
}
this._app.on('MethodNotAllowed', unknownMethodHandler);
this.use(express.bodyParser({ mapParams: false }));
this.use(util.allowCrossDomain);
// Retrieve guaranteed random ID.
this._app.get(this._options.path + ':key/id', function(req, res, next) {
this.get(this.options.path + ':key/id', function(req, res, next) {
res.contentType = 'text/html';
res.send(self._generateClientId(req.params.key));
return next();
});
// Server sets up HTTP streaming when you get post an ID.
this._app.post(this._options.path + ':key/:id/:token/id', function(req, res, next) {
this.post(this.options.path + ':key/:id/:token/id', function(req, res, next) {
var id = req.params.id;
var token = req.params.token;
var key = req.params.key;
@ -243,7 +166,7 @@ PeerServer.prototype._initializeHTTP = function() {
});
// Get a list of all peers for a key, enabled by the `allowDiscovery` flag.
this._app.get(this._options.path + ':key/peers', function(req, res, next) {
this.get(this.options.path + ':key/peers', function(req, res, next) {
var key = req.params.key;
if (self._clients[key]) {
self._checkAllowsDiscovery(key, function(isAllowed) {
@ -293,25 +216,17 @@ PeerServer.prototype._initializeHTTP = function() {
return next();
};
this._app.post(this._options.path + ':key/:id/:token/offer', handle);
this.post(this.options.path + ':key/:id/:token/offer', handle);
this._app.post(this._options.path + ':key/:id/:token/candidate', handle);
this.post(this.options.path + ':key/:id/:token/candidate', handle);
this._app.post(this._options.path + ':key/:id/:token/answer', handle);
this._app.post(this._options.path + ':key/:id/:token/leave', handle);
// Listen on user-specified port and IP address.
if (this._options.ip) {
this._app.listen(this._options.port, this._options.ip);
} else {
this._app.listen(this._options.port);
}
this.post(this.options.path + ':key/:id/:token/answer', handle);
this.post(this.options.path + ':key/:id/:token/leave', handle);
};
/** Saves a streaming response and takes care of timeouts and headers. */
PeerServer.prototype._startStreaming = function(res, key, id, token, open) {
app._startStreaming = function(res, key, id, token, open) {
var self = this;
res.writeHead(200, {'Content-Type': 'application/octet-stream'});
@ -348,7 +263,7 @@ PeerServer.prototype._startStreaming = function(res, key, id, token, open) {
}
};
PeerServer.prototype._pruneOutstanding = function() {
app._pruneOutstanding = function() {
var keys = Object.keys(this._outstanding);
for (var k = 0, kk = keys.length; k < kk; k += 1) {
var key = keys[k];
@ -369,7 +284,7 @@ PeerServer.prototype._pruneOutstanding = function() {
};
/** Cleanup */
PeerServer.prototype._setCleanupIntervals = function() {
app._setCleanupIntervals = function() {
var self = this;
// Clean up ips every 10 minutes
@ -390,7 +305,7 @@ PeerServer.prototype._setCleanupIntervals = function() {
};
/** Process outstanding peer offers. */
PeerServer.prototype._processOutstanding = function(key, id) {
app._processOutstanding = function(key, id) {
var offers = this._outstanding[key][id];
if (!offers) {
return;
@ -401,7 +316,7 @@ PeerServer.prototype._processOutstanding = function(key, id) {
delete this._outstanding[key][id];
};
PeerServer.prototype._removePeer = function(key, id) {
app._removePeer = function(key, id) {
if (this._clients[key] && this._clients[key][id]) {
this._ips[this._clients[key][id].ip]--;
delete this._clients[key][id];
@ -410,7 +325,7 @@ PeerServer.prototype._removePeer = function(key, id) {
};
/** Handles passing on a message. */
PeerServer.prototype._handleTransmission = function(key, message) {
app._handleTransmission = function(key, message) {
var type = message.type;
var src = message.src;
var dst = message.dst;
@ -461,7 +376,7 @@ PeerServer.prototype._handleTransmission = function(key, message) {
}
};
PeerServer.prototype._generateClientId = function(key) {
app._generateClientId = function(key) {
var clientId = util.randomId();
if (!this._clients[key]) {
return clientId;
@ -471,5 +386,3 @@ PeerServer.prototype._generateClientId = function(key) {
}
return clientId;
};
exports.PeerServer = PeerServer;

9
package.json
View File

@ -2,7 +2,7 @@
"name": "peer",
"version": "0.2.7",
"description": "PeerJS server component",
"main": "lib/server.js",
"main": "lib/index.js",
"bin": {
"peerjs": "./bin/peerjs"
},
@ -13,9 +13,10 @@
"author": "Michelle Bu, Eric Zhang",
"license": "MIT",
"dependencies": {
"restify": "~2.6.0",
"ws": "~0.4.25",
"optimist": "*"
"express": "~3.5.1",
"optimist": "~0.6.1",
"utils-merge": "~1.0.0",
"ws": "~0.4.25"
},
"devDependencies": {
"expect.js": "*",

37
test/server.js
View File

@ -3,29 +3,6 @@ var expect = require('expect.js');
var sinon = require('sinon');
describe('PeerServer', function() {
describe('constructor', function() {
before(function() {
PeerServer.prototype._initializeWSS = sinon.stub();
PeerServer.prototype._initializeHTTP = sinon.stub();
});
it('should be able to be created without the `new` keyword', function() {
var p = PeerServer();
expect(p.constructor).to.be(PeerServer);
});
it('should default to port 80, key `peerjs`', function() {
var p = new PeerServer();
expect(p._options.key).to.be('peerjs');
expect(p._options.port).to.be(80);
});
it('should accept a custom port', function() {
var p = new PeerServer({ port: 8000 });
expect(p._options.port).to.be(8000);
});
});
describe('#_initializeWSS', function() {
WebSocketServer = sinon.stub();
@ -39,7 +16,7 @@ describe('PeerServer', function() {
var p;
before(function() {
PeerServer.prototype._initializeHTTP = sinon.stub();
p = new PeerServer({ port: 8000 });
p = PeerServer({ port: 8000 });
p._checkKey('peerjs', 'myip', function() {});
});
@ -58,7 +35,7 @@ describe('PeerServer', function() {
});
it('should reject ips that are at their limit', function(done) {
p._options.ip_limit = 0;
p.options.ip_limit = 0;
p._checkKey('peerjs', 'myip', function(response) {
expect(response).to.be('myip has reached its concurrent user limit');
done();
@ -66,7 +43,7 @@ describe('PeerServer', function() {
});
it('should reject when the server is at its limit', function(done) {
p._options.concurrent_limit = 0;
p.options.concurrent_limit = 0;
p._checkKey('peerjs', 'myip', function(response) {
expect(response).to.be('Server has reached its concurrent user limit');
done();
@ -95,7 +72,7 @@ describe('PeerServer', function() {
var p;
before(function() {
PeerServer.prototype._initializeHTTP = sinon.stub();
p = new PeerServer({ port: 8000 });
p = PeerServer({ port: 8000 });
var fake = {ip: '0.0.0.0'};
p._ips[fake.ip] = 1;
@ -117,7 +94,7 @@ describe('PeerServer', function() {
var ID = 'test';
before(function() {
PeerServer.prototype._initializeHTTP = sinon.stub();
p = new PeerServer({ port: 8000 });
p = PeerServer({ port: 8000 });
p._clients[KEY] = {};
});
@ -202,11 +179,11 @@ describe('PeerServer', function() {
var p;
before(function() {
PeerServer.prototype._initializeHTTP = sinon.stub();
p = new PeerServer({ port: 8000 });
p = PeerServer({ port: 8000 });
});
it('should generate a 16-character ID', function() {
expect(p._generateClientId('anykey').length).to.be(16);
expect(p._generateClientId('anykey').length).to.be.within(15, 16);
});
});
});