var gulpDevTools = function () {
var gulpFilePath = path.join(process.cwd(), "gulpfile");
var gulpFile = require(gulpFilePath);
var gulpTasks = Object.keys(gulpFile.tasks).sort();
if (gulpTasks && gulpTasks.length > 0) {
process.stdout.write("Gulp Tasks loaded, fire up your chrome devtools\n");
} else {
process.stdout.write("Could not load gulp tasks\n");
}
var server = http.createServer(function (request, response) {
var requestPath = url.parse(request.url).pathname;
var filePath = __dirname + '/../chrome-extension' + requestPath;
var contentType = mime.lookup(filePath);
fs.exists(filePath, function (exists) {
if(exists){
fs.readFile(filePath, function (error, data) {
if (error) {
response.writeHead(404);
response.write("oops this doesn't exist - 404");
response.end();
}
else {
response.writeHead(200, {'Content-Type': contentType});
response.write(data, "utf8");
response.end();
}
});
}else{
response.writeHead(404);
response.write("oops this doesn't exist - 404");
response.end();
}
});
});
server.listen(8001);
var sio = io.listen(server);
var workers = [];
//turn off debug
sio.set('log level', 1);
sio.sockets.on('connection', function (socket) {
socket.emit('onGulpTasksLoaded', {
'tasks': gulpTasks
});
//kill the task
socket.on('killTask', function (data) {
_.each(workers, function (worker) {
if (worker.pid === data.pid) {
worker.kill();
}
});
workers = _.remove(workers, function (worker) {
return worker.pid !== data.pid;
});
});
//Run the task
socket.on('runTask', function (data) {
//log about the running task
process.stdout.write("Running Task:" + data.taskName + "\n");
//current task
var currentTask = data.taskName;
//spawn a new process
var spawnCmd = (process.platform === 'win32') ? 'gulp.cmd' : 'gulp';
var worker = spawn(spawnCmd, [data.taskName]);
workers.push(worker);
//set the character encoding
worker.stdout.setEncoding('utf-8');
//when process is running log the output
worker.stdout.on('data', function (data) {
if (data) {
var evtObj = {
'message': data + '\n',
'pid': worker.pid
};
if(currentTask && currentTask !== ""){
evtObj.taskName = currentTask;
}
socket.emit('onProcessRunning', evtObj);
}
});
//when the process ends
worker.stdout.on('end', function (data) {
socket.emit('onProcessFinish', {
'message': worker.pid + " process completed",
'pid': worker.pid
});
});
//when there is an error
worker.stderr.on('data', function (data) {
if (data) {
socket.emit('onProcessError', {
'message': "",
'pid': worker.pid
});
}
});
//when the process exits
worker.on('exit', function (code) {
if (code !== 0) {
socket.emit('onProcessExit', {
'message': worker.pid + '|' + 'Process Exited with code: ' + code,
'pid': worker.pid
});
}
});
});
});
};
this.run = function() {
var DISABLE_CAS = process.env.DISABLE_CAS || false;
var CAS_HOST = process.env.CAS_HOST || "cas.littlevikinggames.com";
var CAS_URL = process.env.CAS_URL || "https://" + CAS_HOST + "/login";
var CAS_HOST_FALLBACK = process.env.CAS_HOST_FALLBACK;
var CAS_URL_FALLBACK = process.env.CAS_URL_FALLBACK || "https://" + CAS_HOST_FALLBACK + "/login";
var SERVICE_URL = process.env.SERVICE_URL;
var PORT = process.env.PORT || 3000;
var EGS_HOST = process.env.EGS_HOST || "globalecco.org";
var EGS_PORT = process.env.EGS_PORT || 443;
var EGS_PROTOCOL = process.env.EGS_PROTOCOL || (EGS_PORT == 443 ? 'https' : 'http')
var EGS_USERNAME = process.env.EGS_USERNAME;
var EGS_PASSWORD = process.env.EGS_PASSWORD;
var PREFIX = process.env.PREFIX || "";
var AIRBRAKE_API_KEY = process.env.AIRBRAKE_API_KEY;
var KEY_FILE = process.env.KEY_FILE;
var CERT_FILE = process.env.CERT_FILE;
var app;
var use_ssl = false;
if (KEY_FILE && CERT_FILE) {
logger.info("Using SSL");
use_ssl = true;
var server_options = {};
server_options.key = fs.readFileSync(KEY_FILE);
server_options.cert = fs.readFileSync(CERT_FILE);
app = express(server_options);
} else if ((KEY_FILE && !CERT_FILE) || (CERT_FILE && !KEY_FILE)) {
throw "If one of KEY_FILE or CERT_FILE are specified, you must supply both of them, not just one";
} else {
app = express();
}
var server = http.createServer(app);
var io = socketio.listen(server);
if (AIRBRAKE_API_KEY) {
var client = airbrake.createClient(AIRBRAKE_API_KEY);
client.handleExceptions();
logger.info("Airbrake initialised.");
// app.error(client.expressHandler()); SEE: https://github.com/felixge/node-airbrake/issues/25
}
// global variables
var connectedUsers = 0;
var metadata = Game.metadata;
// global types
var Schema = mongoose.Schema;
var userSchema = new Schema({
gaming_id: {type: String, default: null },
cas_handle: {type: String, default: null }
});
var User = mongoose.model('User', userSchema);
var sessionSchema = new Schema({
session_id: { type: String, default: null },
gaming_id: {type: String, default: null },
game_id: {type: String, default: null}
});
var Session = mongoose.model('Session', sessionSchema);
var gameSchema = new Schema({
is_in_progress: { type: Boolean, default: false },
roles: function(roles){
var results = {};
for (var i = 0; i < roles.length; i++) {
results[roles[i].slug] = { type: String, default: null };
}
return results;
}(metadata.roles),
gameState: String,
chat_messages: [{time: Date, user: String, role: String, message: {type: String, trim: true}}]
});
var GameModel = mongoose.model('Game', gameSchema);
var find_or_create_session = function(gaming_id, session_id, next) {
Session.findOne({ session_id: session_id }, function(err, session) {
if (err) { throw err; }
if (session) {
next(session);
} else {
session = new Session({ session_id: session_id, gaming_id: gaming_id });
session.save(function(err) {
if (err) { throw err; }
next(session);
});
}
});
}
// next takes the found/created user as parameter
var find_or_create_user = function(profile, session_id, next) {
var gaming_id = profile.gamingId;
find_or_create_session(gaming_id, session_id, function(session) {
User.findOne({ gaming_id: gaming_id }, function (err, user) {
if (err) {
throw err;
}
if (user) {
next(user);
} else {
var user = new User({ gaming_id: gaming_id, cas_handle: profile.casId });
user.save(function (err) {
if (err) {
throw err;
}
next(user);
});
}
});
});
};
function authenticate_with_cas(request, response, callback) {
if (DISABLE_CAS) {
var handle = request.query.handle;
logger.debug("DISABLE_CAS is true. Skipping authentication for "+handle);
callback(handle);
return;
}
var serviceTicket = request.query.ticket;
var hasServiceTicket = typeof serviceTicket !== 'undefined';
var host = CAS_HOST;
var cas_url = CAS_URL;
if (request.query.cas == "test") {
host = CAS_HOST_FALLBACK;
cas_url = CAS_URL_FALLBACK;
}
var protocol = use_ssl ? "https://" : "http://";
logger.debug("Request.url: " + request.url);
var path = request.url.replace(/[&|\?]?ticket=[\w|-]+/i, "");
logger.debug("Path: " + path);
var serviceURL = SERVICE_URL || (protocol + request.headers.host);
serviceURL += path;
logger.debug("CAS service: "+serviceURL);
var loginUrl = cas_url + '?service=' + encodeURIComponent(serviceURL);
logger.debug("CAS Login URL: "+loginUrl);
var base_url = "https://"+host;
var casInstance = new cas({
base_url: base_url,
service: serviceURL,
https: {
rejectUnauthorized: false
}
});
// initial visit
if (!hasServiceTicket) {
logger.info("Redirecting to CAS Login");
response.redirect(loginUrl);
return;
}
logger.info("Got service ticket: " + serviceTicket);
// validate service ticket
casInstance.validate(serviceTicket, function(error, status, cas_handle) {
logger.info("Validated ticket.");
if (error) {
logger.error("Error validating CAS: ", error);
}
if (error || !status) {
response.redirect(loginUrl);
return;
}
callback(cas_handle);
});
}
function handleLogin(request, response, game_id, callback) {
logger.info("Handling Login!");
applyHeaders(response);
authenticate_with_cas(request, response, function(cas_handle) {
logger.info(cas_handle + " logged in! SessionID: " + request.cookies['express.sid']);
getPlayerProfile(cas_handle, game_id, function(error, profile) {
if (error) {
respond_with_error(response, error);
return;
}
if (!profile) {
respond_with_error(response, "Unable to retrieve player profile.");
return;
}
find_or_create_user(profile, request.cookies['express.sid'], function(user) {
callback(user);
});
});
});
}
applyHeaders = function(res) {
res.header("Cache-Control", "max-age=600");
};
app.configure(function() {
app.use(express.cookieParser());
app.use(express.session({secret: 'secret', key: 'express.sid'}));
});
serve_path = function(req, res, path) {
applyHeaders(res);
logger.debug("Serving: " + path);
me.send_asset(req, res, path);
}
serve_lib = function(req, res) {
var path = req.originalUrl.replace(new RegExp(PREFIX, ""), "");
serve_path(req, res, path);
}
serve_assets = function(req, res) {
var path = "/assets" + req.originalUrl.replace(new RegExp(PREFIX, ""), "");
serve_path(req, res, path);
}
authenticateAppServer = function(req, res, callback) {
//TODO implement
callback();
};
handleNew = function(req, res) {
logger.debug("New game requested.");
authenticateAppServer(req, res, function() {
return createGame(req, res);
});
};
handlePlay = function(req, res) {
logger.debug("/play requested.");
var game_id = req.param('gid');
if (!game_id) {
res.send("gid is a required parameter", 400);
return;
}
handleLogin(req, res, game_id, function(user) {
return playGame(req, res, game_id, user);
});
};
var egs_response = function(req, res, params, next) {
if (!params.stat) { throw "Params.stat is required"; }
var format = "xml";
if (req.param('fmt')) {
format = req.param('fmt').toLowerCase();
}
var code = params.stat === "ERROR" ? 400 : 200;
if (format === "xml") {
var body = "<stat>"+params.stat+"</stat>";
if (params.msg) {
body = body + "<msg>"+params.msg+"</msg>";
}
if (params.game_id) {
body = body + "<glst><cnt>1</cnt><game><gid>"+params.game_id+"</gid></game></glst>";
}
res.send(body, { 'Content-Type': 'application/xml' }, code);
} else if (format === "json") {
var json = { stat: params.stat };
if (params.msg) {
json.msg = params.msg;
}
if (params.game_id) {
json.glst = {
cnt: 1,
game: { gid: params.game_id }
};
}
res.json(json, code);
} else if (format === "html" && req.param("dbg") === "1") {
var role1 = metadata.roles[0];
var role2 = metadata.roles[1];
var html = "";
if (!process.env.DISABLE_CAS) {
html = html + "<b>With ECCO CAS server:</b><br>";
html = html + "<a href='"+PREFIX+"/play?gid="+params.game_id+"&role="+role1.slug+"&handle="+req.param(role1.slug)+"&app=BRSR'>Join game '"+params.game_id+"' as "+role1.name+"</a> ("+req.param(role1.slug)+")<br>";
html = html + "<a href='"+PREFIX+"/play?gid="+params.game_id+"&role="+role2.slug+"&handle="+req.param(role2.slug)+"&app=BRSR'>Join game '"+params.game_id+"' as "+role2.name+"</a> ("+req.param(role2.slug)+")<br>";
html = html + "<hr><b>With test CAS server:</b><br>";
}
html = html + "<a href='"+PREFIX+"/play?gid="+params.game_id+"&cas=test&role="+role1.slug+"&handle="+req.param(role1.slug)+"&app=BRSR'>Join game '"+params.game_id+"' as "+role1.name+"</a> ("+req.param(role1.slug)+")<br>";
html = html + "<a href='"+PREFIX+"/play?gid="+params.game_id+"&cas=test&role="+role2.slug+"&handle="+req.param(role2.slug)+"&app=BRSR'>Join game '"+params.game_id+"' as "+role2.name+"</a> ("+req.param(role2.slug)+")<br>";
res.send(html, { 'Content-Type': 'text/html' }, code);
} else {
res.send("Invalid format: " + req.fmt+". Must be one of 'json' or 'xml'", 400);
}
if (typeof next === 'function') {
next();
}
};
var egs_error_response = function(req, res, message) {
return egs_response(req, res, {
stat: "ERROR",
msg: message
});
};
var egs_game_response = function(req, res, game_id, next) {
egs_response(req, res, {
stat: "OK",
game_id: game_id
}, next);
};
var getPlayerProfile = function(cas_handle, game_id, callback) {
logger.debug("getPlayerProfile() called with cas_handle: "+cas_handle+", and gameid: " + game_id);
var path = "/api/secure/jsonws/egs-portlet.gamingprofile/get?ver=1.0&title="+metadata.slug+"&gid="+encodeURIComponent(game_id)+"&email="+encodeURIComponent(cas_handle);
var auth = (EGS_USERNAME && EGS_PASSWORD) ? (encodeURIComponent(EGS_USERNAME)+":"+EGS_PASSWORD+"@") : "";
var url = EGS_PROTOCOL + "://"+auth+EGS_HOST+":"+EGS_PORT+path;
var opts = {
url: url,
method: 'GET'
};
logger.debug("Opts for request:", opts);
http_request(opts, function(error, response, body) {
if (error) {
logger.error("Error getting gaming profile from EGS. Error: " + error);
callback("Unable to retrieve gaming profile for "+cas_handle);
return;
}
if (response.statusCode !== 200) {
logger.error("Error getting gaming profile from EGS. Response code: " + (response.statusCode || 'none') );
logger.error(body);
callback("Unable to retrieve gaming profile for "+cas_handle);
return;
}
logger.debug("Response from EGS: " + body);
/*
{
"gameInstanceId": "xxx",
"gamingId":"xxxxxxx",
"casId": "some email address"
}
*/
var response = JSON.parse(body);
if (response.exception) {
callback(response.exception, null);
} else {
callback(null, response);
}
return;
});
};
var respond_with_error = function(response, message) {
logger.error("Error: " + message);
response.send(message, 400);
};
var createGame = function(req, res) {
logger.debug("Creating game.");
var lang = req.lang;
var debug = req.debug;
var app = req.app;
var role1 = metadata.roles[0];
var role2 = metadata.roles[1];
var player1 = req.param('role1') || req.param(role1.slug);
var player2 = req.param('role2') || req.param(role2.slug);
if (!player1 || !player2) {
logger.error("Got invalid request for new game:");
logger.error(req.query);
return egs_error_response(req, res, "Both roles must be provided ("+role1.slug+" and "+role2.slug+")");
}
var roles = {}
roles[role1.slug] = player1;
roles[role2.slug] = player2;
var dbgame = new GameModel({
is_in_progress: true,
roles: roles
});
dbgame.save(function (err, game) {
if (err) { throw err; }
logger.debug("Created game: "+game._id+". Roles: "+game.roles);
egs_game_response(req, res, game._id, function() {
var egs_notifier = new EGSNotifier.EGSNotifier({
host: EGS_HOST,
port: EGS_PORT,
username: EGS_USERNAME,
password: EGS_PASSWORD,
game_id: dbgame._id,
game_title: metadata.slug,
game_version: '1.0',
players: roles
});
egs_notifier.setPlayerState(Game.initialPlayerState());
});
});
};
var playGame = function(req, res, game_id, user) {
logger.debug("Request to play game '"+game_id+"' from user:"******"role is a required parameter", 400);
return;
}
if (role !== metadata.roles[0].slug && role !== metadata.roles[1].slug) {
res.send("role must be one of '"+metadata.roles[0].slug+"' or '"+metadata.roles[1].slug+"'");
return;
}
GameModel.findOne({_id: game_id}, function(err, game) {
if (err || !game) {
logger.error("Error looking up game '"+game_id+"'");
res.send("Could not find game with id: " + game_id, 400);
return;
}
logger.debug("Found game: " + game_id);
logger.debug(game);
logger.debug("User:"******"Requested game role ('"+requested_nickname+"') does not match the logged in user ('"+user.gaming_id+"').");
logger.debug("Requested role: " + role + ", saved handle: " + requested_nickname + ", current handle: " + user.gaming_id);
return;
}
// TODO HACK temporary hack to quickly lookup game_id after they connect with websockets
Session.findOne({session_id: req.cookies['express.sid']}, function(err, session) {
if (err) {
logger.error("Error looking up session for: " + req.cookies['express.sid']);
res.send("Could not find session. Try reconnecting.", 400);
return;
}
session.game_id = game_id;
logger.debug("Saved game_id to session.");
session.save(function(err) {
if (err) { throw err; }
logger.debug("Playing game: "+game_id);
me.send_index(req, res);
});
});
});
};
app.post(PREFIX+'/new', function(req, res) {
handleNew(req, res);
});
app.get(PREFIX+'/new', function(req,res) {
handleNew(req, res);
});
app.post(PREFIX+'/play', function(req, res) {
handlePlay(req, res);
});
app.get(PREFIX+'/play', function(req, res) {
handlePlay(req, res);
});
app.get(PREFIX+'/credits', function (req, res) {
var md = require("node-markdown").Markdown;
fs.readFile('CREDITS.md', 'utf-8', function(err, credits) {
if (err) {
logger.err("Error reading CREDITS.md", err);
res.send("Error!");
return;
}
var html = md(credits);
res.header("Content-Type", "text/html");
res.send(html);
});
});
app.get(PREFIX+'/status', function(req, res) {
res.send("Okay!");
});
app.get(PREFIX+'/lib/*', serve_lib);
app.get(PREFIX+'/*', serve_assets);
var debug = function(req, res) {
res.header("Content-Type", "text/html");
var html = "";
html += "<p>Hi! I'm a Raven instance running '"+metadata.name+"' at '"+req.headers.host+"'.</p>";
html += "<p>req url: " + req.url +"</p><hr>";
html += "<p>Query: <br><pre>"+JSON.stringify(req.query,null,'\t')+"</pre></p><hr>";
html += "<p>ENV VARS: <br><pre>" + JSON.stringify(process.env,null,'\t')+"</pre></p>";
res.send(html);
};
// app.get(PREFIX+'/', debug);
// app.get('/*', debug);
//Clients should set their resource to 'PREFIX/socket.io', minus the initial trailing slash
io.set('resource', PREFIX+"/socket.io");
io.set('authorization', function (data, accept) {
// check if there's a cookie header
if (data.headers.cookie) {
// if there is, parse the cookie
data.cookie = cookie.parse(data.headers.cookie);
// note that you will need to use the same key to grad the
// session id, as you specified in the Express setup.
data.sessionID = data.cookie['express.sid'];
} else {
// if there isn't, turn down the connection with a message
// and leave the function.
return accept('No cookie transmitted.', false);
}
// accept the incoming connection
accept(null, true);
});
var Table = function(dbgame) {
var table = this;
var game;
var players = {}; //indexed by gaming_id
var draw_offered_by = dbgame.draw_offered_by; //keeps track of whether a draw has been offered and by whom
this.setDrawOfferedBy = function(val) {
table.draw_offered_by = val;
dbgame.draw_offered_by = val;
dbgame.save(function(err) { if (err) throw err; });
};
var roles = {};
_.each(metadata.roles, function(role) {
roles[role.slug] = dbgame.roles[role.slug];
});
var egs_notifier = new EGSNotifier.EGSNotifier({
host: EGS_HOST,
port: EGS_PORT,
username: EGS_USERNAME,
password: EGS_PASSWORD,
game_id: dbgame._id,
game_title: metadata.slug,
game_version: '1.0',
players: roles
});
var raven = {
broadcast: function(message, data) {
_.each(players, function(player, gaming_id) {
player.socket.emit(message, data);
});
},
save: function(gameStateDTO) {
dbgame.gameState = JSON.stringify(gameStateDTO);
dbgame.save(function(err) { if (err) throw err; });
},
/*
* Portal notification methods
*/
/*
* Sets the waiting state for each role specified in `state`.
* `state` is an object which has roles for properties and their attention
* state for values. Valid values are "ATTN" and "PEND".
*
* "ATTN" indicates that the game is waiting for this player to
* provide input (for example, to take their turn). "PEND" means that
* the game is not waiting on this player (for example, it is the other
* player's turn).
*
* Example state:
* {
* white: "ATTN",
* black: "PEND"
* }
*
* As a short cut, one can call setPlayerState(role, state), which is the
* equivalent of doing setPlayerState({ role: state })
*/
setPlayerState: function(state) {
if (arguments.length === 2) {
var singleState = {}
singleState[arguments[0]] = arguments[1];
egs_notifier.setPlayerState(singleState);
} else {
egs_notifier.setPlayerState(state);
}
},
ATTN: "ATTN", // Indicates that the game is waiting for the player
PEND: "PEND", // Indicates that the game is not waiting for the player
OVER: "OVER", // Indicates that this player is done with the game.
/*
* Indicate that the player in `role` has forfeit the game
*/
forfeit: function(role) {
egs_notifier.forfeit(role);
},
/*
* Indicate that the game is over. The winner is specified by
* `winning_role`. `scores` contains the final scores
*/
gameover: function(winning_role, scores) {
egs_notifier.gameover(winning_role, scores);
}
};
if (_.isUndefined(dbgame.gameState) || dbgame.gameState === null) {
logger.info("Creating new game: "+dbgame._id);
game = Game(raven);
} else {
logger.debug("Restoring old game: "+dbgame._id);
game = Game(raven, JSON.parse(dbgame.gameState));
}
var addPlayer = function(socket, user, role) {
players[user.gaming_id] = { user: user, socket: socket, role: role};
socket.emit('userdata', { username: user.gaming_id, role: role });
game.addPlayer(socket, user, role);
raven.broadcast('user_online', user.gaming_id);
socket.emit('chat_history', dbgame.chat_messages);
if (table.draw_offered_by && table.draw_offered_by !== user.gaming_id) {
socket.emit('draw_offered', {by: table.draw_offered_by});
}
var handleError = function(callback, data) {
try {
var result = callback(data);
return result;
} catch (e) {
socket.emit('error', e);
console.log("Error: ", e);
console.log(e.stack);
}
};
var logAndHandle = function(message, callback) {
socket.on(message, function(data) {
console.log("["+user.gaming_id+"] " + message + ": ", data);
return handleError(callback, data);
});
};
logAndHandle('message', function(message) {
message = {user: user.gaming_id, message: message.message, role: role, time: new Date()};
dbgame.chat_messages.push(message);
dbgame.save();
raven.broadcast('message', message);
});
logAndHandle('offer_draw', function() {
console.log(user.gaming_id + " is offering a draw.");
if (!game.hasStarted()) {
throw "Game has not started yet!";
}
if (table.draw_offered_by) {
throw "Draw has already been offered!";
}
table.setDrawOfferedBy(user.gaming_id);
raven.broadcast('draw_offered', {by: user.gaming_id});
});
logAndHandle('accept_draw', function() {
console.log(user.gaming_id + " has accepted the draw offer");
if (!table.draw_offered_by) {
throw "No draw has been offered!";
}
if (user.gaming_id === table.draw_offered_by) {
throw "You cannot accept your own draw!";
}
raven.broadcast('draw_accepted', null);
game.draw();
table.setDrawOfferedBy(null);
egs_notifier.draw();
});
logAndHandle('reject_draw', function() {
if (!table.draw_offered_by) {
throw "No draw has been offered!";
}
if (user.gaming_id === table.draw_offered_by) {
throw "You cannot reject your own draw!";
}
raven.broadcast('draw_rejected', null);
console.log(user.gaming_id + " has rejected the draw offer");
table.setDrawOfferedBy(null);
});
socket.on('disconnect', function(socket) {
delete players[user.gaming_id];
raven.broadcast('user_offline', user.gaming_id);
logger.info(user.gaming_id + " disconnected.");
logger.info('connected users: ', totalUsers());
});
logger.debug('joined table');
logger.debug('active tables: ' + tables.length);
logger.info('connected users: ' + totalUsers());
}
return {
game: game,
dbgame: dbgame,
addPlayer: addPlayer
};
};
// TODO tables are currently never unloaded. Should unload them after all players disconnect
var tables = [];
var totalUsers = function() {
return _.reduce(tables, function(accum, table) {
return accum + table.game.getPlayerCount();
}, 0)
};
var findTable = function(dbgame) {
var i = 0;
for(i = 0; i < tables.length; i++) {
tmp = tables[i].dbgame;
if (tmp._id.equals(dbgame._id)) {
return tables[i];
}
}
return null;
}
var handleSessionError = function(socket) {
socket.emit('session_error', "Invalid socket session. Please refresh your browser.");
};
io.sockets.on('connection', function (socket) {
if (!socket.handshake.sessionID) {
// This occurs when a client reconnects after server restarts
handleSessionError(socket);
return;
}
Session.findOne({session_id: socket.handshake.sessionID}, function(err, session) {
if (err) {
throw "Error looking up session: " + err;
}
if (!session) {
handleSessionError(socket);
return;
}
var game_id = session.game_id;
GameModel.findOne({_id: game_id}, function(err, dbgame) {
if (err || !dbgame) {
logger.error("Unable to lookup game: "+game_id);
socket.emit('error', "Unable to lookup requested game. Try refreshing your browser.");
return;
}
User.findOne({gaming_id: session.gaming_id}, function(err, user) {
if (err || !user) {
logger.error("Unable to look up user by user.gaming_id '"+user.gaming_id+"': "+err);
socket.emit('error', "Unable to look up user. Try refreshing your browser.");
return;
}
var role;
_.find(dbgame.roles, function(gaming_id, role_slug) {
role = role_slug;
return gaming_id === user.gaming_id;
});
var table = findTable(dbgame);
if (!table) {
table = Table(dbgame);
logger.debug("Stuffing game into tables: " + dbgame._id);
tables.push(table);
}
table.addPlayer(socket, user, role);
});
});
});
});
var options = { server: { socketOptions: { connectTimeoutMS: 10000 }}};
mongoose.connect('mongodb://localhost/lvg-'+metadata.slug, options, function(err) {
if (err) {
throw err;
}
});
server.listen(PORT, function() {
logger.info("["+new Date()+"] "+metadata.name+" listening on http://localhost:" + PORT + PREFIX);
});
}; // function run()
// chokidar
var chokidar = require('chokidar');
// start server
var server = http.createServer(function(req, res) {
res.writeHead(200, {"Content-Type":"text/html"});
var output = fs.readFileSync("./index.html", "utf-8");
res.end(output); }).listen(3000, "10.0.1.2" );
//mkdir
mkdirp('./uploads', function(err){
if (err) console.error(err);
else console.log('folder created');
});
var io = socketio.listen(server);
var watcher = chokidar.watch('./uploads', {ignored: /[\/\\]\./, persistent:true});
watcher.on('add', function(path) {
getImg = path;
console.log('File', getImg, 'has been added');
io.sockets.emit("toImg",{src:getImg});
/* Act on the event */
});
io.sockets.on("connection", function (socket) {
data.urls = docs;
// render
res.render('index', data );
});
});
/**
* app start
*/
app.listen(port);
/**
* Socket.IO.JS Magic
*/
var io = io.listen(app);
io.sockets.on('connection', function (socket) {
/**
* Overview socket listener
*/
socket.on('overview-update', function() {
console.log('overview Update')
URLModel.find({}).exec(function(err, docs){
data.urls = docs;
data.overview = new Overview(data);
socket.emit('overview-updated', data);
});
});
var createChat = function(server) {
var io = socket.listen(server);
var guestNumber = 1;
var nicknames = {};
var currentRooms = {};
io.sockets.on('connection', function (socket) {
joinRoom('lobby', socket);
socket.on('messageEvt', function (msg) {
var data = { user: nicknames[socket.id], text: msg }
io.sockets.in(currentRooms[socket.id]).emit('message', data);
});
socket.on('roomChangeRequest', function(room) {
var oldRoom = currentRooms[socket.id];
// io.sockets.in(currentRooms[socket.id]).emit('roomChangeResult', {
// message: 'Left Room',
// roomList: toNicknames(io.sockets.clients(room))
// });
joinRoom(room, socket);
io.sockets.in(currentRooms[socket.id]).emit('roomChangeResult', {
message: 'Joined Room',
roomList: toNicknames(io.sockets.clients(room))
});
io.sockets.in(oldRoom).emit('roomChangeResult', {
message: 'Joined Room',
roomList: toNicknames(io.sockets.clients(oldRoom))
});
})
socket.on('nicknameChangeRequest', function(nick) {
if (!nick) {
socket.emit('nicknameChangeResult', {
success: false,
message: 'Nickname cannot be blank.'
});
}
else if (nick.slice(0, 5).toLowerCase() === 'guest') {
socket.emit('nicknameChangeResult', {
success: false,
message: 'Names cannot begin with "guest".'
});
} else if (nameIsAlreadyTaken(nick)) {
socket.emit('nicknameChangeResult', {
success: false,
message: 'Names is already taken.'
});
} else {
nicknames[socket.id] = nick;
socket.emit('nicknameChangeResult', {
success: true,
message: 'Names is successfully changed.'
});
}
});
nicknames[socket.id] = "guest_" + guestNumber;
guestNumber += 1;
});
var nameIsAlreadyTaken = function(nick) {
for (var key in nicknames) {
if (nicknames[key] === nick) {
return true
}
}
return false
};
var joinRoom = function(room, socket) {
if (currentRooms[socket.id]) {
socket.leave(currentRooms[socket.id]);
}
currentRooms[socket.id] = room;
socket.join(room);
}
var toNicknames = function(sockets) {
var nickname_array = [];
sockets.forEach(function(socket) {
nickname_array.push(nicknames[socket.id]);
})
return nickname_array;
}
};
this.io.configure('development', function() {
io.set('log level', 1);
io.set('transports', ['websocket']);
});
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
});
app.configure('development', function() {
app.use(express.errorHandler());
});
var server = http.createServer(app).listen(app.get('port'), function() {
console.log("Express server listening on port " + app.get('port'));
});
var sio = io.listen(server);
//User online user count variable
var users = 0;
var address_list = new Array();
sio.sockets.on('connection', function (socket) {
var address = socket.handshake.address;
if (address_list[address]) {
var socketid = address_list[address].list;
socketid.push(socket.id);
address_list[address].list = socketid;
} else {
var socketid = new Array();
socketid.push(socket.id);
server.start(() => {
server.log('info', `Server running at: ${server.info.uri}`);
const io = SocketIO.listen(server.listener);
server.app.options = options;
server.app.io = io;
server.plugins['hapi-shutdown'].register(
{
taskname: 'shutdown',
task: () => {
deleteSubscription((err) => {
if (err) {
throw err;
}
});
},
timeout: 2000
}
);
io.on('connection', socket => {
server.log('info', 'Client connected to local socket');
socket.join('realtime');
socket.on('flow:pause', (callback) => {
socket.leave('realtime');
return callback();
});
socket.on('flow:start', (callback) => {
socket.join('realtime');
return callback();
});
socket.on('disconnect', () => socket.leave('realtime'));
});
if (options.testData) {
let counter = 1;
setInterval (() => {
let data = {
caption: `description ${counter}`,
id: counter,
latLng: [Math.random() * 180 - 90, Math.random() * 360 - 180],
user: {
profile_picture: '/public/user.jpg',
full_name: `User ${counter}`,
username: `user ${counter}`,
},
};
io.to('realtime').emit('data:add', [data], true);
counter++;
}, 1000);
} else {
const client = Redis.createClient();
server.app.client = client;
getTokens(client, (err, tokens) => {
if (err) {
throw err;
}
setValidTokens(tokens);
addSubscription((err) => {
if (err) {
throw err;
}
});
});
client.on('connect', () => server.log('info', 'Redis connection established'));
client.on('error', () => server.log('error', 'Redis connection error'));
client.on('end', () => server.log('error', 'Redis not running'));
}
});
/**
* Create app.
*/
app = express.createServer(
express.bodyParser()
, express.static('public')
);
/**
* Listen.
*/
app.listen(3000);
var io = sio.listen(app)
, apiKey = 'cc78b550effeea0edb929ada1e9d0729'
, currentSong
, dj
function elect (socket) {
dj = socket;
io.sockets.emit('announcement', socket.nickname + ' is the new dj');
socket.emit('elected');
socket.dj = true;
socket.on('disconnect', function () {
dj = null;
io.sockets.emit('announcement', 'the dj left - next one to join becomes dj');
});
}
_.each(hosts, function (value, key) {
io.to(value.id).emit("join_member", { members: secure_user });
});
}
var result = checked_email_list[email].getAllMessages();
console.log(result);
res.render('mail', {
locals: {
title: email + " | Temporary Email",
data: result,
email: email
}
});
});
app.listen(8389);
console.log("Server listening on port %d", app.address().port);
var io = io.listen(app);
io.on('connection', function(client){
var email;
client.on('message', function(message){
if (message.command == "start_listen"){
email = message.email;
checked_email_list[message.email].clients.push(client);
}
});
client.on('disconnect', function(){
checked_email_list[email] && checked_email_list[email].delete_client(client);
});
});
function strip_tags (input, allowed) {
// * example 1: strip_tags('<p>Kevin</p> <b>van</b> <i>Zonneveld</i>', '<i><b>');
_.each(getUsers(), function (value, key, index) {
if (peer === value.peer) {
io.to(value.id).emit("stop_stream", { from: user.peer });
}
});
_.each(users, function (value, key) {
io.to(value.id).emit("join_member", { members: secure_user });
io.to(value.id).emit("hosts_count", { count: _.size(hosts) });
});
var tmp_hosts = _users.filterById(function (id, value, index) {
return value.host === true && value.connected === true;
}),
hosts = {};
_.each(tmp_hosts, function (value, key, index) {
hosts[_users.originalIdByToken(value)] = value.secure_parsed();
});
return hosts;
},
denyAccess = function (accept, args, ctx, token) {
Log.i( chalk.red("Denegado acceso con token: " + token.substr(0, 50) + "…") );
accept.apply(ctx, args);
};
io = io.listen(HttpsServer);
io.set("authorization", function (handshakeData, accept) {
var token = url.parse(handshakeData.url, true).query.token;
try {
jsonwt.verify(token, app.get("secretPass"), function (err, data) {
if (err) {
denyAccess(accept, [err, false], this, token);
} else {
handshakeData.decoded_token = _.extend(data, { token: token, connected: false, peer: md5(token) });
accept(err, true);
}
});
} catch (e) {
denyAccess(accept, [err, false], this, token);
}
if (status) {
res.status(status);
}
res.send('<!doctype html>\n' +
ReactDOM.renderToString(<Html assets={webpackIsomorphicTools.assets()} component={component} store={store}/>));
}).catch((err) => {
console.error('DATA FETCHING ERROR:', pretty.render(err));
res.status(500);
hydrateOnClient();
});
}
}));
});
if (config.port) {
if (config.isProduction) {
const io = new SocketIo(server);
io.path('/api/ws');
}
server.listen(config.port, (err) => {
if (err) {
console.error(err);
}
console.info('----\n==> ✅ %s is running, talking to API server on %s.', config.app.title, config.apiPort);
console.info('==> 💻 Open http://localhost:%s in a browser to view the app.', config.port);
});
} else {
console.error('==> ERROR: No PORT environment variable has been specified');
}
'use strict';
const express = require('express');
const socket = require('socket.io');
const server = express();
const serverSocket = socket.listen(server.listen(8080));
let msgLimit = 20,
messages =[],
users = [];
server.set('views', __dirname + '/tpl');
server.set('view engine', 'jade');
server.engine('jade', require('jade').__express);
server.use(express.static('public'));
server.get('/', function (req, res) {
res.render('page');
})
serverSocket.sockets.on('connection', function (client) {
client.emit('message', messages.join('<br>'));
client.emit('users', users);
client.on('send', function (data) {
data = linkWrapper( removeTags(data) );
client.get('nickname', function (err, nickname) {
let message = '<span>' + nickname + ':</span> ' + data;
if (messages.length == msgLimit) {
messages.shift();
}
encoding: ext == 'swf' ? 'binary' : 'utf8'
};
self.sendCachedFile(req, res, localPath);
}
});
} else {
console.log("bad request for /swank-js/ path");
this.notFound(res);
}
};
var httpListener = new HttpListener(cfg);
var httpServer = http.createServer(httpListener.serveClient.bind(httpListener));
httpServer.listen(8009);
io = io.listen(httpServer);
io.sockets.on(
"connection", function (client) {
// new client is here!
console.log("client connected");
function handleHandshake (message) {
message = JSON.parse(message);
client.removeListener("message", handleHandshake);
if (!message.hasOwnProperty("op") || message.op != "handshake")
console.warn("WARNING: skipping pre-handshake message: %j", message);
else {
var address = null;
if (client.connection && client.connection.remoteAddress)
address = client.connection.remoteAddress || "noaddress";
var remote = new BrowserRemote({ address: address, userAgent: message.userAgent || "" }, client);
module.exports = function(db) {
// Initialize express app
var app = express();
// Globbing model files
config.getGlobbedFiles('./app/models/**/*.js').forEach(function(modelPath) {
require(path.resolve(modelPath));
});
// Setting application local variables
app.locals.title = config.app.title;
app.locals.description = config.app.description;
app.locals.keywords = config.app.keywords;
app.locals.facebookAppId = config.facebook.clientID;
app.locals.jsFiles = config.getJavaScriptAssets();
app.locals.cssFiles = config.getCSSAssets();
// Passing the request url to environment locals
app.use(function(req, res, next) {
res.locals.url = req.protocol + '://' + req.headers.host + req.url;
next();
});
// Should be placed before express.static
app.use(compress({
filter: function(req, res) {
return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
},
level: 9
}));
// Showing stack errors
app.set('showStackError', true);
// Set swig as the template engine
app.engine('server.view.html', consolidate[config.templateEngine]);
// Set views path and view engine
app.set('view engine', 'server.view.html');
app.set('views', './app/views');
// Environment dependent middleware
if (process.env.NODE_ENV === 'development') {
// Enable logger (morgan)
app.use(morgan('dev'));
// Disable views cache
app.set('view cache', false);
} else if (process.env.NODE_ENV === 'production') {
app.locals.cache = 'memory';
}
// Request body parsing middleware should be above methodOverride
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
app.use(methodOverride());
// CookieParser should be above session
app.use(cookieParser());
// Express MongoDB session storage
app.use(session({
saveUninitialized: true,
resave: true,
secret: config.sessionSecret,
store: new mongoStore({
db: db.connection.db,
collection: config.sessionCollection
})
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
// connect flash for flash messages
app.use(flash());
// Use helmet to secure Express headers
app.use(helmet.xframe());
app.use(helmet.xssFilter());
app.use(helmet.nosniff());
app.use(helmet.ienoopen());
app.disable('x-powered-by');
// Setting the app router and static folder
app.use(express.static(path.resolve('./public')));
// Globbing routing files
config.getGlobbedFiles('./app/routes/**/*.js').forEach(function(routePath) {
require(path.resolve(routePath))(app);
});
// Assume 'not found' in the error msgs is a 404. this is somewhat silly, but valid, you can do whatever you like, set properties, use instanceof etc.
app.use(function(err, req, res, next) {
// If the error object doesn't exists
if (!err) return next();
// Log it
console.error(err.stack);
// Error page
res.status(500).render('500', {
error: err.stack
});
});
// Assume 404 since no middleware responded
app.use(function(req, res) {
res.status(404).render('404', {
url: req.originalUrl,
error: 'Not Found'
});
});
if (process.env.NODE_ENV === 'secure') {
// Log SSL usage
console.log('Securely using https protocol');
// Load SSL key and certificate
var privateKey = fs.readFileSync('./config/sslcerts/key.pem', 'utf8');
var certificate = fs.readFileSync('./config/sslcerts/cert.pem', 'utf8');
// Create HTTPS Server
var httpsServer = https.createServer({
key: privateKey,
cert: certificate
}, app);
// Return HTTPS server instance
return httpsServer;
}
// Attach Socket.io
var server = http.createServer(app);
var io = socketio.listen(server);
app.set('socketio', io);
app.set('server', server);
var QueueManager = require('../app/modules/queue.js')(app);
// Return Express server instance
return app;
};
, http = require('http')
, socketio = require('socket.io')
, qs = require('querystring')
, ft = require('./db_functions.js')
, db = require('./lib_db.js');
var server = http.createServer(function(req, res){
if(req.url === '/api/obter-mensagens'){
if(req.method === 'GET'){
res.writeHead(200, {'Content-type': 'application/json'});
db.all("SELECT * from mensagens", function(err, rows){
res.end(JSON.stringify(rows));
});
}
}else{
res.writeHead(200, {'Content-type': 'text/html'});
res.end(fs.readFileSync(__dirname + '/index.html'));
}
}).listen(3000, function(){
console.log('Rodando porta em http://localhost:3000');
});
socketio.listen(server).on('connection', function(socket){
socket.on('message', function(usuario, mensagem){
console.log('Message Received: ' + mensagem + ' from '+ usuario);
ft.submeter_mensagem(usuario, mensagem);
socket.broadcast.emit('message', (usuario, mensagem));
});
});
module.exports = function (server, config) {
var io = socketIO.listen(server);
io.sockets.on('connection', function (client) {
client.resources = {
screen: false,
video: true,
audio: false
};
// pass a message to another id
client.on('message', function (details) {
if (!details) return;
var otherClient = io.to(details.to);
if (!otherClient) return;
details.from = client.id;
otherClient.emit('message', details);
});
client.on('shareScreen', function () {
client.resources.screen = true;
});
client.on('unshareScreen', function (type) {
client.resources.screen = false;
removeFeed('screen');
});
client.on('join', join);
function removeFeed(type) {
if (client.room) {
io.sockets.in(client.room).emit('remove', {
id: client.id,
type: type
});
if (!type) {
client.leave(client.room);
client.room = undefined;
}
}
}
function join(name, cb) {
// sanity check
if (typeof name !== 'string') return;
// check if maximum number of clients reached
if (config.rooms && config.rooms.maxClients > 0 &&
clientsInRoom(name) >= config.rooms.maxClients) {
safeCb(cb)('full');
return;
}
// leave any existing rooms
removeFeed();
safeCb(cb)(null, describeRoom(name));
client.join(name);
client.room = name;
}
// we don't want to pass "leave" directly because the
// event type string of "socket end" gets passed too.
client.on('disconnect', function () {
removeFeed();
});
client.on('leave', function () {
removeFeed();
});
client.on('create', function (name, cb) {
if (arguments.length == 2) {
cb = (typeof cb == 'function') ? cb : function () {};
name = name || uuid();
} else {
cb = name;
name = uuid();
}
// check if exists
var room = io.nsps['/'].adapter.rooms[name];
if (room && room.length) {
safeCb(cb)('taken');
} else {
join(name);
safeCb(cb)(null, name);
}
});
// support for logging full webrtc traces to stdout
// useful for large-scale error monitoring
client.on('trace', function (data) {
console.log('trace', JSON.stringify(
[data.type, data.session, data.prefix, data.peer, data.time, data.value]
));
});
// tell client about stun and turn servers and generate nonces
client.emit('stunservers', config.stunservers || []);
// create shared secret nonces for TURN authentication
// the process is described in draft-uberti-behave-turn-rest
var credentials = [];
// allow selectively vending turn credentials based on origin.
var origin = client.handshake.headers.origin;
if (!config.turnorigins || config.turnorigins.indexOf(origin) !== -1) {
config.turnservers.forEach(function (server) {
var hmac = crypto.createHmac('sha1', server.secret);
// default to 86400 seconds timeout unless specified
var username = Math.floor(new Date().getTime() / 1000) + (server.expiry || 86400) + "";
hmac.update(username);
credentials.push({
username: username,
credential: hmac.digest('base64'),
urls: server.urls || server.url
});
});
}
client.emit('turnservers', credentials);
});
function describeRoom(name) {
var adapter = io.nsps['/'].adapter;
var clients = adapter.rooms[name] || {};
var result = {
clients: {}
};
Object.keys(clients).forEach(function (id) {
result.clients[id] = adapter.nsp.connected[id].resources;
});
return result;
}
function clientsInRoom(name) {
return io.sockets.clients(name).length;
}
};
function broadcastInfo ( ip, referer ) {
var options = {
host: 'api.ipinfodb.com',
port: 80,
path: '/v3/ip-city/?key=afbce595eb8f0b56719f748ed0c9e7dc84f67dc09a244f340624aa21c958f89a&ip=' + ip
};
http.get(options, function(res) {
var data = '';
res.on('data', function (chunk) {
data += chunk;
});
res.on('end', function () {
data = data.split(';');
socket.broadcast({ data: data[6], referer: referer });
});
})
}
// Only listen on $ node app.js
if (!module.parent) {
app.listen( PORT );
console.log("Express server listening on port %d", app.address().port);
}
var socket = io.listen( app );
(function fakeData () {
socket.broadcast({ data: 'fake' });
setTimeout( fakeData, Math.random() * 10000 );
})();
init: function(){
//set up web server
this.httpServer = express.createServer();
this.httpServer.use(express.bodyParser());
this.httpServer.post("/connect_to_channel", function(req, res) {
var channel_str = req.body.channel;
var credential_str = req.body.credentials;
var secret = req.body.secret;
//check that server's secret string matches configuation's secret
if( secret != config.secret ) {
res.send("FAIL");
return false;
}
Events.subscribe({
channel: channel_str,
credential_str: credential_str,
meta: '',
server_id: 0
});
//store the user's subscription to the channel in the redis datastore, in the event that the the client is not connected to any servers
//when the message is sent; if the user is, this command will be duplicated (harmlessly)
Clients.channel_store.add(credential_str, channel_str);
if( config.debug )
console.log("server-side connectToChannel", channel_str, credential_str);
res.send("OK")
});
this.httpServer.post("/disconnect_from_channel", function(req, res) {
var channel_str = req.body.channel;
var credential_str = req.body.credentials;
var secret = req.body.secret;
//check that server's secret string matches configuation's secret
if( secret != config.secret ) {
res.send("FAIL");
return false;
}
if( channel_str == "__all__") {
//TODO: not really sure how to disconnect from all channels ATM
} else {
Events.unsubscribe({
channel: channel_str,
credential_str: credential_str,
meta: '',
server_id: 0
});
}
//store the user's removal from channel in the redis datastore, in the event that the the client is not connected to any servers
//when the message is sent; if the user is, this command will be duplicated (harmlessly)
Clients.channel_store.remove(credential_str, channel_str);
res.send("OK")
if( config.debug )
console.log("server-side disconnectFromChannel", channel_str, credential_str);
});
this.httpServer.post("/message", function(req, res) {
var channel_str = req.body.channel;
var message_str = req.body.message;
var secret = req.body.secret;
//check that server's secret string matches configuation's secret
if( secret != config.secret ) {
res.send("FAIL");
return false;
}
if( config.debug ) {
var console_msg_str = ( message_str.length > 250 ) ? message_str.substr(0,250) + "..." : message_str;
console.log("server-side message", channel_str, console_msg_str);
}
Events.message([channel_str], message_str);
res.send("OK")
});
//set up static file server
this.httpServer.use(express.static("./public"));
//set up socket server
this.socket = io.listen(this.httpServer);
this.socket.on("connection", function(stream){ new Connection(stream) });
},
/**
* Module dependencies.
*/
var express = require('express')
, routes = require('./routes');
// socket io
var io = require('socket.io');
var app = module.exports = express.createServer();
// socket io setup
io = io.listen(app);
// Configuration
// configure socket.io
io.configure(function () {
// recommended production testing
//io.enable('browser client minification'); // send minified client
//io.enable('browser client etag'); // apply etag caching logic based on version number
//io.enable('browser client gzip'); // gzip the file
io.set('log level', 1); // reduce level of logging to warning only
io.set('transports', [
'websocket'
, 'flashsocket'
, 'htmlfile'
var http = require('http'),
io = require('socket.io'),
util = require('util'),
path = require('path'),
spawn = require('child_process').exec,
ansi = require('ansi-html-stream');
var server = http.createServer(function(req, res){
res.writeHead(200);
res.end("OK");
}).listen(8002);
var io_app = io.listen(server),
cwd = process.cwd(),
currentProcess;
function getUserHome() {
return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE;
}
io_app.sockets.on('connection', function(socket){
socket.on('exec', function(cmd){
socket.emit("exec_init");
cmd = cmd.trim();
var cdm;
if(cdm = cmd.match(/^\s*cd (.*)/)){
cdm[1] = cdm[1].replace("~", getUserHome());
var cwdt = path.resolve(cwd, cdm[1]);
exports.listen = function(abs_path, port) {
op.chdir(abs_path);
var cwd = process.cwd();
server.configure(function() {
server.use(express.bodyParser());
server.use(express.methodOverride());
server.use(server.router);
server.use(express.static(__dirname + '/../public'));
});
staticServer.configure(function() {
staticServer.use(express.bodyParser());
staticServer.use(express.methodOverride());
staticServer.use(server.router);
staticServer.use(express.static(cwd));
});
var io = sockeio.listen(httpServer, {
'log level': 1
})
io.configure(function() {
io.set('transports', ['xhr-polling', 'jsonp-polling']);
});
httpServer.listen(port, function() {
httpStaticServer.listen(port + 1, function() {});
});
var serverErrorHandler = function(err) {
if (err.code == 'EADDRINUSE') {
console.error('Error: Address already in use. use another port');
process.exit(-1);
} else {
console.error('Error: ', err);
process.exit(-1);
}
}
server.on('error', serverErrorHandler);
staticServer.on('error', serverErrorHandler);
io.sockets.on('connection', function(socket) {
op.list(cwd, function(nodes) {
socket.emit('cwd', cwd, cwd.substring(cwd.lastIndexOf(separator) + 1), nodes);
});
socket.on('openfolder', function(folder) {
op.list(folder, function(nodes) {
socket.emit('openfolder', folder, nodes);
});
});
//显示文件内容事件
socket.on('load', function(path, isMarkdown) {
op.load(path, function(result, file) {
if (result) {
socket.emit('file', {
path: path,
error: null,
file: file
});
} else {
socket.emit('file', {
path: path,
error: file,
file: null
});
}
});
});
socket.on('save', function(data, fn) {
var index = data.index;
op.save(data.path, data.content, function(result, desc) {
if (result) {
fn({
result: true,
index: index,
path: data.path
})
} else {
fn({
result: false,
index: index,
path: data.path,
error: desc
});
}
});
});
});
}
var socket=require("socket.io"),os=require("os"),childProcess=require("child_process"),path=require("path"),thread={Global:{MaxThreads:16,LogLevel:5,Port:85498,NodeExecutable:"node"},WorkerPool:[],Queue:[],Events:{OnFinish:function(){}},Server:void 0,Initialize:function(a){a.Port&&(thread.Global.Port=a.Port),a.MaxThreads&&(thread.Global.MaxThreads=a.MaxThreads),a.NodeExecutable&&(thread.Global.NodeExecutable=a.NodeExecutable),a.LogLevel&&(thread.Global.LogLevel=a.LogLevel),thread.Server=socket.listen(thread.Global.Port),thread.Server.set("log level",1),thread.Server.sockets.on("connection",function(a){a.on("Boot",function(b){thread.Work(a,b)}),a.on("Result",function(b){console.log("Worker "+b.id+": "+b.result),thread.Work(a,b)})})},Work:function(a,b){if(thread.Queue.length>0)a.emit("Work",{task:thread.Queue[0].Task,index:b.id}),thread.Queue=thread.Queue.slice(1),console.log("Worker "+b.id+": Grabbed Task from Queue, "+thread.Queue.length+" remaining"),0===thread.Queue.length&&console.log("Queue empty");else{console.log("Queue empty"),thread.WorkerPool[b.id].state=0;var c=0;thread.WorkerPool.forEach(function(a){c+=a.state}),0===c&&thread.Events.OnFinish()}},CreateThread:function(a){if(!a)return!1;thread.Queue.push(a),thread.Server.emit("Add",{});var b=thread.WorkerPool.length;if(b<thread.Global.MaxThreads){var c=path.join(__dirname,"..","lib","ThreadBase.js"),d=["node",c,thread.Global.Port,b],e=childProcess.exec(d.join(" "),function(a,c,d){console.log("Worker "+b+": stdout: "+c),console.log("Worker "+b+": stderr: "+d)});e.on("exit",function(a){console.log("Worker "+b+": Finished or exited with code "+a)}),thread.WorkerPool.push({state:1}),console.log("Created Worker Thread "+b)}return!0},End:function(){thread.Server.emit("End",{})},BaseTask:function(a){this.Task=""+a,this.OnExit=function(){}}};module.exports=thread;
function initialize(server, options, fn) {
"use strict";
if (process.env.WEBT_LOGIN) {
if (process.getuid && process.setuid) {
if (process.getuid() === 0) {
try {
pam = require("authenticate-pam");
} catch (err) {
console.log(errs.loginNoPam);
process.exit(1);
}
} else {
console.log(errs.loginNotRoot);
process.exit(1);
}
} else {
console.log(errs.loginNotPosix);
process.exit(1);
}
}
var port, sPort, protocol;
if ("function" === typeof options) {
fn = options;
options = {};
}
if (undefined === server) {
if (process.env.PORT) {
server = (+process.env.PORT);
} else {
server = (+config.port) || 8088;
}
}
if ("string" === typeof server) {
server = (+server);
}
if ("number" === typeof server) {
// if a port number is passed
port = server;
if (options && options.key) {
protocol = "https";
http = require(protocol);
sPort = (port !== 443) ? ":" + port : "";
} else {
protocol = "http";
http = require(protocol);
sPort = (port !== 80) ? ":" + port : "";
}
server = http.createServer(options);
server.listen(port, fn);
standalone = true;
console.log(util.format("Web-Terminal running at %s://localhost%s/terminal", protocol, sPort));
}
if (options) {
autoClose = options.autoClose;
}
if (!config.root) {
config.root = "/terminal";
}
server.on("request", function (req, res) {
if (req.url.indexOf(config.root) === 0) {
send(req, req.url.substr(config.root.length))
.root(path.normalize(__dirname + "/../web"))
.on('error', function (err) {
res.statusCode = err.status || 500;
res.end(err.message);
})
.on('directory', function () {
redirect(res, req.url + "/");
})
.pipe(res);
} else if (standalone) {
redirect(res, config.root);
}
});
io = io.listen(server, { log: false });
io.sockets.on("connection", function (socket) {
var cwd = process.cwd(),
env = _.clone(process.env),
home = process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE,
linebreak = "\n", // check if we need to add \r\n for windows
promptChar = process.platform === "win32" ? ">" : "$",
stdin,
args,
cmd,
proc,
dir,
replSrv,
user,
username;
function execCmd(command, shell) {
if (env.WEBT_LOGIN && !user) {
socket.emit("exit", "login required");
return;
}
var opts = { cwd: cwd, env: env };
if (user) {
opts.uid = user;
}
if (env.WEB_SHELL || shell) {
proc = spawn(env.WEB_SHELL || shell, null, opts);
stdin = proc.stdin;
stdin.write(command);
stdin.end();
} else {
proc = spawn(cmd, args, opts);
stdin = proc.stdin;
}
proc.on("error", function (err) {
if (err.code === "ENOENT") {
err.message = cmd + ": command not found";
}
socket.emit("console", err.message);
});
proc.stdout.setEncoding("utf8");
proc.stdout.on("data", function (data) {
socket.emit("console", data);
});
proc.stderr.setEncoding("utf8");
proc.stderr.on("data", function (data) {
if (data.indexOf("execvp():") === 0) {
data = cmd + ": command not found";
}
socket.emit("console", data);
});
proc.on("close", function () {
stdin = null;
socket.emit("exit", "");
});
}
function startRepl() {
var input = streams.ReplStream(),
output = streams.ReplStream();
input.setEncoding("utf8");
output.setEncoding("utf8");
stdin = input;
output.on("data", function (data) {
socket.emit("console", data);
});
replSrv = repl.start({
prompt: "> ",
input: input,
output: output,
terminal: false,
useColors: true
});
replSrv.on("exit", function () {
stdin = null;
socket.emit("configure", {
prompt : cwd,
promptChar : promptChar
});
socket.emit("exit");
replSrv = null;
});
socket.emit("configure", {
prompt : "",
promptChar : ">"
});
}
socket.on("disconnect", function () {
if (autoClose && io.sockets.clients().length === 0) {
server.close();
}
});
socket.on("signal", function (signal) {
var cmd;
if (replSrv) {
switch (signal) {
case "SIGINT":
cmd = ".break";
break;
case "SIGQUIT":
cmd = ".exit";
break;
}
stdin.write(cmd + linebreak);
} else if (proc) {
proc.kill(signal);
}
});
socket.on("console", function (command) {
var i, arg, basePath;
if (stdin) {
stdin.write(command + linebreak);
} else {
args = cmdLine.parse(command);
cmd = args.splice(0, 1)[0];
switch (cmd) {
case "cd":
arg = args[0];
if (arg[0] === "~") {
basePath = home;
arg = arg.substring(2);
} else {
basePath = cwd;
}
dir = path.resolve(basePath, arg);
fs.exists(dir, function (exists) {
var msg;
if (exists) {
cwd = dir;
msg = "cwd: " + cwd;
} else {
msg = "No such file or directory";
}
socket.emit("exit", msg);
});
break;
case "export":
for (i = 0; i < args.length; i++) {
arg = args[i].split("=");
env[arg[0]] = arg[1];
}
socket.emit("exit");
break;
case "unset":
for (i = 0; i < args.length; i++) {
delete env[args[i]];
}
socket.emit("exit");
break;
case "env":
// TODO: handle env command to manage environment variables
args.length = 0;
command = "env";
execCmd(command);
break;
case "ls":
if (env.WEB_SHELL) {
if (command.length === 2) {
command += " --color -C";
}
} else {
if (args.length === 0) {
args.push("--color");
args.push("-C");
}
}
execCmd(command);
break;
case "node":
if (args.length === 0) {
startRepl();
} else {
execCmd(command);
}
break;
case "echo":
execCmd(command, process.platform === "win32" ? "cmd" : "bash");
break;
case "login":
case "logout":
user = undefined;
username = undefined;
env.WEBT_LOGIN = "******";
socket.emit("configure", { prompt: "", promptChar: ">" });
socket.emit("username");
default:
execCmd(command);
}
}
});
function begin() {
socket.emit("configure", {
srvOS : process.platform,
prompt : cwd,
promptChar : promptChar
});
socket.emit("exit");
}
socket.on("username", function (input) {
username = input;
socket.emit("password");
});
socket.on("password", function (input) {
pam.authenticate(username, input, function (err) {
if (err) {
console.log("Authentication failed: " + err);
socket.emit("exit", errs.wrongCrdtls);
socket.emit("username");
} else {
console.log("Authenticated: " + username);
require("uid-number")(username, function (err, uid, gid) {
if (err) {
console.log(err);
socket.emit("exit", err);
} else {
user = uid;
exec("echo ~" + username, function (err, stdout, stderr) {
if (err) {
console.log(err);
socket.emit("exit", err);
} else {
cwd = home = env.HOME = stdout.toString().trim();
begin();
}
});
}
});
}
});
});
if (process.env.WEBT_LOGIN) {
socket.emit("username");
} else {
begin();
}
});
return server;
}
res.type('text');
res.send(500, err.message);
});
app.use(lessMiddleware({ src: publicDir, force: true }));
app.use('/scripts/lib/', express.static(path.join(__dirname, '../bower_components'), { maxAge: 24*60*60*1000 }));
app.use(express.static(publicDir, { maxAge: 60*60*1000 }));
app.use(function(req, res, next){
res.send(404);
accessLog.debug({ method: req.method, url: req.url, status: res.statusCode })
});
var server = http.createServer(app);
var io = server.io = socketio.listen(server, {
'log level': 1, // 0 - error, 1 - warn, 2 - info, 3 - debug
//'transports': ['websocket', 'flashsocket', 'htmlfile', 'xhr-polling', 'jsonp-polling']
});
io.enable('browser client minification');
io.enable('browser client etag');
io.enable('browser client gzip');
server.listen(app.get('port'), function(){
logger.info("Listening on http://*:" + app.get('port'));
});
//test broadcasting upload progress
// setInterval(function(){
// logger.debug("sending fake broadcast event");
// io.sockets.emit('deploy', { topic: 'deploy:catalyst:_all:start', body: { test: true, componentId: 'storm', step: 'upload', state: 'progress', progress: Math.random() }});
// }, 3000);
Hub.prototype.listen = function(callback) {
var self = this,
app = express(),
server = http.Server(app),
io = new Server(server);
this.server = server;
app.use(cors());
// require a valid session token for all api calls
var validateSession = function(req, res, next) {
session.find(req.query.token, function(err, data) {
if (err || ! data) {
res.sendStatus(401);
} else {
next();
}
});
};
// allow cross origin requests
io.set('origins', '*:*');
io.sockets.on('connection', function (socket) {
var disconnectTimer = setTimeout(function() {
socket.disconnect();
}, 10000);
socket.on('auth', function (creds, callback) {
function succeed (record) {
//AJF: set the groupID on the socket to be used in further local calls
//AJF: set the groupID on the socket to be used in further calls
socket.groupID = record._groupID;
addApiCalls(self, io, socket);
clearTimeout(disconnectTimer);
callback(null, record._id.toString(), socket.id, record._groupID.toString());//AJF: try to return the groupID...
}
function fail (msg) {
callback(msg);
socket.disconnect();
}
if (creds.hasOwnProperty('password') && creds.password && creds.password !== '') {
//AJF: Compares the passwords and determines what group the user logging into belongs to
if ( bcrypt.compareSync(creds.password, self.config.secret) ) {
session.create(0, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_1)) {
session.create(1, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_2)) {
session.create(2, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_101)) {
session.create(101, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_102)) {
session.create(102, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_103)) {
session.create(103, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_104)) {
session.create(104, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_105)) {
session.create(105, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_106)) {
session.create(106, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_107)) {
session.create(107, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_108)) {
session.create(108, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_109)) {
session.create(109, throwErr(succeed));
} else if (bcrypt.compareSync(creds.password, self.config.secret_110)) {
session.create(110, throwErr(succeed));
} else {
fail('Invalid Password');
}
} else if (creds.hasOwnProperty('token') && creds.token && creds.token !== '') {
console.log("Finding session via token");
session.find(creds.token, function(err, data) {
if (data) {
succeed(data);
} else {
fail('Invalid Token');
}
});
} else {
fail('Password must be provided');
}
});
});
server.listen(self.config.port, callback);
};
module.exports = function (app, models) {
var io = require('socket.io');
var utils = require('connect').utils;
var cookie = require('cookie');
var Session = require('connect').middleware.session.Session;
var sio = io.listen(app.server)
sio.configure(function () {
app.isAccountOnline = function (accountId) {
var clients = sio.sockets.clients(accountId);
return (clients.length > 0);
};
sio.set('authorization', function (data, accept) {
var signedCookies = cookie.parse(data.headers.cookie);
var cookies = utils.parseSignedCookies(signedCookies, app.sessionSecret);
data.sessionID = cookies['express.sid'];
data.sessionStore = app.sessionStore;
data.sessionStore.get(data.sessionID, function (err, session) {
if (err || !session) {
return accept('Invalid session', false);
} else {
data.session = new Session(data, session);
accept(null, true);
}
});
});
sio.sockets.on('connection', function (socket) {
var session = socket.handshake.session;
var accountId = session.accountId;
var sAccount = null;
socket.join(accountId);
app.triggerEvent('event:' + accountId, {
from: accountId,
action: 'login'
});
var handleContactEvent = function (eventMessage) {
socket.emit('contactEvent', eventMessage);
};
var subscribeToAccount = function (accountId) {
var eventName = 'event:' + accountId;
app.addEventListener(eventName, handleContactEvent);
console.log('Subscribing to ' + eventName);
};
models.Account.findById(accountId, function subscribeToFriendFeeds(account) {
var subscribedAccounts = {};
sAccount = account;
account.contacts.forEach(function (contact) {
if (!subscribedAccounts[contact.accountId]) {
subscribeToAccount(contact.accountId);
subscribedAccounts[contact.accountId] = true;
}
});
if (!subscribedAccounts[accountId]) {
// Subscribe to my own updates
subscribeToAccount(accountId);
}
});
socket.on('disconnect', function () {
sAccount.contacts.forEach(function (contact) {
var eventName = 'event:' + contact.accountId;
app.removeEventListener(eventName, handleContactEvent);
console.log('Unsubscribing from ' + eventName);
});
app.triggerEvent('event:' + accountId, {
from: accountId,
action: 'logout'
});
});
socket.on('chatclient', function (data) {
sio.sockets.in(data.to).emit('chatserver', {
from: accountId,
text: data.text
});
});
});
});
}