wsServer.on('request',function(request){
// code to run connection
// for accept clients use echo-protocol
console.log((new Date()) + 'connection from origin '+request.origin+'.');
var connection = request.accept(null, request.origin);
var id = clients.push(connection)-1;
// store connections details
var user = false;
var ucolor = false;
console.log((new Date()) + ' connection accepted');
// listen for incoming message and broadcast
if(history.length>0)
connection.sendUTF(JSON.stringify({type:'history',data:history}));
connection.on('message',function(message){
if(message.type ==='utf8'){
if(user===false){
user = htmlEntities(message.utf8Data);
ucolor= colors.shift();
connection.sendUTF(JSON.stringify({type:'color',data:ucolor}));
console.log((new Date()) + 'User is known as: '+ user +' with '+ ucolor +'color.');
}
else {
console.log((new Date()) + 'received message from '+ user+ ': '+ message.utf8Data);
var Obj = {
time:(new Date()).getTime(),
text:htmlEntities(message.utf8Data),
author:user,
color:ucolor
};
history.push(Obj);
history = history.slice(-100);
var json = JSON.stringify({type:'message',data:Obj});
for(var i=0;i<clients.length;i++)
clients[i].sendUTF(json);
}
}
});
connection.on('close',function(connection){
if(user!==false && ucolor!== false){ clients.splice(id,1);
colors.push(ucolor);
console.log(new Date() + ' Peer '+connection.remoteAddres+ ' disconnected. ');
}
});
});
wsServer.on('request', function(request) {
var client = null, stream = null, connection;
if (!Constants.DEBUG_MODE && request.origin !== Config.origin) {
request.reject();
console.log((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');
return;
}
try {
connection = request.accept('lunasync', request.origin);
} catch (e) {
console.log('Caught error: ' + e);
request.reject();
return;
}
console.log((new Date()) + ' Connection accepted from IP ' + connection.remoteAddress);
connection.once('message', function (message) {
var msg, i, users, nonEmptyStreams, args, results, name, cmd;
// handle unexpected packet types
// we don't use binary frames
if (message.type !== 'utf8') {
connection.sendUTF(JSON.stringify({
type: 'kick',
reason: 'protocol_error'
}));
connection.close();
return;
}
// every frame is a JSON-encoded packet
try {
msg = JSON.parse(message.utf8Data);
} catch (e) {
connection.sendUTF(JSON.stringify({
type: 'kick',
reason: 'protocol_error'
}));
connection.close();
return;
}
// first packet MUST be set_stream
if (msg.type !== 'set_stream') {
connection.close();
return;
}
// check for id
if (!Stream.haveStream(msg.id)) {
connection.sendUTF(JSON.stringify({
type: 'error',
error: 'not_found'
}));
connection.close();
return;
}
// hand over to Client
client = new Client(connection, Stream.get(msg.id), msg.control);
});
});
wsServer.on('connect', function(connection) {
// Check if we should accept users.
if (accept_connections === false) {
connection.write("XIM_TOO_MANY");
connection.close();
return;
}
var m_temp_id = makeid();
if (connections_url.indexOf(m_temp_id) !== -1) {
while(connections_url.indexOf(m_temp_id) !== -1) {
m_temp_id = makeid();
}
}
//console.log("[ DBG ] Generated m_temp_id " + m_temp_id);
connection.socket_id = m_temp_id;
var n_length = connections.push(connection);
connections_url.push(m_temp_id);
connections_id.push(m_temp_id);
connection.array_index = n_length - 1;
connection.photo_data = "";
connection.on('message', function(message) {
if (message.type === "binary") {
// Something weird/fishy going on.
console.log("[ ERR ] Security error, got binary");
connection.close();
return;
}
process(connection, message.utf8Data);
});
connection.on('close', function(reasonCode, description) {
// console.log("[ USR ] Peer " + connection.remoteAddress + " disconnected.");
log_out(connection);
});
});
var getKeys = Object.keys;
socketServer.on('request', function ( req ) {
var entries = getKeys(CONNECTIONS),
id = entries.length;
if ( id === maxConnections ) return;
var conn = req.accept( null, req.origin );
for ( var i = 0; i < id; i++ ) {
conn.send( JSON.stringify({ action: 'ADD', data: { id: i, color: COLORS[i], pos: POSITIONS[i] } }) );
}
conn.send( JSON.stringify({ action: 'REGISTER', data: id }) );
CONNECTIONS[ id ] = conn;
conn.on('error', function(){ console.log('[ERROR]'); });
conn.on('close', function(){ console.log('[CLOSE]'); }); // TODP: remove on leave
conn.on('message', handle );
});
var COMMANDS = {
wsServer.on('request', function(request) {
if (!originIsAllowed(request.origin)) {
request.reject();
log("Connection from " + request.origin + " rejected.");
return;
}
// Accept the request and get a connection.
var connection = request.accept("json", request.origin);
// Add the new connection to our list of connections.
log("Connection accepted from " + connection.remoteAddress + ".");
connectionArray.push(connection);
connection.clientID = nextID;
nextID++;
// Send the new client its token; it send back a "username" message to
// tell us what username they want to use.
var msg = {
type: "id",
id: connection.clientID
};
connection.sendUTF(JSON.stringify(msg));
// Set up a handler for the "message" event received over WebSocket. This
// is a message sent by a client, and may be text to share with other
// users, a private message (text or signaling) for one user, or a command
// to the server.
connection.on('message', function(message) {
if (message.type === 'utf8') {
log("Received Message: " + message.utf8Data);
// Process incoming data.
var sendToClients = true;
msg = JSON.parse(message.utf8Data);
var connect = getConnectionForID(msg.id);
// Take a look at the incoming object and act on it based
// on its type. Unknown message types are passed through,
// since they may be used to implement client-side features.
// Messages with a "target" property are sent only to a user
// by that name.
switch(msg.type) {
// Public, textual message
case "message":
msg.name = connect.username;
msg.text = msg.text.replace(/(<([^>]+)>)/ig,"");
break;
// Username change
case "username":
var nameChanged = false;
var origName = msg.name;
// Ensure the name is unique by appending a number to it
// if it's not; keep trying that until it works.
while (!isUsernameUnique(msg.name)) {
msg.name = origName + appendToMakeUnique;
appendToMakeUnique++;
nameChanged = true;
}
// If the name had to be changed, we send a "rejectusername"
// message back to the user so they know their name has been
// altered by the server.
if (nameChanged) {
var changeMsg = {
id: msg.id,
type: "rejectusername",
name: msg.name
};
connect.sendUTF(JSON.stringify(changeMsg));
}
// Set this connection's final username and send out the
// updated user list to all users. Yeah, we're sending a full
// list instead of just updating. It's horribly inefficient
// but this is a demo. Don't do this in a real app.
connect.username = msg.name;
sendUserListToAll();
sendToClients = false; // We already sent the proper responses
break;
}
// Convert the revised message back to JSON and send it out
// to the specified client or all clients, as appropriate. We
// pass through any messages not specifically handled
// in the select block above. This allows the clients to
// exchange signaling and other control objects unimpeded.
if (sendToClients) {
var msgString = JSON.stringify(msg);
var i;
// If the message specifies a target username, only send the
// message to them. Otherwise, send it to every user.
if (msg.target && msg.target !== undefined && msg.target.length !== 0) {
sendToOneUser(msg.target, msgString);
} else {
for (i=0; i<connectionArray.length; i++) {
connectionArray[i].sendUTF(msgString);
}
}
}
}
});
// Handle the WebSocket "close" event; this means a user has logged off
// or has been disconnected.
connection.on('close', function(reason, description) {
// First, remove the connection from the list of connections.
connectionArray = connectionArray.filter(function(el, idx, ar) {
return el.connected;
});
// Now send the updated user list. Again, please don't do this in a
// real application. Your users won't like you very much.
sendUserListToAll();
// Build and output log output for close information.
var logMessage = "Connection closed: " + connection.remoteAddress + " (" +
reason;
if (description !== null && description.length !== 0) {
logMessage += ": " + description;
}
logMessage += ")";
log(logMessage);
});
});
wsServer.on('request', function(request) {
console.log((new Date()) + ' Connection from origin ' + request.origin + '.');
// accept connection - you should check 'request.origin' to make sure that
// client is connecting from your website
// (http://en.wikipedia.org/wiki/Same_origin_policy)
var connection = request.accept(null, request.origin);
// we need to know client index to remove them on 'close' event
var index = clients.push(connection) - 1;
var userName = false;
var userColor = false;
console.log((new Date()) + ' Connection accepted.');
// send back chat history
if (history.length > 0) {
connection.sendUTF(JSON.stringify( { type: 'history', data: history} ));
}
// user sent some message
connection.on('message', function(message) {
if (message.type === 'utf8') { // accept only text
if (userName === false) { // first message sent by user is their name
// remember user name
userName = htmlEntities(message.utf8Data);
// get random color and send it back to the user
userColor = colors.shift();
connection.sendUTF(JSON.stringify({ type:'color', data: userColor }));
console.log((new Date()) + ' User is known as: ' + userName
+ ' with ' + userColor + ' color.');
} else { // log and broadcast the message
console.log((new Date()) + ' Received Message from '
+ userName + ': ' + message.utf8Data);
// we want to keep history of all sent messages
var obj = {
time: (new Date()).getTime(),
text: htmlEntities(message.utf8Data),
author: userName,
color: userColor
};
history.push(obj);
history = history.slice(-100);
// broadcast message to all connected clients
var json = JSON.stringify({ type:'message', data: obj });
for (var i=0; i < clients.length; i++) {
clients[i].sendUTF(json);
}
}
}
});
// user disconnected
connection.on('close', function(connection) {
if (userName !== false && userColor !== false) {
console.log((new Date()) + " Peer "
+ connection.remoteAddress + " disconnected.");
// remove user from the list of connected clients
clients.splice(index, 1);
// push back user's color to be reused by another user
colors.push(userColor);
}
});
});
wsServer.on('request', function(request) {
numberOfConnections ++;
console.log('Connection from origin ' + request.origin);
var connection = request.accept(null, request.origin);
console.log('Connection address ' + connection.remoteAddress);
console.log('Number of connections ' + numberOfConnections);
connection.on('message', function(message) {
if (message.type === 'utf8') {
// process WebSocket message
console.log('Received Message ' + message.utf8Data);
//parse the message
msg = JSON.parse(message.utf8Data);
var type = msg.type;
var from = msg.from;
var to = msg.to;
var name;
//accept only messages that are authorized, in simple case, we assume that the
//first call is the presence with a name of the caller
if(type !== 'presence' && connection.name === undefined){
console.log('connection not allowed, name not provided');
return;
}
//after presence message, socket connection is 'named', only such connections participate later.
if(type === 'presence'){
name = msg.name;
if(people[name] === undefined && !settings.acceptNewUsers){
console.log('Unknown user not allowed');
return;
}
var status = msg.status;
if(status === 'on'){
connection.name = name;
connectionDict[name] = connection;
console.log('adding '+ name)
people[name] = 'on';
if(settings.sendRoster){
connection.send(JSON.stringify({type: "roster", people: roster.people, rooms: roster.rooms}));
}
} else {
remove(name);
}
} else if(type === 'room'){
if(rooms[to] === undefined)
rooms[to] = [];
console.log('Number of people in the room ' + rooms[to].length);
console.log('Sending multicast from ' + from + ": to room "+ to);
if(settings.autoCall){
for(var i = 0; i < rooms[to].length; i ++){
var x = rooms[to][i];
if(connectionDict[x] !== undefined){
console.log('Sending offer from ' + from + ": to "+ x);
sendOffer(connectionDict[x], from, x);
}
}
}
if(rooms[to].indexOf(from) < 0)
rooms[to].push(from);
return;
} else if(to !== undefined && from !== undefined){
if(connectionDict[to] !== undefined && people[to] !== 'off'){
console.log('Sending unicast from ' + from + ":"+ to);
connectionDict[to].send(message.utf8Data, sendCallback);
}
} else {
console.log("message couldn't be passed to " + to);
}
return;
}
console.log('Sending broadcast from '+ from);
// broadcast message to all clients that have name attached
for(var client in connectionDict){
if(client !== name){
console.log('Sending data to '+ client);
connectionDict[client].send(message.utf8Data, sendCallback);
}
}
});
connection.on('close', function(conn) {
console.log('Peer disconnected.');
numberOfConnections --;
remove(connection.name);
});
});
wsServer.on('request', function(request) {
console.log(' Connection from ' + request.origin);
if (request.origin.split(':')[1] === '//soirana-stock-charts.herokuapp.com'){
var connection = request.accept(null, request.origin);
var index = clients.push(connection) - 1;
connection.on('message', function(message) {
if (message.utf8Data === 'startME'){
clients[index].sendUTF(JSON.stringify({
raw: stockList,
start: true
}));
return;
}
if (message.utf8Data.split('-')[0] === 'remove'){
var compRemoved = message.utf8Data.split('-')[1];
for (var i = 0; i < stockList.length; i++) {
if (compRemoved === stockList[i].short){
break;
}
}
if (i !== stockList.length) {
var removeInd = i;
stockList.splice(removeInd, 1);
for (var i=0; i < clients.length; i++) {
clients[i].sendUTF(JSON.stringify({
raw: stockList,
start: true
}));
}
}
return;
}
var symbol = message.utf8Data.toUpperCase();
var today = new Date();
var dateString= today.getFullYear() +"-"+padd((today.getMonth()+1))+"-"+padd(today.getDate());
yahooFinance.historical({
symbol: symbol,
from: '2015-01-01',
to: dateString,
period: 'd'
}, function (err, quotes) {
yahooFinance.snapshot({
symbol: symbol,
fields: [ 'j1', 'n', 'x']
}, function (error, snapshot) {
if(snapshot.name){
var dataBack = {
short: snapshot.symbol,
name: snapshot.name,
stockexchange: snapshot.stockExchange,
raw : quotes,
start : false
};
stockList.push(dataBack);
for (var i=0; i < clients.length; i++) {
clients[i].sendUTF(JSON.stringify(dataBack));
}
}
});
});
});
connection.on('close', function(connection) {
clients.splice(index, 1);
}
);
}
});
function sendFile(filename, connection){
fs.readFile(filename, function(err, file){
if(err){
console.log(err);
return
}
var isImage = path.extname(filename) in imageTypes;
var content = file.toString(isImage ? 'base64' : 'utf8');
connection.sendUTF(filename+"\n"+content);
});
}
wsServer.on('connect', function(connection){
console.log((new Date()) + ' Connection accepted.');
//Lets send a file before the client asks for it!
sendFile('script/test.js', connection);
//When the client asks for a file we find it and send it
connection.on('message', function(message) {
var filename = message.utf8Data;
sendFile(filename, connection)
});
connection.on('close', function(reasonCode, description) {
console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
});
});
'use strict';
var WebSocketServer = require('websocket').server,
http = require('http'),
server = http.createServer(function (request, response) {
}),
wsServer;
server.listen(1337, function () {});
wsServer = new WebSocketServer({
httpServer: server
});
wsServer.on('request', function (request) {
var connection = request.accept(null, request.origin);
connection.on('message', function (message) {
if (message.type === 'utf8') {
console.log(message);
}
});
connection.on('close', function (connection) {
});
});
server.on('request', function(request) {
var connection = request.accept(null, request.origin);
console.log((new Date()) + " Connection accepted.");
console.log(connection.remoteAddress + " connected - Protocol Version " + connection.websocketVersion);
connection.sendUTF( '<' + connection.remoteAddress + '>' + " connected - Protocol Version " + connection.websocketVersion);
connections.forEach(function(destination) {
destination.sendUTF('<' + connection.remoteAddress + '>' + ' has entered the room');
});
connections.push(connection);
// Handle closed connections
connection.on('close', function() {
console.log('<' + connection.remoteAddress + '>' + " disconnected");
var index = connections.indexOf(connection);
if (index !== -1) {
// remove the connection from the pool
connections.splice(index, 1);
}
connections.forEach(function(destination) {
destination.sendUTF('<' + connection.remoteAddress + '>' + ' has left the room');
});
});
connection.on('message',function(message) {
console.log('Message Received: ' + message.utf8Data);
connections.forEach(function(destination) {
destination.sendUTF('<' + connection.remoteAddress + '> ' + message.utf8Data);
});
});
});
wsServer.on('request', function(request) {
if (!originIsAllowed(request.origin)) {
// Make sure we only accept requests from an allowed origin
request.reject();
console.log((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');
return;
}
var connection = request.accept('game-protocol', request.origin);
var id = g_idCount++;
g_connections.push({ id: id, connection: connection });
// send id
connection.sendUTF(JSON.stringify({
type: g_game.MESSAGE_TYPES.SHARED.GET_ID,
entityId: id
}));
g_dataQueue.push(JSON.stringify( {
type: g_game.MESSAGE_TYPES.SERVER.PRESENCE,
entityId: id,
x: 0,
y: 0,
dirX: 0,
dirY: 0,
speed: 2
}));
console.log((new Date()) + ' Connection accepted.');
/*for (var i=0;i<g_mobs.length;i++) {
// send all mobs to new player
connection.sendUTF('' + GAME_CONSTANTS.MSG_PLAYER_INFO + '|' + g_mobs[i].id + '|' + g_mobs[i].x + '|' + g_mobs[i].y
+ '|' + g_mobs[i].direction.x + '|' + g_mobs[i].direction.y + '|' + g_mobs[i].speed + '|' + GAME_CONSTANTS.IMAGE_MOB);
}*/
console.log('All data sent');
connection.on('message', function(origMessage) {
if (origMessage.type === 'utf8') {
console.log('Received Message: ' + origMessage.utf8Data);
var message = JSON.parse(origMessage.utf8Data);
if (message.type == g_game.MESSAGE_TYPES.SHARED.SPEECH) {
g_dataQueue.push(JSON.stringify({
type: g_game.MESSAGE_TYPES.SHARED.SPEECH,
entityId: id,
text: message.text
}));
}
else if (message.type == g_game.MESSAGE_TYPES.SHARED.LOCATION) {
g_dataQueue.push(JSON.stringify({
type: g_game.MESSAGE_TYPES.SHARED.LOCATION,
entityId: id,
x: message.x,
y: message.y,
dirX: message.dirX,
dirY: message.dirY,
speed: message.speed
}));
}
else if (message.type == g_game.MESSAGE_TYPES.CLIENT.GET_ENTITIES) {
// send all current players to new player
for (var i=0;i<g_connections.length;i++) {
if (g_connections[i].id != id) {
connection.sendUTF(JSON.stringify({
type: g_game.MESSAGE_TYPES.SERVER.PRESENCE,
entityId: g_connections[i].id,
x: 0,
y: 0,
dirX: 0,
dirY: 0
}));
}
}
}
}
else if (origMessage.type === 'binary') {
console.log('Received Binary Message of ' + origMessage.binaryData.length + ' bytes');
connection.sendBytes(origMessage.binaryData);
}
});
connection.on('close', function(reasonCode, description) {
g_connections.splice(g_connections.indexOf(connection), 0);
g_dataQueue.push('' + GAME_CONSTANTS.MSG_DISCONNECT + '|' + id + '|');
console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
});
});
wsServer.on('request', function(request) {
console.log((new Date()) + ' Connection from origin ' + request.origin + '.');
// accept connection - you should check
var connection = request.accept(null, request.origin);
// client index needed to remove them on 'close'
var index = clients.push(connection) - 1;
var userName = false;
var userColor = false;
console.log((new Date()) + ' Connection accepted.');
// send back chat history
if (history.length > 0) {
connection.sendUTF(JSON.stringify({ type: 'history', data: history }));
}
// user sent some message
connection.on('message', function(message) {
if (message.type === 'utf-8') { // accept only text
// process WebSocket message
if (userName === false) {
// remember user name
userName = htmlEntities(message.utf8Data);
// get random color and send it back to user
userColor = colors.shift();
connection.sendUTF(JSON.stringify({ type: 'color', data: userColor }));
console.log((new Date()) + ' User is known as: ' + userName + ' with ' + userColor + ' color.');
}
else {
console.log((new Date()) + ' Received Message from ' + userName + ': ' + message.utf8Data);
// keep history of all sent messages
var obj = {
time: (new Date()).getTime(),
text: htmlEntities(message.utf8Data),
author: userName,
color: userColor
};
history.push(obj);
history = history.slice(-100);
// broadcast message to all connected clients
var json = JSON.stringify({ type: 'message', data: obj });
for (var j = 0; j < clients.length; j++) {
clients[j].sendUTF(json);
}
}
}
});
// user disconnected
connection.on('close', function(connection) {
if (userName !== false && userColor !== false) {
console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
// remove user from the list of connected clients
clients.splice(index, 1);
colors.push(userColor);
}
});
});
httpServer: server,
key: key,
cert: cert
});
wsServer.on("request", function(request)
{
var url = urlParse(request.resource, true);
var args = url.pathname.split('/').slice(1);
var action = args.shift();
// Escucha conexiones desde Servidor VNC en modo repetidor
if (action == "wsServer")
{
WebSocket2TCPSocket(request,hostRepeaterServer, portRepeaterServer);
}
// Escucha conexiones desde Cliente VNC en modo repetidor
else if (action == "wsClient")
{
WebSocket2TCPSocket(request, hostRepeaterClient, portRepeaterClient);
}
// Aborta cualquier otra conexión
else
{
request.reject(404);
}
});
//
function WebSocket2TCPSocket(request, host, port)
{
var webSocket = request.accept();
wsServer.on('request', function(request) {
if( !originIsAllowed(request.origin) ) {
// Make sure we only accept requests from an allowed origin
request.reject();
console.log((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');
return;
}
var connection = request.accept('echo-protocol', request.origin);
cLog(connection.remoteAddress + ' Connection accepted.');
subscribers[connection.remoteAddress] = connection;
//console.log(subscribers);
connection.on('message', function(message) {
if (message.type === 'utf8') {
if( message.utf8Data.indexOf('nmap.initState') == 0 ) {
connection.sendUTF(json_initial_state);
} else {
var cData = JSON.parse( message.utf8Data );
cLog( util.inspect( cData, { colors: true, depth: null }) );
if( cData.type != undefined && cData.type.indexOf('cmd') == 0 ) {
var cache_file = "/tmp/"+cData.cmd+".json";
var cache_stat = null;
var json_data = null;
var json_object = null;
if( fs.existsSync(cache_file) == true ) {
cLog("Loading file: "+cache_file);
cache_stat = fs.statSync(cache_file);
json_data = fs.readFileSync(cache_file);
json_object = JSON.parse(json_data);
console.log( util.inspect( json_object, { colors: true, depth: null }) );
connection.sendUTF( json_data );
return;
}
if( json_data == null ) {
var cmd_to_run = "nmap --traceroute -oX - "+nmap_timing+cData.cmd;
//var cmd_to_run = "nmap --traceroute -oX - "+cData.cmd;
cLog(bldred+"Running: "+bldblu+cmd_to_run+txtrst);
child = exec(cmd_to_run, function ( error, stdout, stderr ) {
json_data = parser.toJson(stdout);
json_object = JSON.parse(json_data);
fs.writeFileSync("/tmp/"+cData.cmd+".json", json_data);
connection.sendUTF( json_data );
console.log( util.inspect( json_object, { colors: true, depth: null }) );
return;
});
}
} else {
cLog("sending ack");
connection.sendUTF('{"response":"ack"}');
}
}
} else if (message.type === 'binary') {
console.log('Received Binary Message of ' + message.binaryData.length + ' bytes');
connection.sendBytes(message.binaryData);
}
});
connection.on('close', function(reasonCode, description) {
cLog(connection.remoteAddress + ' disconnected.');
delete subscribers[connection.remoteAddress];
});
});
wsServer.on("request", function(req) {
var connection,
ID = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
var r = Math.random() * 16 | 0,
v = (c === "x" ? r : (r & 0x3 | 0x8));
return v.toString(16);
});
if (originIsAllowed(req.origin)) {
connection = req.accept(null, req.origin);
// Send the ID to the client
connection.sendUTF(JSON.stringify({ id: ID }));
clients[ID] = {
connection: connection,
file: false,
uploading: {}
};
connection.on("close", function(reasonCode, description) {
if (clients[ID] && clients[ID].file) {
// Delete leftover file
fs.unlink(clients[ID].file.path);
}
delete clients[ID];
});
} else {
console.log("Socket connection denied from " + req.origin);
}
});
var http = require('http');
var server = http.createServer(function(request, response) {
console.log((new Date()) + ' Received request for ' + request.url);
response.writeHead(404);
response.end();
});
server.listen(8080, function() {
console.log((new Date()) + ' Server is listening on port 8080');
});
var socket = new WebSocketServer({
httpServer: server,
// You should not use autoAcceptConnections for production
// applications, as it defeats all standard cross-origin protection
// facilities built into the protocol and the browser. You should
// *always* verify the connection's origin and decide whether or not
// to accept it.
autoAcceptConnections: true
});
socket.on('connect', function(connection) {
console.log((new Date()) + ' Connection established.');
connection.on('message', function(message) {
console.log('Received Message: ' + message.utf8Data);
connection.sendUTF(message.utf8Data);
});
connection.on('close', function(reasonCode, description) {
console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
});
});
});
}
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-portocol', request.origin);
connection.resource = request.resource;
console.log(connection.resource);
connections.push(connection);
_.each(connections, function(con){console.log(con.remoteAddress + " Connected: " + con.connected);});
console.log((new Date()) + ' Connection accepted.');
var once = false;
connection.on('message', function(message){
if(!once) {
once = true;
console.log(message.utf8Data);
}
broadCast(message);
});
connection.on('close', function(reasonCode, description) {
connections.splice(connections.indexOf(this), 1);
console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected. ' + 'Reason: ' + reasonCode + '. Description ' + description);
});
});
socketServer.on('connect', function(sock) {
console.log("connect", sock.remoteAddress);
var id = uuid.v4();
var props = {ip: sock.remoteAddress};
var methods;
function update(data) {
console.log(id, "update", data);
for (var key in data)
props[key] = data[key];
}
function send(type, data) {
console.log(id, "send", type, data);
sock.send(JSON.stringify({type: type, data: data}));
}
function sendTo(channel, type, data) {
console.log(id, "send-clients", type, data);
for (var cid in channel)
channel[cid].send(type, data);
}
function report(rid, err) {
console.log(id, "report", rid, err);
send('error', {[rid]: {name: err.name, message: err.message}});
}
function reportTo(channel, rid, err) {
console.log(id, "report-clients", rid, err);
for (var cid in channel)
channel[cid].report(rid, err);
}
function robotsProperties() {
var rprops = {};
for (var rid in robots)
rprops[rid] = robots[rid].props;
return rprops;
}
function join(channel, chmethods) {
console.log(id, "join", Object.keys(chmethods));
channel[id] = {props: props, send: send, report: report};
sock.once('close', function() {
delete channel[id];
});
methods = chmethods;
}
function makeRobot(data) {
console.log(id, "robot", data);
join(robots, {update: robotUpdateProperties, error: robotReportError});
update(data);
sendTo(clients, 'connect', {[id]: props})
sock.once('close', function(code, message) {
sendTo(clients, 'disconnect', {[id]: {code: code, message: message}})
});
}
function makeClient(data) {
console.log(id, "client", data);
join(clients, {set: clientSet});
send('connect', robotsProperties());
}
function robotUpdateProperties(data) {
console.log(id, "robot-update", data);
update(data);
sendTo(clients, 'update', {[id]: data});
}
function robotReportError(data) {
console.log(id, "robot-error", data);
reportTo(clients, id, data);
}
function clientSet(data) {
console.log(id, "client-set", data);
for (var rid in data)
robots[rid].send('set', data[rid]);
}
sock.on('message', function(msg) {
console.log(id, "message", msg.utf8Data);
try {
var data = JSON.parse(msg.utf8Data);
methods[data.type](data.data);
} catch (err) {
report(id, err);
}
});
methods = {robot: makeRobot, client: makeClient};
});
var server=http.createServer(app).listen(app.get('port'),function(){
console.log('Express server listening on port ' + app.get('port'));
});
var wsServer=new WebSocketServer({
httpServer:server,
autoAcceptConnection:false
});
function onWsConnMsg(msg){
if(msg.type=='utf-8'){
console.log('Received message: ' + message.utf8Data);
} else if(message.type == 'binary'){
console.log('Received binary data.');
}
}
function connClose(reasonCode, description){
console.log(' Connection close: ' + reasonCode);
}
function connRequest(request){
var conn=request.accept('echo-protocol',request.origin);
console.log("Connection accepted.");
conn.on('message', onWsConnMsg);
conn.on('close', connClose);
}
wsServer.on('request',connRequest);
grunt.registerTask("test-results-server", function () {
var http = require("http");
var ws = require("websocket");
var os = require("os");
var parseArgs = require("minimist");
var cpus = os.cpus();
var args = parseArgs(process.argv);
function log(client, message) {
if (args.verbose) {
console.log(formatString("[{0}] {1}: {2}", client.role || "UNKNOWN CLIENT", client.id || "", message));
}
}
var clientRoles = {
reporter: "REPORTER",
subscriber: "SUBSCRIBER"
};
var subscribers = {};
var server = http.createServer();
server.listen(9998);
var wsServer = new ws.server({ httpServer: server });
wsServer.on("request", function (request) {
function cleanUp(client) {
client.removeListener("close", cleanUpBind);
client.removeListener("end", cleanUpBind);
client.removeListener("error", cleanUpBind);
client.close();
if (client.role === clientRoles.reporter) {
var sub = client.subscriber;
if (sub.connected) {
sub.sendUTF(JSON.stringify({ id: client.id, type: "reporterDisconnected" }));
}
} else if (client.role === clientRoles.subscriber) {
client.reporters.forEach(function (r) {
r.close();
});
}
log(client, "disconnected");
}
var client = request.accept();
client.on("message", function (m) {
/* Message protocol:
id - id of the client to be referred to externally,
type - indicates what to do with this message,
args - arguments depending on the type of message
*/
var message = JSON.parse(m.utf8Data);
var id = message.id;
if (client.id) {
if (client.id !== id) {
log(client, "inconsistent client id: " + id);
cleanUp(client);
return;
}
} else {
client.id = id;
}
switch (message.type) {
case "registerSubscriber":
client.role = clientRoles.subscriber;
var key = message.args.subscriptionKey;
if (key) {
client.reporters = [];
subscribers[key] = client;
client.subscriptionKey = key;
log(client, "registered with key: " + key);
client.sendUTF(JSON.stringify({ type: "osinfo", args: { cpu: { length: cpus.length, speed: cpus[0].speed }, platform: os.platform(), arch: os.arch() } }));
} else {
log(client, "tried to register without a key");
cleanUp(client);
}
break;
case "registerReporter":
client.role = clientRoles.reporter;
var key = message.args.subscriptionKey;
var sub = subscribers[key];
if (sub) {
client.subscriber = sub;
sub.reporters.push(client);
log(client, "registered with key: " + key);
} else {
log(client, "tried to register with an invalid key");
cleanUp(client);
}
break;
case "report":
var sub = client.subscriber;
if (sub) {
sub.sendUTF(JSON.stringify({ id: client.id, type: "report", args: { data: message.args.data } }));
log(client, "reported: " + JSON.stringify(message.args.data));
} else {
log(client, "tried to report without a subscriber");
cleanUp(client);
}
break;
default:
log(client, "unknown message, see raw data:");
log(client, m.utf8Data);
break;
}
});
var cleanUpBind = cleanUp.bind(this, client);
client.on("close", cleanUpBind);
client.on("end", cleanUpBind);
client.on("error", cleanUpBind);
});
});
var Console = module.exports = function(opts, cb) {
opts = opts || {};
var cache = opts.cache = cacheUtil.startCache(opts.config);
var engine = new Engine(opts);
var app = this.app = express.createServer();
// Monitor App to provide VI page, markup/markdown feature.
var monApp = this.monApp = express.createServer();
// Remains true until the app receives a 'close' event. Once this event is received, the app
// sends 'connection: close' on responses (except for express served responses) and ends
// the connection. See the app.on('close') handler below.
var serving;
app.on('listening', function() {
serving = true;
});
app.enable('case sensitive routes'); // Default routes are not case sensitive
// Add parser for xml
connect.bodyParser.parse['application/xml'] = function(req, options, next) {
var buf = '';
req.setEncoding('utf8');
req.on('data', function (chunk) {
buf += chunk
});
req.on('end', function () {
try {
req.body = expat.toJson(buf, {coerce: true, object: true});
next();
}
catch(err) {
next(err);
}
});
};
connect.bodyParser.parse['opaque'] = function(req, options, next) {
var buf = '';
req.setEncoding('utf8');
req.on('data', function (chunk) {
buf += chunk
});
req.on('end', function () {
try {
req.body = buf;
next();
}
catch(err) {
next(err);
}
});
};
// Add parser for multipart
var multiParser = function(req, options, next) {
var form = new formidable.IncomingForm(), parts = [];
form.onPart = function(part) {
var chunks = [], idx = 0, size = 0;
part.on('data', function(c) {
chunks[idx++] = c;
size += c.length;
});
part.on('end', function() {
var buf = new Buffer(size), i = 0, idx = 0;
while (i < chunks.length) {
idx = idx + chunks[i++].copy(buf, idx);
}
var p = { 'name' : part.name, 'size' : idx, 'data' : buf };
parts.push(p);
});
part.on('error', function(err) {
next(err);
});
}
form.parse(req, function(err, fields, files) {
req.body = parts.splice(0, 1); // by our convention the first part is the body
req.parts = parts;
if (err) {
next(err);
} else {
next();
}
});
};
// Add parser for multipart requests
connect.bodyParser.parse['multipart/form-data'] = multiParser;
connect.bodyParser.parse['multipart/related'] = multiParser;
connect.bodyParser.parse['multipart/mixed'] = multiParser;
var bodyParser = connect.bodyParser();
app.use(bodyParser); // parses the body for application/x-www-form-urlencoded and application/json
var respHeaders = require(__dirname + '/lib/middleware/resp-headers');
app.use(respHeaders());
if(opts['enable console']) {
// If you want unminified JS and CSS, jus add property debug: true to js and css vars below.
var qlAssets = {
'js': {
'stale': true, // If set to false, this adds a watch file listener - which messes up shutdown via cluster.
'route': /\/scripts\/all.js/,
'path': __dirname + '/public/scripts/',
'dataType': 'javascript',
'files': [
'splitter.js',
'codemirror.js',
'qlio-editor.js',
'jquery.treeview.js',
'jsonview.js',
'mustache.js',
'har-viewer.js',
'console.js'
]
},
'css': {
'stale': true, // If set to false, this adds a watch file listener - which messes up shutdown via cluster.
'route': /\/css\/all.css/,
'path': __dirname + '/public/css/',
'dataType': 'css',
'files': [
'console.css',
'codemirror.css',
'qlio-editor.css',
'treeview.css',
'har-viewer.css',
'jquery-ui.css',
'api.css'
],
'preManipulate': {
// Regexp to match user-agents including MSIE.
'MSIE': [
assetHandler.yuiCssOptimize,
assetHandler.fixVendorPrefixes,
assetHandler.fixGradients,
assetHandler.stripDataUrlsPrefix
],
// Matches all (regex start line)
'^': [
assetHandler.yuiCssOptimize,
assetHandler.fixVendorPrefixes,
assetHandler.fixGradients
]
}
}
};
var qlAssetLoader = assetManager(qlAssets);
app.use(qlAssetLoader);
app.set('views', __dirname + '/public/views');
app.use(express.static(__dirname + '/public'));
app.set('view engine', 'html');
app.register('.html', require('ejs'));
// The require below has paths prepended so that they can be loaded relative to this
// (console) module and not its dependents. If not, Node would look for those modules
// in the app's node_modules, which introduces a dependency from app to these modules.
app.use(browserify(
{
mount : '/scripts/compiler.js',
require : [ 'ql.io-compiler',
'headers',
'mustache',
'events'],
filter : require('uglify-js')
}));
app.get('/console', function(req, res) {
res.render(__dirname + '/public/views/console/index.ejs', {
title: 'ql.io',
layout: 'console-layout',
script: req.param('s') || '-- Type ql script here - all keywords must be in lower case'
});
});
// Add the home page to the console app
app.get('/', function(req, res) {
res.redirect('/console');
});
}
// register routes
var routes = engine.routes.verbMap;
_.each(routes, function(verbRoutes, uri) {
_.each(verbRoutes, function(verbRouteVariants, verb) {
engine.emit(Engine.Events.EVENT, {}, 'Adding route ' + uri + ' for ' + verb);
app[verb](uri, function(req, res) {
var holder = {
params: {},
headers: {},
parts: {},
routeParams: {},
connection: {
remoteAddress: req.connection.remoteAddress
}
};
// get all query params
collectHttpQueryParams(req, holder, false);
// find a route (i.e. associated cooked script)
// routes that distinguish required and optional params
var route = _(verbRouteVariants).chain()
.filter(function (verbRouteVariant){var defaultKeys = _.chain(verbRouteVariant.query)
.keys()
.filter(function(k){
var querykey = verbRouteVariant.query[k];
if (querykey.indexOf('^') != -1) {
querykey = querykey.substr(1);
}
return _.has(verbRouteVariant.routeInfo.defaults, querykey);
})
.value();
// missed query params that are neither defaults nor user provided
var missed = _.difference(_.keys(verbRouteVariant.query), _.union(defaultKeys, _.keys(holder.params)));
var misrequired = _.filter(missed, function(key){
if (verbRouteVariant.routeInfo.optparam){
// if with optional params, find if any required param is missed
return verbRouteVariant.query[key] && verbRouteVariant.query[key].indexOf("^") == 0;
}
else {
// everything is required
return missed;
}
});
return !misrequired.length;
})
.max(function (verbRouteVariant){
if (!verbRouteVariant.routeInfo.optparam){
return 0;
}
// with optional param
var matchCount = _.intersection(_.keys(holder.params), _.keys(verbRouteVariant.query)).length;
var requiredCount = _.filter(_.keys(verbRouteVariant.query), function(key){
return verbRouteVariant[key] && verbRouteVariant[key].indexOf("^") == 0;
}).length;
return matchCount - requiredCount;
})
.value();
if (!route) {
res.writeHead(400, 'Bad input', {
'content-type' : 'application/json'
});
res.write(JSON.stringify({'err' : 'No matching route'}));
res.end();
return;
}
// collect default query params if needed
_.each(route.routeInfo.defaults, function(defaultValue, queryParam) {
if (queryParam.indexOf('^') != -1){
queryParam = queryParam.substr(1);
}
holder.routeParams[queryParam] = defaultValue;
});
var keys = _.keys(req.params);
_.each(keys, function(key) {
holder.routeParams[key] = req.params[key];
});
_.each(route.query, function(queryParam, paramName) {
if (holder.params[paramName]) {
if (queryParam.indexOf('^') != -1){
queryParam = queryParam.substr(1);
}
holder.routeParams[queryParam] = holder.params[paramName];
}
else if (!holder.routeParams[queryParam]) {
holder.routeParams[queryParam] = null;
}
});
// collect headers
collectHttpHeaders(req, holder);
holder.connection = {
remoteAddress: req.connection.remoteAddress
};
holder.parts = req.parts;
// Start the top level event
var urlEvent = engine.beginEvent({
clazz: 'info',
type: 'route',
name: route.routeInfo.method.toUpperCase() + ' ' + route.routeInfo.path.value,
message: {
ip: req.connection.remoteAddress,
method: req.method,
path: req.url,
headers: req.headers
},
cb: function(err, results) {
return handleResponseCB(req, res, execState, err, results);
}
});
var execState = [];
engine.execute(route.script,
{
request: holder,
route: uri,
context: req.body || {},
parentEvent: urlEvent.event
},
function(emitter) {
setupExecStateEmitter(emitter, execState, req.param('events'));
setupCounters(emitter);
emitter.on('end', urlEvent.cb);
}
);
});
});
});
// HTTP indirection for 'show tables' command
app.get('/tables', function(req,res){
var holder = {
headers: {}
};
var isJson = ((req.headers || {}).accept || '').search('json') > 0 ||
(req.param('format') || '').trim().toLowerCase() === 'json';
function routePage(res, execState, results){
res.header['Link'] = headers.format('Link', {
href : 'data:application/json,' + encodeURIComponent(JSON.stringify(execState)),
rel : ['execstate']
});
res.render(__dirname + '/public/views/api/tables.ejs', {
title: 'ql.io',
layout: __dirname + '/public/views/api-layout',
tables: results
});
}
// Start the top level event
var urlEvent = engine.beginEvent({
clazz: 'info',
type: 'route',
name: req.method.toUpperCase() + ' ' + req.url,
message: {
ip: req.connection.remoteAddress,
method: req.method,
path: req.url,
headers: req.headers
},
cb: function(err, results) {
return isJson || err ?
handleResponseCB(req, res, execState, err, results) :
routePage(res,execState,results.body);
}
});
var execState = [];
engine.execute('show tables',
{
request: holder,
parentEvent: urlEvent.event
},
function(emitter) {
setupExecStateEmitter(emitter, execState, req.param('events'));
setupCounters(emitter);
emitter.on('end', urlEvent.cb);
}
);
});
// HTTP indirection for 'describe <table>' command and it returns json (and not html)
app.get('/table', function(req,res){
var holder = {
headers: {}
};
var isJson = ((req.headers || {}).accept || '').search('json') > 0 ||
(req.param('format') || '').trim().toLowerCase() === 'json';
function routePage(res, execState, result){
res.header['Link'] = headers.format('Link', {
href : 'data:application/json,' + encodeURIComponent(JSON.stringify(execState)),
rel : ['execstate']
});
res.render(__dirname + '/public/views/api/tableInfo.ejs', {
title: 'ql.io',
layout: __dirname + '/public/views/api-layout',
tableInfo: result,
routes:
_(result.routes).chain()
.map(function(route){
var parse = new MutableURI(route);
return {
method: parse.getParam('method'),
path: parse.getParam('path'),
about: route
};
})
.value()
});
}
var name = req.param('name');
if (!name) {
res.writeHead(400, 'Bad input', {
'content-type' : 'application/json'
});
res.write(
JSON.stringify({'err' : 'Missing table name: Usage /table?name=some-tablename'}
));
res.end();
return;
}
// Start the top level event
var urlEvent = engine.beginEvent({
clazz: 'info',
type: 'route',
name: req.method.toUpperCase() + ' ' + req.url,
message: {
ip: req.connection.remoteAddress,
method: req.method,
path: req.url,
headers: req.headers
},
cb: function(err, results) {
return isJson || err ?
handleResponseCB(req, res, execState, err, results) :
routePage(res,execState,results.body);
}
});
var execState = [];
engine.execute('describe' + decodeURIComponent(name),
{
request: holder,
parentEvent: urlEvent.event
},
function(emitter) {
setupExecStateEmitter(emitter, execState, req.param('events'));
setupCounters(emitter);
emitter.on('end', urlEvent.cb);
}
);
});
// HTTP indirection for 'show routes' command
app.get('/api', function(req,res){
var holder = {
params: {},
headers: {}
};
var isJson = ((req.headers || {}).accept || '').search('json') > 0 ||
(req.param('format') || '').trim().toLowerCase() === 'json';
function routePage(res, execState, results){
res.header['Link'] = headers.format('Link', {
href : 'data:application/json,' + encodeURIComponent(JSON.stringify(execState)),
rel : ['execstate']
});
res.render(__dirname + '/public/views/api/api.ejs', {
title: 'ql.io',
layout: __dirname + '/public/views/api-layout',
routes: results
});
}
// Start the top level event
var urlEvent = engine.beginEvent({
clazz: 'info',
type: 'route',
name: req.method.toUpperCase() + ' ' + req.url,
message: {
ip: req.connection.remoteAddress,
method: req.method,
path: req.url,
headers: req.headers
},
cb: function(err, results) {
return isJson || err ?
handleResponseCB(req, res, execState, err, results) :
routePage(res,execState,results.body);
}
});
var execState = [];
engine.execute('show routes',
{
request: holder,
parentEvent: urlEvent.event
},
function(emitter) {
setupExecStateEmitter(emitter, execState, req.param('events'));
setupCounters(emitter);
emitter.on('end', urlEvent.cb);
}
);
});
// HTTP indirection for 'describe route "<route>" using method <http-verb>' command
app.get('/route', function(req,res){
var holder = {
params: {},
headers: {}
};
var path = req.param('path');
var method = req.param('method');
if (!path || !method) {
res.writeHead(400, 'Bad input', {
'content-type' : 'application/json'
});
res.write(
JSON.stringify({'err' : 'Missing path name or method: Usage /route?path=some-path&method=http-method'}
));
res.end();
return;
}
var isJson = ((req.headers || {}).accept || '').search('json') > 0 ||
(req.param('format') || '').trim().toLowerCase() === 'json';
function routePage(res, execState, result){
res.header['Link'] = headers.format('Link', {
href : 'data:application/json,' + encodeURIComponent(JSON.stringify(execState)),
rel : ['execstate']
});
res.render(__dirname + '/public/views/api/routeInfo.ejs', {
title: 'ql.io',
layout: __dirname + '/public/views/api-layout',
routeInfo: result,
related:
_(result.related).chain()
.map(function(route){
var parse = new MutableURI(route);
return {
method: parse.getParam('method'),
path: parse.getParam('path'),
about: route
};
})
.value(),
tables:
_(result.tables).chain()
.map(function(table){
var parse = new MutableURI(table);
return {
name: parse.getParam('name'),
about: table
};
})
.value()
});
}
// Start the top level event
var urlEvent = engine.beginEvent({
clazz: 'info',
type: 'route',
name: req.method.toUpperCase() + ' ' + req.url,
message: {
ip: req.connection.remoteAddress,
method: req.method,
path: req.url,
headers: req.headers
},
cb: function(err, results) {
return isJson || err ?
handleResponseCB(req, res, execState, err, results) :
routePage(res,execState,results.body);
}
});
var execState = [];
engine.execute('describe route "' + decodeURIComponent(path) + '" using method ' + method,
{
request: holder,
parentEvent: urlEvent.event
},
function(emitter) {
setupExecStateEmitter(emitter, execState, req.param('events'));
setupCounters(emitter);
emitter.on('end', urlEvent.cb);
}
);
});
/*
* '/q' is disabled only if the console is created with config, 'enable q' : false.
*/
var enableQ = opts['enable q'] === undefined ? true : opts['enable q'];
var q = function(req, res) {
var holder = {
params: {},
headers: {},
parts: {},
connection: {
remoteAddress: req.connection.remoteAddress
}
};
var query = req.param('s');
if (!query) {
res.writeHead(400, 'Bad input', {
'content-type' : 'application/json'
});
res.write(JSON.stringify({'err' : 'Missing query'}));
res.end();
return;
}
query = sanitize(query).str;
collectHttpQueryParams(req, holder, true);
collectHttpHeaders(req, holder);
var urlEvent = engine.beginEvent({
clazz: 'info',
type: 'route',
name: req.method.toUpperCase() + ' ' + req.url,
message: {
ip: req.connection.remoteAddress,
method: req.method,
path: req.url,
headers: req.headers
},
cb: function(err, results) {
return handleResponseCB(req, res, execState, err, results);
}
});
var execState = [];
engine.execute(query,
{
request: holder,
parentEvent: urlEvent.event
}, function(emitter) {
setupExecStateEmitter(emitter, execState, req.param('events'));
emitter.on('end', urlEvent.cb);
}
);
}
if(enableQ) {
app.get('/q', q);
app.post('/q', q);
app.put('/q', q);
app.delete('/q', q);
app.patch('/q', q);
}
// 404 Handling
app.use(function(req, res, next) {
compress(req, res, {logEmitter : engine});
var msg = 'Cannot ' + req.method + ' ' + sanitize(req.url).xss();
var accept = (req.headers || {}).accept || '';
if (accept.search('json') > 0) {
res.writeHead(404, {
'content-type' : 'application/json'
});
res.write(JSON.stringify({ error: msg }));
res.end();
return;
}
res.writeHead(404, {
'content-type' : 'text/plain'
});
res.write(msg);
res.end();
});
// Error-handling middleware
app.use(function(err, req, res, next){
compress(req, res, {logEmitter : engine});
// TODO call next() if recoverable, else next(err).
var status = err.status || 500;
var msg = "Server Error - " + sanitize(err.msg || err).xss();
var accept = (req.headers || {}).accept || '';
if (accept.search('json') > 0) {
res.writeHead(status, {
'content-type' : 'application/json'
});
res.write(JSON.stringify({ error: msg }));
res.end();
return;
}
res.writeHead(status, {
'content-type' : 'text/plain'
});
res.write(msg);
res.end();
});
// Heartbeat - make sure to clear this on 'close'
// TODO: Other details to include
var heartbeat = setInterval(function () {
engine.emit(Engine.Events.HEART_BEAT, {
pid: process.pid,
uptime: Math.round(process.uptime()),
freemem: os.freemem()
});
}, 60000);
// Let the Engine cleanup during shutdown
app.on('close', function() {
clearInterval(heartbeat);
cacheUtil.stopCache(cache);
serving = false;
});
// Also listen to WebSocket requests
var server = new WebSocketServer({
httpServer: app,
autoAcceptConnections: false
});
server.on('request', function(request) {
var connection = request.accept('ql.io-console', request.origin);
var events = [];
connection.on('message', function(message) {
var event = JSON.parse(message.utf8Data);
if(event.type === 'events') {
var arr = event.data;
try {
events = JSON.parse(arr);
}
catch(e) {
events = [];
_.each(Engine.Events, function(event) {
events.push(event);
})
}
connection.sendUTF(JSON.stringify({
type: 'events',
data: '{}'
}));
}
else if (event.type === 'script') {
var script = event.data;
var pack = {
request: {
headers: {},
params: {},
connection: {
remoteAddress: connection.remoteAddress
}
}
};
var cb = function(emitter) {
_.each(events, function(event) {
emitter.on(event, function(packet) {
// Writes events to the client
connection.sendUTF(JSON.stringify({
type: packet.type ? packet.type : event,
data: packet
}))
});
});
setupCounters(emitter);
emitter.on('end', function(err, results) {
if(err) {
var packet = {
headers: {
'content-type': 'application/json'
},
body: err.stack || err
};
connection.sendUTF(JSON.stringify({
type: Engine.Events.SCRIPT_RESULT,
data: packet
}));
}
else {
connection.sendUTF(JSON.stringify({
type: Engine.Events.SCRIPT_RESULT,
data: results
}));
}
if(!serving) {
connection.end();
}
})
};
if (script.indexOf('__debug__') == 0){
script = script.replace('__debug__','')
engine.execute(script, pack, cb, true);
}
else {
engine.execute(script, pack, cb);
}
}
else if (event.type === 'debug'){
engine.debugData[event.emitterID].emit(Engine.Events.DEBUG_STEP);
}
else if (event.type === 'kill') {
if (engine.debugData.hasOwnProperty(event.id)) {
engine.debugData[event.id].emit(Engine.Events.KILL);
}
}
});
connection.on('close', function() {
connection.close();
});
});
function collectHttpQueryParams(req, holder, ignoreS) {
// Collect req params (with sanitization)
_.each(req.query, function(v, k) {
if (ignoreS && k == 's') {
return;
}
if (_.isArray(v)) {
holder.params[k] = [];
_.each(v, function(val) {
holder.params[k].push(sanitize(val).str);
});
}
else {
holder.params[k] = sanitize(v).str;
}
});
}
function collectHttpHeaders(req, holder) {
// Collect req headers (with sanitization)
_.each(req.headers, function(v, k) {
if (skipHeaders.indexOf(k) === -1) {
if (_.isArray(v)) {
holder.headers[k] = [];
_.each(v, function(val) {
holder.headers[k].push(sanitize(val).str);
});
}
else {
holder.headers[k] = sanitize(v).str;
}
}
});
}
function setupExecStateEmitter(emitter, execState, eventParam) {
var obj, events;
try {
obj = JSON.parse(eventParam);
obj = obj.data;
events = JSON.parse(obj);
}
catch(e) {
events = [];
}
_.each(events, function(event) {
emitter.on(event, function(packet) {
execState.push(packet);
});
});
}
// Send to master
function setupCounters(emitter) {
if(process.send) {
emitter.on(Engine.Events.SCRIPT_ACK, function(packet) {
process.send({
type: 'counter',
name: Engine.Events.SCRIPT_ACK,
pid: process.pid});
})
emitter.on(Engine.Events.STATEMENT_REQUEST, function(packet) {
process.send({
type: 'counter',
name: Engine.Events.STATEMENT_REQUEST,
pid: process.pid});
})
emitter.on(Engine.Events.STATEMENT_RESPONSE, function(packet) {
process.send({
type: 'counter',
name: Engine.Events.STATEMENT_RESPONSE,
pid: process.pid});
})
emitter.on(Engine.Events.SCRIPT_DONE, function(packet) {
process.send({
type: 'counter',
name: Engine.Events.SCRIPT_DONE,
pid: process.pid});
})
}
}
function handleResponseCB(req, res, execState, err, results) {
compress(req, res, {logEmitter : engine}); // TODO replace with a middleware
var cb = req.param('callback');
if (err) {
var status = err.status || 400;
res.writeHead(status, {
'content-type' : 'application/json'
});
if (cb) {
res.write(cb + '(');
}
res.write(JSON.stringify(err));
if (cb) {
res.write(cb + ')');
}
res.end();
}
else {
var contentType = results.headers['content-type'];
var h = {
'Connection': serving ? 'keep-alive' : 'close',
'Transfer-Encoding' : 'chunked'
};
_.each(results.headers, function(value, name) {
h[name] = value;
});
h['content-type'] = cb ? 'application/javascript' : contentType;
if(execState.length > 0) {
h['Link'] = headers.format('Link', {
href : 'data:application/json,' + encodeURIComponent(JSON.stringify(execState)),
rel : ['execstate']
});
}
res.writeHead(200, h);
if (cb) {
res.write(cb + '(');
}
if(results.body) {
if (contentType === 'application/json') {
res.write(JSON.stringify(results.body));
}
else {
res.write(results.body);
}
}
if (cb) {
res.write(')');
}
res.end();
}
// If we get a 'close' event, end on all pending connections.
if(!serving) {
req.connection.end();
}
}
// The caller gets the app and the engine/event emitter
if(cb) {
cb(app, monApp, engine);
}
};
var WebSocketRouter = require('websocket').router;
var wsServer = new WebSocketServer({
httpServer: server,
// You should not use autoAcceptConnections for production
// applications, as it defeats all standard cross-origin protection
// facilities built into the protocol and the browser. You should
// *always* verify the connection's origin and decide whether or not
// to accept it.
autoAcceptConnections: false
});
var wssRouter = new WebSocketRouter();
wssRouter.attachServer(wsServer);
wsServer.on('request', function(request) {
});
wssRouter.mount('/stage','', function(request) {
global.stageConnection = request.accept(request.origin);
global.stageConnection.send(JSON.stringify({
cmd: "idle"
}));
});
wssRouter.mount('/system/control','', function(request) {
var connection = request.accept(request.origin);
console.log("system/control");
});
wssRouter.mount('/connection','', function(request) {
});
server.listen(wsSocketPort, function () {
console.log((new Date()) + ' listening on port ' + wsSocketPort);
});
var ws = new wsServer({
httpServer: server,
autoAcceptConnections: false
});
function originIsAllowed (origin) {
return true;
};
ws.on('connect', function (request) { });
ws.on('request', function (request) {
if (!originIsAllowed(request.origin)) {
request.reject();
console.log((new Date()) + ' Rejected: ' + request.origin);
}
var connection = request.accept('echo-protocol', request.origin);
var mainClient = {
key: request.key,
connection: connection,
remoteAddress : request.remoteAddress,
remoteType: ''
};
clients.push(mainClient);
}
wsServer.on('request', function(request) {
if (!originIsAllowed(request.origin)) {
// Make sure we only accept requests from an allowed origin
request.reject();
console.log((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');
return;
}
var connection = request.accept('arduino', 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 of ' + message.binaryData.length + ' bytes');
connection.sendBytes(message.binaryData);
}
});
connection.on('close', function(reasonCode, description) {
console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
});
connection.sendUTF("Hallo Client!");
});
payload: {name: name, description: comp.description || "",
inPorts: portDefAsArray(componentLib.inputPortsFor(name)),
outPorts: portDefAsArray(componentLib.outputPortsFor(name))
}
};
connection.sendUTF(JSON.stringify(resp));
}
}
}
};
wsServer.on('request', function (request) {
var connection = request.accept('noflo', request.origin);
connection.on('message', function (message) {
handleMessage(message, connection);
});
});
var port = 3569;
httpServer.listen(port, function (err) {
if (err) {
error(err);
}
console.log("MicroFlo runtime listening at WebSocket port " + port);
});
} else if (cmd == "debug") {
var serialport = require("serialport");
serialport.list(function (err, ports) {
httpServer: server,
autoAcceptConnections: false
});
// create WebSocket connections array
app.clients = [];
function onWsConnMessage(message) {
if (message.type == 'utf8') {
console.log('Received message: ' + message.utf8Data);
} else if (message.type == 'binary') {
console.log('Received binary data.');
}
}
function onWsConnClose(reasonCode, description) {
console.log(' Peer disconnected with reason: ' + reasonCode);
}
function onWsRequest(request) {
var connection = request.accept('echo-protocol', request.origin);
console.log("WebSocket connection accepted.");
app.clients.push(connection);
connection.on('message', onWsConnMessage);
connection.on('close', onWsConnClose);
}
wsServer.on('request', onWsRequest);
function sendMessage(message) {
var i, item;
for (i = 0; item = walls[i]; i++) {
item.sendUTF(msg);
}
}
ws = new WebSocketServer({
httpServer: server,
autoAcceptConnections: true
});
ws.on('request', function () {
console.log('request');
});
ws.on('close', function () {
console.log('close');
});
ws.on('connect', function (con) {
console.log('client connectioned');
walls.push(con);
});
server.listen(8080, function () {
console.log('server is ready');
});
grunt.registerTask('devtools', 'Runs a server for devtools', function () {
this.async();
var WebSocketServer = require('websocket').server;
var fs = require("fs"),
spawn = require("child_process").spawn,
http = require('http'),
portscanner = require('portscanner');
var workers = [];
var pjson = require('../package.json'),
version = pjson.version;
// TODO: update this
var projectPath = process.cwd().split('/'),
projectName = projectPath[projectPath.length - 1],
aliasTasks = getAliasTasks(),
allTasks = Object.keys(grunt.task._tasks),
basicTasks = grunt.util._.difference(allTasks, aliasTasks);
var server = http.createServer(function (request, response) {
response.writeHead(404);
response.end();
});
// TODO: update this
var projectPort = 61750;
portscanner.findAPortNotInUse(projectPort, projectPort + 4, 'localhost', function (error, port) {
projectPort = port;
if (projectPort) {
server.listen(port, function () {
grunt.log.ok("Grunt Devtools v" + version + " is ready! Proceed to the Chrome extension.");
});
} else {
grunt.fail.warn("You're running too many Grunt Devtools, please close one.");
}
});
var wsServer = new WebSocketServer({
httpServer: server,
autoAcceptConnections: false
});
wsServer.on('request', function (request) {
var key = request.key;
var connection = request.accept('echo-protocol', request.origin);
connection.on('message', function (message) {
if (message.type === 'utf8') {
var msg = message.utf8Data;
try {
msg = JSON.parse(message.utf8Data);
} catch (e) {
}
if (msg.action) {
if (msg.action === 'killTask') {
workers.forEach(function (worker) {
if (worker.pid === msg.task.pid) {
connection.send(worker.pid + '|' + 'Task Killed: ' + msg.task.name);
worker.kill();
}
});
}
} else {
var cmd = msg.split(' ');
// For colorized version we don't need -no-color option
// cmd.push('-no-color');
if (cmd[0] === 'handleSocketOpen') {
connection.sendUTF(JSON.stringify({
tasks: basicTasks,
alias: aliasTasks,
project: projectName,
port: projectPort,
devtoolsVersion: version
}));
}
else if (allTasks.indexOf(cmd[0]) > -1) {
var watcher = spawn('grunt', cmd);
watcher.key = key;
workers.push(watcher);
connection.sendUTF(JSON.stringify({
action: 'start',
name: cmd[0],
pid: watcher.pid
}));
// TODO: fix bug here with running task return
connection.send('Running Task: ' + cmd[0]);
watcher.stdout.on('data', function (data) {
if (data) {
connection.send(watcher.pid + '|' + data.toString());
grunt.log.writeln().write(data.toString());
}
});
watcher.stdout.on('end', function (data) {
if (data) {
connection.send(watcher.pid + '|' + data.toString());
grunt.log.writeln().write(data.toString());
}
connection.sendUTF(JSON.stringify({ action: 'done', pid: watcher.pid }));
});
watcher.stderr.on('data', function (data) {
if (data) {
connection.send(watcher.pid + '|' + data.toString());
grunt.log.writeln().write(data.toString());
}
});
watcher.on('exit', function (code) {
if (code !== 0) {
connection.send(watcher.pid + '|' + 'Process Exited with code: ' + code);
}
});
}
}
}
});
connection.on('close', function () {
killWorkers(key);
});
});
/**
* Clean up child processes
*/
var killWorkers = function (key) {
workers.forEach(function (worker) {
if (key) {
if (worker.key === key) {
worker.kill();
}
} else {
process.kill(worker);
}
});
if (!key) {
process.exit();
}
};
process.on("uncaughtException", killWorkers);
process.on("SIGINT", killWorkers);
process.on("SIGTERM", killWorkers);
// TODO: move this later please
/**
* Get sidebar list for section from Home.md
*/
function getAliasTasks() {
var l,
aliasTasks = [];
var gruntFile = 'Gruntfile.js',
gruntFileCoffee = 'Gruntfile.coffee';
// check if Gruntfile.coffee
if (grunt.file.exists(gruntFileCoffee)) {
gruntFile = gruntFileCoffee;
}
// make sure Gruntfile exists, otherwise exit
if (grunt.file.exists(gruntFile)) {
// TODO: add grunt read file here?
var lines = fs.readFileSync(gruntFile).toString().split('\n');
for (l in lines) {
var line = lines[l].replace(/ /g, '');
if (line.indexOf('grunt.registerTask') === 0) {
aliasTasks.push(line.split(/'/)[1]);
}
}
} else {
grunt.fail.warn('Cannot find Gruntfile.js or Gruntfile.coffee');
}
return aliasTasks;
}
});
if (!room) {
res.redirect('/404');
return;
}
res.render('room.hbs', {'roomId': roomId});
});
app.get('/404', function (req, res) {
res.render('404.hbs');
});
app.use(express.static(__dirname + '/static'));
ws.on('request', function (req, res) {
var connection = req.accept('echo-protocol', req.origin);
connection.on('message', connectionOnMessage);
connection.on('close', connectionOnClose);
});
function connectionOnMessage(evt) {
var msg = JSON.parse(evt.utf8Data);
if (msg['getPeerType']) {
var roomId = msg.roomId;
var room = rooms[roomId];
if (!room) {
return;
}
this['roomId'] = roomId;
room.addConnection(this);
dispRoomStatuses();
return;