(function() {
var
i = 0,
server, // http or https server
socket_server, // sock.js server
ports, secure,
sockjs_opts, ssl_opts;
ports = commander.ports.split( "," );
sockjs_opts = {
sockjs_url : "http://cdn.sockjs.org/sockjs-0.3.min.js"
};
// Create non SSL servers
for ( i = 0; i < ports.length; i += 1 ) {
console.log( ( "Server binding to port " + ports[ i ] ).green );
if ( process.getuid() !== 0 && ports[ i ] < 1024 ) {
console.log( ( "Must run server as root for ports below 1024." ).red );
process.exit( 1 );
}
server = http.createServer( web );
server.listen( ports[ i ] );
socket_server = sockjs.createServer( sockjs_opts );
socket_server.installHandlers( server, { prefix : "/sockjs" } );
servers.push( socket_server );
}
// Create SSL servers
if ( useSSL ) {
ssl_opts = {
key : fs.readFileSync( "ssl.key" ),
cert : fs.readFileSync( "ssl.crt" )
};
secure = commander.secure.split( "," );
for ( i = 0; i < secure.length; i += 1 ) {
console.log( ( "SSL Server binding to port " + secure[ i ] ).green );
if ( process.getuid() !== 0 && secure[ i ] < 1024 ) {
console.log( ( "Must run server as root for ports below 1024." ).red );
process.exit( 1 );
}
server = https.createServer( ssl_opts, web );
server.listen( secure[ i ] );
socket_server = sockjs.createServer( sockjs_opts );
socket_server.installHandlers( server, { prefix : "/sockjs" } );
servers.push( socket_server );
}
}
})();
/**
* Attach a SockJS (https://github.com/sockjs) server to the server instance.
*/
function attachSockJsToHttpServer(httpServer, prefix, callback) {
var sockjs = require('sockjs');
var sockjsServer = sockjs.createServer();
var config = {prefix: prefix};
sockjsServer.installHandlers(httpServer, config);
callback(sockjsServer);
}
exports.run = function(server,logInterval,hertz,burst) {
var sockjs = require('sockjs');
var sjs = sockjs.createServer(/*{
heartbeat_delay: 25000
disconnect_delay: 9000
}*/);
sjs.on('connection', function(conn) {
conn.write(logInterval);
conn.write(hertz);
var generator = new Generator(function(ts,count) {
//says it implements the Stream interface but does not tell if it ever returns false and/or what to do in such case.
conn.write(ts+"|"+count);
},logInterval,hertz,burst);
conn.on('close', function() {
generator.stop();
});
});
sjs.installHandlers(server, {prefix:'/sockjs'});
};
constructor(options = {}) {
super()
this.options = options
this.options.hostname = this.options.hostname || '0.0.0.0'
if (!this.options.port) throw new Error('port is required!')
this.logger = new KiteLogger({
name: options.name,
level: options.logLevel,
})
const sockjsOptions = {
log: (level, message) => {
if (this.logger[level]) {
this.logger[level](message)
}
},
}
this.sockjs = SockJS.createServer(sockjsOptions)
this.server = http.createServer()
this.sockjs.on('connection', connection => {
this.logger.debug('a new connection', connection)
this.emit('connection', new Session(connection))
})
this.sockjs.installHandlers(this.server, { prefix: options.prefix || '' })
this.logger.debug('starting to listen on server', options)
this.server.listen(options.port, options.hostname)
}
PulsarWebSocket.prototype.installHandlers = function(server) {
var self = this;
this.pulsar.on('create', function(task) {
self.broadcast(JSON.stringify({
'event': 'task.create',
'task': task.getData()
}));
task.on('change', function() {
self.broadcast(JSON.stringify({
'event': 'task.change',
'task': task.getData()
}));
});
});
var sockjsServer = sockjs.createServer();
sockjsServer.on('connection', function(conn) {
self.connections[conn.id] = conn;
conn.on('close', function() {
delete self.connections[conn.id];
});
});
sockjsServer.installHandlers(server, {prefix: '/websocket'});
};
this.start = function ()
{
try
{
var express = require('express');
var http = require('http');
var sockjs = require('sockjs');
var sock = sockjs.createServer();
// reinitialize
reinitialize ();
// Upon connection established from a client socket
sock.on('connection', function (conn)
{
clientConnection (conn);
clientClosing (conn);
receivingDataFromClient (conn);
});// socket.on("connection"
// Standard code to starts the server and listen for connection
startServerAndListenForConnection(express,http,sock);
}
catch (e)
{
console.log("Cannot listen to " + port);
console.log("Error: " + e);
}
}
module.exports.start = function(port) {
var redis_client = redis.createClient();
var socket_server = sockjs.createServer();
var server = require('http').createServer();
socket_server.installHandlers(server, {
prefix: '/socket'
});
server.listen(port);
var sockets = {};
socket_server.on('connection', function (conn) {
sockets[conn.id] = conn;
conn.on('close', function () {
delete sockets[conn.id];
});
});
redis_client.on("message", function (channel, message) {
var conn, connectionId;
for (connectionId in sockets) {
conn = sockets[connectionId];
conn.write(message);
}
});
redis_client.subscribe("websocket:push");
};
var Server = function (config) {
this.config = config;
this.bitcoind = new Bitcoind(config.bitcoind);
this.db = new RedisDB();
this.express = express();
/*this.express.engine('.html', require('ejs').__express);
this.express.set('views',__dirname+'/../../public/templates');
this.express.set('view engine', 'html');
this.express.set('view options', { layout: true, root: __dirname + '/../../public/templates' } );
this.express.get('/page1', function(req, res){
res.render('main', { name: "Sasai Lalka"});
});*/
// Set up the Express server.
this.express.use(express.json());
this.express.use(express.urlencoded());
this.express.use(express.static('public'));
this.express.use(function(err, req, res, next){
console.error(err.stack);
res.send({error: true});
});
// Set up our websocket.
this.websocket = sockjs.createServer({log: function(severity, message) {}});
// Export public module things.
this.exportProperties();
};
Server.prototype.listen = function() {
this.listeningApp.listen.apply(this.listeningApp, arguments);
var sockServer = sockjs.createServer({
// Limit useless logs
log: function(severity, line) {
if (severity === "error") {
console.log(line);
}
}
});
sockServer.on("connection", function(conn) {
this.sockets.push(conn);
// Remove the connection when it's closed
conn.on("close", function() {
var connIndex = this.sockets.indexOf(conn);
if (connIndex >= 0) {
this.sockets.splice(connIndex, 1);
}
}.bind(this));
if(this.hot) this.sockWrite([conn], "hot");
if(!this._stats) return;
this._sendStats([conn], this._stats.toJson(), true);
}.bind(this));
sockServer.installHandlers(this.listeningApp, {
prefix: '/sockjs-node'
});
}
var UpdateServer = module.exports = function (sear, fileWatcher, server, options) {
this.sear = sear;
this.options = options;
this.server = server;
this.fileWatcher = fileWatcher;
fileWatcher.on('update', _.bind(this._fileUpdated, this));
if (this.sear.options.react_update) {
this.reactUpdate = _.template(
fs.readFileSync(
require.resolve('./includes/reactupdater.js')
)
);
}
this.connections = [];
this.sockServer = sockjs.createServer(options.sockjs_opts);
this.sockServer.installHandlers(server, {prefix: '/sear_sock'});
this.sockServer.on('connection', _.bind(function(conn) {
this.connections.push(conn);
conn.on('close', _.bind(function () {
this.connections = _.without(this.connections, conn);
}, this));
}, this));
};
Socket.prototype.start = function() {
log.sys('Start SocketServer on port ' + this.port);
sockjsServer = sockjs.createServer({
log: function() {
}
});
sockjsServer.on('connection', function(conn) {
// console.log('New connection', conn);
conn.on('data', function(message) {
log.dev('Recive socket message:', message);
message = JSON.parse(message);
this.__emit(message.eventName, message.data);
}.bind(this));
conn.on('close', function() {
log.dev('Close socket connection');
for (var i = 0, len = this.connections.length; i < len; i++) {
if (this.connections[i] === conn) {
this.connections.splice(i, 1);
break;
}
}
}.bind(this));
}.bind(this));
var server = http.createServer();
sockjsServer.installHandlers(server, {prefix:'/cb'});
server.listen(this.port, this.host);
};
function Browser(verbose) {
this.cconsole = verbose ? colorize.console : {log:function(){}};
this.connections = [];
this.browser_connection = sockjs.createServer();
this.browser_connection.on('connection', this.newConnection.bind(this));
return this;
}
const socket = (server) => {
//socket.io
// let socketServer = socketIO.listen(server);
//
// let mainRoom = 'skiscool_room';
//
// // Initiate socket to handle all connection
// socketServer.sockets.on('connection', function (socket) {
// let socketID = socket.id;
// socket.join(mainRoom);
//
// // Listen for register action
// console.info("connected", socketID);
//
// socket.on('registerDevice', function (data) {
// //check user is logged in.
// checkAuth(data.token, true)
// .then((user) => {
// registerDevice(data, socket);
// });
// });
//
// // Listen for disconnect event
// socket.on('disconnect', function () {
// // Update device online status
// console.info("disconnected");
//
// //remove disconnected socket from online, admin sockets array;
// removeObject(onlineSockets, socketID, "socketId");
// removeObject(adminSockets, socketID, "socketId");
// });
// });
//sock js
let sockjs_opts = {sockjs_url: "http://cdn.jsdelivr.net/sockjs/1.0.1/sockjs.min.js"};
let deviceEcho = sockjs.createServer(sockjs_opts);
deviceEcho.on('connection', (conn) => {
let socketID = conn.id;
console.info('new sock js connection: ', socketID);
conn.on('data', (strMessage) => {
//check user is logged in.
let message = JSON.parse(strMessage);
if (message.method == 'registerDevice') {
checkAuth(message.data.token, true)
.then((user) => {
registerDevice(message.data, conn);
});
}
});
conn.on('close', () => {
console.info("disconnected");
removeObject(onlineSockets, socketID, "socketId");
removeObject(adminSockets, socketID, "socketId");
});
});
deviceEcho.installHandlers(server, {prefix:'/device'});
}
DiggerServe.prototype.ensure_sockets = function(){
if(this.sockets){
return this.sockets;
}
this.sockets = sockjs.createServer();
this.sockets.on('connection', this.socket_connector());
this.sockets.installHandlers(this.server, {prefix:'/digger/sockets'});
return this.sockets;
}
function start(route, handle) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
// Don't bother for favicon.ico
if (pathname === '/favicon.ico') {
return;
}
//console.log("Request for " + pathname + " received.");
route(handle, pathname, response, request);
}
var echo = sockjs.createServer();
echo.on('connection',function(conn) {
conn.on('data', function(message) {
conn.write(message);
console.log("ws echo received '"+message+"'");
});
conn.on('close',function() {});
});
var server = http.createServer(onRequest);
echo.installHandlers(server,{prefix:'/echo'});
require('./servlets/incremental-search-servlet').install(server);
require('./servlets/incremental-file-search-servlet').install(server);
server.listen(7261, "127.0.0.1" /* only accepting connections from localhost */);
console.log("Server has started.");
// https://github.com/Worlize/WebSocket-Node
// var wsServer = new WebSocketServer({httpServer: server,autoAcceptConnections: false });
// function originIsAllowed(origin) {
// // TODO check it is localhost
// return true;
// }
// wsServer.on('request',function(request) {
// if (!originIsAllowed(request.origin)) {
// request.reject();
// console.log((new Date())+' Connection from origin '+request.origin+' rejected.');
// return;
// }
// var connection = request.accept('echo-protocol', request.origin);
// console.log((new Date())+' connection accepted.');
// connection.on('message',function(message) {
// if (message.type==='utf8') {
// console.log('received message: '+message.utf8Data);
// connection.sendUTF(message.utf8Data);
// } else if (message.type==='binary') {
// console.log('received binary message: '+message.binaryData.length+' bytes');
// connection.sendBytes(message.utf8Data);
// }
// });
// connection.on('close',function(rc,description) {
// console.log((new Date())+' peer '+connection.remoteAddress+' disconnected');
// });
// });
}
/**
* install the multiplexing websocket onto an app server.
*/
function install(app) {
//This method will be called by 'client' servlets that depend on the multiplexer.
//Ensure that we do not install ourselves more than once.
if (!multiplexer) {
var service = sockjs.createServer();
multiplexer = new ws_multiplex.MultiplexServer(service);
service.installHandlers(app, {prefix: '/websockets'});
}
}
Now.prototype.initialize = function (server, options) {
// Merge options
if (typeof options === 'object') {
nowUtil.extend(this.options, options);
}
this.Group = require('./group').initialize(this);
this.User = require('./user').initialize(this);
this.Handlers = require('./handlers').initialize(this);
this.Support = require('./support').initialize(this);
var self = this;
fileServer.wrapServer(server, this.options);
this.server = sockjs.createServer();
this.server.installHandlers(server, {prefix: this.options.sockjs.uri});
// Need this to be separate from clientsMap.
this.server.on('connection', function (conn) {
var user = new self.User(conn);
conn.id = Object.keys(self.users).length; // TODO: is this slow?
conn.user = self.users[conn.id] = user;
conn.send = function(obj) {
conn.write(JSON.stringify(obj));
}
self.getGroup('everyone').addUser(conn.id);
conn.send({type: 'rd'});
});
var everyone = this.getGroup('everyone');
everyone.isSuperGroup = true;
// Shim for backwards compatibility.
this.on('connect', function () {
var user = nowUtil.clone(this);
user._events = everyone._events;
everyone.emit.apply(user, ['connect']);
});
this.on('disconnect', function () {
var user = nowUtil.clone(this);
user._events = everyone._events;
everyone.emit.apply(user, ['disconnect']);
});
// Detect connect and add session middleware as necessary
// Use `in` so we look up the prototype chain
if('use' in server && 'stack' in server && 'route' in server) {
server.use(function(req, res, next) {
self.sessions[req.sessionID] = req.session;
next();
});
}
return everyone;
};
var SocketJsServer = function(expressServer){
var sockjs_echo = sockjs.createServer();
sockjs_echo.on('connection', function(conn) {
conn.on('data', function(message) {
conn.write(message);
});
});
sockjs_echo.installHandlers(expressServer, {prefix:'/echo'});
}
exports.listen = function(server, options) {
var log = options.log ? options.log : false;
// sockjs version
var sockOptions = options.sockjs || {};
var sockets = sockjs.createServer(sockOptions);
sockets.installHandlers(server, { prefix: '/meem' });
return new Whims(sockets, options.mqtt);
};
exports = module.exports = function (opts, cb) {
if (typeof opts === 'function') {
cb = opts;
opts = {};
}
var server = sockjs.createServer();
var handler = function (stream) {
var _didTimeout = stream._session.didTimeout
var _didClose = stream._session.didClose
stream._session.didTimeout = function () {
cleanup()
_didTimeout.apply(this, arguments)
}
stream._session.didClose = function () {
cleanup()
_didClose.apply(this, arguments)
}
cb(stream)
function cleanup() {
if (stream.destroy) {
stream.destroy()
} else {
stream.emit("close")
}
}
}
if (typeof cb === 'function') {
server.on('connection', handler);
}
server.install = function (httpServer, hopts) {
if (hopts && hopts.listen && !httpServer.listen) {
httpServer = arguments[1];
hopts = arguments[0];
}
if (typeof hopts === 'string') {
hopts = { prefix : hopts };
}
if (!hopts) hopts = {};
if (hopts.log === undefined) {
// spamming stdout by default is VERY infuriating,
// emit an event instead
hopts.log = function (severity, line) {
server.emit('log', severity, line);
};
}
server.installHandlers(httpServer, hopts);
return server;
};
return server;
};
var Hub = module.exports = function Hub(options) {
EventEmitter2.call(this, {
wildcard: true
});
if (!options) {
options = {};
}
if (!options.loglevel) {
options.loglevel = "silent";
}
if (!options.webdriver) {
options.webdriver = {
host: "localhost"
};
}
if (process.env.YETI_HUB_DEBUG) {
options.loglevel = "debug";
}
this._setupLogEvents(options.loglevel);
// Setup the HTTP server, routing, and its Socket.io.
this.router = this._createRouter();
this.server = this._createServer(this.router);
this.tower = sockjs.createServer();
this.blizzard = this._createBlizzard(this.server);
this.tower.installHandlers(this.server, {
prefix: "/tower",
log: this._onTowerLog.bind(this)
});
this.sessions = new EventYoshi();
this.echoecho = new EchoEcho({
all: true
});
// Setup IO events.
this.tower.on("connection", this._onTowerConnection.bind(this));
this.allAgents = new AllAgents(this);
this.allBatches = new AllBatches(this);
this.allAgents.pipeLog(this);
this._setupEvents();
this.mountpoint = "/";
this.webdriver = options.webdriver;
};
function ResourceIO (){
var self = this;
EventEmitter.call(self);
self.connections = {};
self.websocketServer = sockjs.createServer();
self.websocketServer.on('connection', function(connection){
self.connections[connection.address] = connection;
connection.on('close', function(){
delete self.connections[connection.address];
});
});
}
function socket(projectPath, onConnectionCallback) {
var server = sock.createServer();
var connections = {};
function broadcast(event, data) {
for (var id in connections) {
connections[id].send(event, data);
}
}
server.on('connection', function (conn) {
connections[conn.id] = conn;
console.log(chalk.magenta('A client has connected.'));
conn.send = function(event, data) {
conn.write(JSON.stringify({
type: event,
data: data
}));
};
if (onConnectionCallback) {
onConnectionCallback(conn);
}
conn.on('close', function () {
delete connections[conn.id];
console.log(chalk.magenta('A client has disconnected.'));
});
conn.on('data', function (message) {
var event = JSON.parse(message);
switch (event.type) {
case 'set':
var data = {};
data[event.data.field] = event.data.value;
layers.update(projectPath, event.data.id, data, function (err) {
if (err) {
console.log(err);
}
});
break;
case 'generate':
generate.generate(projectPath, event.data.type, event.data.name);
break;
}
});
});
return {server: server, broadcast: broadcast};
}
function createServer(opts) {
opts = defaults(opts, {
url: '/skates',
middleware: connect.createServer(),
entry: './client.js',
cache: true
})
var sox = sockjs.createServer()
var app = opts.middleware
var _listen = app.listen
//TODO... automatically insert browserify and sock.
app.listen = function () {
var args = [].slice.call(arguments)
sox.installHandlers(_listen.apply(app, args), {
prefix: opts.prefix || opts.url
})
return app
}
var browser = browserify(opts)
browser.addEntry(opts.entry)
//this adds some global information from the server.
//it will be the same for all clients that have loaded data
//from this server
var clientSettings = defaults(opts.client, {
url: opts.url,
timestamp: app.timestamp = Date.now(), //this is the version of the code you are on
})
browser.prepend([
'window.SKATES = ' + JSON.stringify(clientSettings),
'window.SKATES.create = ' + function () {
return new SockJS(SKATES.prefix || SKATES.url)
}.toString() + ';'
].join('\n'))
browser.prepend(fs.readFileSync(__dirname + '/src/sockjs-0.3.min.js'))
/*
REMEMBER to make sure that the javascript gets served.
maybe inject it into the page?
or is that too overbearing?
*/
app.use(browser)
sox.on('connection', function () {
var args = [].slice.call(arguments)
args[0] = toEmitter(args[0])
args.unshift('connection')
app.emit.apply(app, args)
})
return app
}
Application.prototype.run = function() {
var server = http.createServer(this.app);
var echo = sockjs.createServer();
echo.on('connection', function(connection) {
var tailStream = new TailStream(connection);
tailStream.run();
});
echo.installHandlers(server, {prefix: '/log-viewer'});
// Start listening for HTTP requests
var port = process.env.SERVER_PORT;
server.listen(port);
log.info('Listening on port ' + port);
};
listen: function(port) {
var server, xssnake;
server = http.createServer();
server.listen(port, '0.0.0.0');
xssnake = sockjs.createServer();
xssnake.on('connection', function(connection) {
new xss.Client(this.pubsub, connection);
}.bind(this));
xssnake.installHandlers(server, {prefix: '/xssnake', log: xss.util.noop});
this._server = server;
}
Mechanics.prototype.unitInit = function (units) {
this.units = units;
var settings = units.require('core.settings');
var coreSettings = settings.core;
this.handler = units.require('core.handler');
if (coreSettings.socket && !coreSettings.socket.disabled) {
var web = units.requireInited('core.mechanics.web');
var logging = units.require('core.logging');
this.server = sockjs.createServer();
this.configure(web, logging, this.getSocketPrefix(coreSettings));
}
};
function createWS(httpServer) {
var ws = sockjs.createServer();
ws.installHandlers(httpServer, {
prefix: '/ws'
});
ws.on('connection', function (conn) {
setInterval(function () {
conn.write(Math.random());
}, 1000);
})
return ws;
}
const returnValue = this.listeningApp.listen(port, hostname, (err) => {
const sockServer = sockjs.createServer({
// Use provided up-to-date sockjs-client
sockjs_url: '/__webpack_dev_server__/sockjs.bundle.js',
// Limit useless logs
log(severity, line) {
if (severity === 'error') {
log(line);
}
}
});
sockServer.on('connection', (conn) => {
if (!conn) return;
if (!this.checkHost(conn.headers)) {
this.sockWrite([conn], 'error', 'Invalid Host header');
conn.close();
return;
}
this.sockets.push(conn);
conn.on('close', () => {
const connIndex = this.sockets.indexOf(conn);
if (connIndex >= 0) {
this.sockets.splice(connIndex, 1);
}
});
if (this.clientLogLevel) { this.sockWrite([conn], 'log-level', this.clientLogLevel); }
if (this.progress) { this.sockWrite([conn], 'progress', this.progress); }
if (this.clientOverlay) { this.sockWrite([conn], 'overlay', this.clientOverlay); }
if (this.hot) this.sockWrite([conn], 'hot');
if (!this._stats) return;
this._sendStats([conn], this._stats.toJson(clientStats), true);
});
sockServer.installHandlers(this.listeningApp, {
prefix: '/sockjs-node'
});
if (fn) {
fn.call(this.listeningApp, err);
}
});
var TestServer = function (config, logger) {
this.logger = new Logger("TestServer", logger);
this.config = config;
var app = connect();
app.use(compression());
app.use(index);
app.use(favicon(path.join(__dirname, "client", "favicon.ico")));
// Template pages (before the static folder)
app.use('/__attester__', template.bind({
data: this,
page: "/index.html",
path: path.join(__dirname, "client", "index.html")
}));
app.use('/__attester__', template.bind({
data: this,
page: "/status.html",
path: path.join(__dirname, "client", "status.html")
}));
app.use('/__attester__', template.bind({
data: this,
page: "/slave.html",
path: path.join(__dirname, "client", "slave.html")
}));
app.use('/__attester__', serveStatic(__dirname + '/client'));
app.use('/__attester__/json3', serveStatic(path.dirname(require.resolve("json3/lib/json3.js"))));
app.use('/__attester__/sockjs', serveStatic(path.dirname(require.resolve("sockjs-client/dist/sockjs.js"))));
app.use('/__attester__/coverage/display', globalCoverage.bind(this));
app.use('/__attester__/coverage/data', routeCoverage.bind(this));
app.use('/__attester__/results-ui', attesterResultsUI({
toJSON: attesterResultsUIConfig.bind(this)
}));
app.use(routeToCampaign.bind(this));
app.use('/__attester__', jsonApi.bind(this));
this.app = app;
this.server = http.createServer(app);
this.sockjs = sockjs.createServer();
this.sockjs.installHandlers(this.server, {
prefix: '/sockjs',
sockjs_url: '/__attester__/sockjs/sockjs.js',
disconnect_delay: 60000,
log: createSockJSLogger(this.logger)
});
this.sockjs.on('connection', socketConnection.bind(this));
this.slaves = []; // array of all slaves
this.availableSlaves = []; // array of available slaves
this.campaigns = []; // array of campaigns
this.frozen = config.frozen; // if frozen, then don't assign tasks
};