.done(function(app) {
var connect = require('connect'),
passport = require('passport'),
redirect = require('connect-redirection'),
port = process.env.PORT || 5777;
var server = connect()
.use(connect.favicon())
.use(connect.query())
.use(connect.cookieParser())
.use(connect.bodyParser())
.use(connect.session({ secret: 'key' }))
.use(redirect())
.use(passport.initialize())
.use(passport.session())
.use(app.responder())
.use(connect.static(__dirname))
.listen(port);
if (app.args.debug) {
app.autoreload(server);
mask.cfg('allowCache', false);
}
logger.log('Listen %s'.green.bold, port);
});
'test req.session.cookie.expires': function(){
var n = 0
, port = ++portno
, app = connect.createServer(
connect.cookieParser()
, connect.session({ secret: 'keyboard cat', key: 'foobar' })
, function(req, res, next){
if (!n++) req.session.cookie.expires = new Date(0);
res.end(req.session.id);
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
http.get(options, function(res){
var prev = res.body;
options.headers = { Cookie: 'foobar=' + prev };
expires(res).should.equal('Thu, 01 Jan 1970 00:00:00 GMT');
http.get(options, function(res){
res.body.should.not.equal(prev);
http.get(options, function(res){
res.body.should.not.equal(prev);
app.close();
});
});
});
});
},
requestHandler.startServer = function() {
// Sessions
var sessionOptions = {
secret: (process.env.SESSIONS_SECRET) ? process.env.SESSIONS_SECRET : 'hello world'
};
if (process.env.STORE_SESSIONS_IN_MONGODB) {
var MongoStore = require('connect-mongodb');
var mongoStoreOptions = {
safe: true,
url: 'mongodb://' + process.env.MONGODB_USER + ':' + process.env.MONGODB_PASSWORD + '@' + process.env.MONGODB_HOST + ':' + process.env.MONGODB_PORT + '/' + process.env.MONGODB_DATABASE
};
sessionOptions.store = new MongoStore(mongoStoreOptions, function(err) {
if (err) console.log('err', err);
});
}
// if ran from c9, use its port
process.env.PORT = (process.env.C9_PORT != undefined) ? process.env.C9_PORT : process.env.PORT;
// starts the server
var server = connect()
.use(connect.favicon())
.use(connect.cookieParser())
.use(connect.session(sessionOptions))
.use(requestHandler)
.listen(process.env.PORT, function() {
console.log('ThinAir server is started and listening on port ' + process.env.PORT);
});
return server;
};
'test expiration': function(){
var n = 0
, port = ++portno
, app = create(
connect.cookieParser()
, connect.session({ secret: 'keyboard cat', cookie: { maxAge: 200 }})
, function(req, res, next){
res.end(req.session.id);
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
http.get(options, function(res){
var prev = res.body;
options.headers = { Cookie: 'connect.sid=' + prev };
setTimeout(function(){
http.get(options, function(res){
res.body.should.not.equal(prev);
app.close();
});
}, 300);
});
});
},
'test req.session.cookie.maxAge': function(){
var n = 0
, port = ++portno
, app = create(
connect.cookieParser()
, connect.session({ secret: 'keyboard cat', key: 'foobar' })
, function(req, res, next){
if (!n++) req.session.cookie.maxAge = 0;
res.end(req.session.id);
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
http.get(options, function(res){
var prev = res.body;
options.headers = { Cookie: 'foobar=' + prev };
http.get(options, function(res){
res.body.should.not.equal(prev);
http.get(options, function(res){
res.body.should.not.equal(prev);
app.close();
});
});
});
});
},
'test #flash()': function(assert){
var app = express.createServer(
connect.cookieDecoder(),
connect.session({ store: memoryStore })
);
app.get('/', function(req, res){
assert.eql([], req.flash('info'));
assert.eql([], req.flash('error'));
assert.eql({}, req.flash());
assert.eql({}, req.session.flash);
assert.equal(1, req.flash('info', 'one'));
assert.equal(2, req.flash('info', 'two'));
assert.eql(['one', 'two'], req.flash('info'));
assert.eql([], req.flash('info'));
assert.equal(1, req.flash('info', 'one'));
assert.eql({ info: ['one'] }, req.flash());
req.flash('info', 'Email _sent_.');
req.flash('info', '<script>');
assert.eql(['Email <em>sent</em>.', '<script>'], req.flash('info'));
res.send('ok');
});
assert.response(app,
{ url: '/' },
{ body: 'ok' });
}
function initExpress (callback) {
self.app = express();
self.app.locals.title = 'Translation';
self.app.locals.baseUrl = self.baseUrl;
self.app.use(connect.basicAuth(function (username, password) {
return self.users[username] && password == self.users[username];
}));
self.app.use(express.static(self.editorStaticFilesPath));
self.app.use(connect.bodyParser());
self.app.use(connect.cookieParser('translator-a0f0d060-bf58-11e2-ab1f-0800200c9a66'));
self.app.use(connect.session({
secret: 'translator-a879d480-bf58-11e2-ab1f-0800200c9a66',
cookie: {path: self.baseUrl},
store: connect.session.MemoryStore({
reapInterval: 60000 * 60
})
}));
self.app.use(translator.useSession);
self.app.set('view engine', 'ejs');
self.app.set('view options', {layout: false});
callback();
}
http.configure(function(){
// logger.debug(__dirname + '/views');
// process.exit(0);
http.set('views', __dirname + '/views');
http.set('view engine', 'ejs');
http.engine('ejs', engine);
http.use(express.logger());
http.use(express.static(__dirname + '/public'));
http.use(express.cookieParser());
http.use(express.bodyParser());
http.use(express.methodOverride());
//TODO: Load secret from config/env var
http.use(connect.session({
secret: env.get("SESSION_SECRET"),
store: sessionStore,
cookie: {maxAge: (365).days()}
}));
http.use(function (req, res, next) {
res.removeHeader("X-Powered-By");
next();
});
http.use(http.router);
require("express-persona")(http, {
audience: env.get("PERSONA_AUDIENCE")
});
});
'test expires: null': function(){
var port = ++portno
, app = create(
connect.cookieParser()
, connect.session({
secret: 'foo'
, cookie: { expires: null, httpOnly: true }
})
, function(req, res){
res.end('wahoo');
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
http.get(options, function(res){
var cookie = res.headers['set-cookie'][0]
, prev = sid(res);
cookie.should.not.include.string('expires');
options.headers = { Cookie: 'connect.sid=' + prev };
http.get(options, function(res){
var cookie = res.headers['set-cookie'][0];
sid(res).should.equal(prev);
cookie.should.not.include.string('expires');
app.close();
});
});
});
},
function listen(callback) {
var cookieParser = connect.cookieParser();
var app = connect();
var sessionStore = new connect.session.MemoryStore();
var sessionKey = 'sid';
var sessionSecret = 'keyboard cat';
app.use(connect.cookieParser());
app.use(connect.session({ store: sessionStore, key: sessionKey, secret: sessionSecret }));
app.use(function(req, res) {
req.session.foo = 'bar';
req.session.save();
res.end('test');
});
var httpServer = http.createServer(app).listen();
var server = eio.attach(httpServer);
server.on('connection', eioSession({
cookieParser: cookieParser,
store: sessionStore,
key: sessionKey,
secret: sessionSecret
}));
callback(httpServer.address().port);
return server;
}
var WebServer = function(site) {
this.site = site;
this.server = connect.createServer(
// log HTTP requests
connect.logger(),
// decode application/x-www-form-urlencoded and application/json requests
connect.bodyDecoder(),
// populate req.cookies
connect.cookieDecoder(),
// dole out session cookies
connect.session({ store: new MemoryStore({ reapInterval: 5 * MINUTE }) }),
// conditional HTTP GETs
connect.conditionalGet(),
// handle /
connect.router(this.mainHandler()),
// cache manifest for offline app
//connect.cacheManifest(),
// merge static files into /
connect.staticProvider({root: __dirname + "/../public", maxAge: 1000}),
connect.errorHandler({ showStack: true })
);
};
'test Store#load(sid, fn)': function(){
var port = ++portno
, store = new MemoryStore
, app = connect.createServer(
connect.cookieParser()
, connect.session({ secret: 'foo', store: store })
, function(req, res){
res.end('wahoo');
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
http.get(options, function(res){
var id = decodeURIComponent(sid(res));
store.load(id, function(err, sess){
should.equal(null, err);
sess.should.be.an.instanceof(Session);
sess.cookie.should.be.an.instanceof(Cookie);
sess.foo = 'bar';
var a = sess;
sess.save(function(){
store.load(id, function(err, sess){
should.equal(null, err);
sess.should.be.an.instanceof(Session);
sess.cookie.should.be.an.instanceof(Cookie);
sess.foo.should.equal('bar');
a.lastAccess.should.equal(sess.lastAccess);
app.close();
});
});
});
});
});
},
'test req.session.regenerate()': function(){
var prev
, port = ++portno
, app = create(
connect.cookieParser()
, connect.session({ secret: 'keyboard cat' })
, function(req, res, next){
req.session.lastAccess.should.not.equal(prev);
req.session.count = req.session.count || 0;
var n = req.session.count++;
switch (req.url) {
case '/one':
prev = req.session.id;
res.end('count: ' + n);
break;
case '/two':
req.session.id.should.not.equal(prev);
res.end('count: ' + n);
break;
case '/regenerate':
should.equal(req.session.id, prev, 'SIDs did not match before regenerate()');
req.session.regenerate(function(err){
should.notEqual(req.session.id, prev, 'SIDs matched after regenerate()');
should.notEqual(req.sessionID, prev, 'SIDs matched after regenerate()');
req.sessionID.should.equal(req.session.id);
should.equal(null, err);
res.end('count: ' + n);
});
break;
}
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
// 0
options.path = '/one';
http.get(options, function(res){
var prev = sid(res);
options.headers = { Cookie: 'connect.sid=' + prev };
res.body.should.equal('count: 0');
// regenerated
options.path = '/regenerate';
http.get(options, function(res){
should.notEqual(prev, sid(res), 'SID remained the same after regenerate() request');
res.body.should.equal('count: 1');
// 1
options.path = '/two';
http.get(options, function(res){
res.body.should.equal('count: 0');
app.close();
});
});
});
});
},
module.exports = function(options) {
var app = connect(),
emitter = new events.EventEmitter();
// optional parameters
options = options || {};
options.emitter = emitter;
// proxy cross-origin requests
app.use(proxy(options));
// support POST JSON-encoded and URL-encoded queries
app.use(connect.json());
app.use(connect.urlencoded());
// no-cache header
app.use(nocache(options));
// sessions require the cookie parser
app.use(connect.cookieParser());
// register requires session support
app.use(connect.session({ secret: 'phonegap' }));
// watch file system for changes and notify client
app.use(autoreload(options));
// handle /register requests
app.use(register(options));
// handle /zip requests
app.use(zip(options));
// inject JavaScript to refresh app or navigate home
app.use(inject(options));
// serve static assets
app.use(mstatic(options));
// serve cordova js if 404'd out from previous static server
app.use(cordova(options));
// serve cordova_plugin js if 404'd out from previous static server
app.use(cordova_plugins(options));
// serve plugins if 404'd out from previous static server
app.use(plugins(options));
// create request listener and attach event emitter interface
var requestListener = function(req, res, next) {
app.handle(req, res, next);
};
for(var property in emitter) {
requestListener[property] = emitter[property];
}
return requestListener;
};
exports.connect_middleware = function(){
var minute = 60000;
return connect.session({
secret:'daft!punk',
maxAge: minute * 1440,
cookie: { domain: '.spokesproject.org' }
});
}
module.exports = function(express, app, root_path) {
// development only
if ('development' == app.get('env')) {
app.use(expressErrorHandler());
}
app.set('brokerServer', config[app.get('env')].broker);
app.set("config", config[app.get('env')]);
app.engine('ejs', engine);
app.use(express.static(path.join(root_path, 'public')));
app.use(connect.logger( app.get("config").debug_level));
app.use(methodOverride());
app.use(expressLayouts);
app.use(expressJson());
app.use(cookieParser());
app.use(bodyParser());
app.use(connect.cookieParser());
var client = redis.createClient( app.get("config").redis.port, app.get("config").redis.host);
client.on("error", function (err) {
console.log("Redis error encountered".red, err);
});
var offset = 30*24*60*60*1000* 12 * 10;
app.use(connect.session({
secret: 'secret',
key: 'parada',
store: new RedisStore(app.get("config").redis),
cookie: {
expires: new Date(Date.now() + offset),
maxAge: offset,
client: client
}
}));
app.use(function(req, res, next) {
if (!req.session)
return res.send("Chyba při práci se session. Nepodařilo se připojit k Redis serveru.");
next();
});
app.use(common.createLocals(app));
app.use(passport.initialize()); app.use(passport.session()); app.use(flash());
// all environments
app.set('port', process.env.PORT || config[app.get('env')].port);
app.set('views', path.join(root_path, 'views'));
app.set('view engine', 'ejs');
app.set('layout', 'layout');
};
app.configure(function(){
app.set('views', __dirname + '/views');
app.use(connect.cookieDecoder());
app.use(connect.session());
app.use(connect.bodyDecoder());
app.use(connect.methodOverride());
app.use(connect.compiler({ src: __dirname + '/public', enable: ['less'] }));
app.use(app.router);
app.use(connect.staticProvider(__dirname + '/public'));
});
target: function() {
server = connect.createServer(
connect.cookieParser(),
connect.session({
store: ng.db.getMongoStore(),
secret: 'blah',
fingerprint: '',
cookie: {
maxAge: 12 * 24 * 60 * 60 * 1000
}
}),
connect.bodyParser(),
connect.router(routes),
connect.static('./static')
)
var sio = io.listen(server, {'log level': 3})
sio.set('authorization', function(data, accept) {
var cookies = connect.utils.parseCookie(data.headers.cookie)
, sessionId = cookies['connect.sid']
if (!sessionId) {
accept(null, false)
return
}
ng.db.getMongoStore().get(sessionId, function(err, session) {
if (err) {
accept(err, false)
return
}
if (!session) {
accept(null, false)
return
}
data.session = session
accept(null, true)
})
})
sio.sockets.on('connection', function(socket) {
ng.clientSocket.onSocketReady(socket, socket.handshake.session)
})
ng.log.log('Starting HTTP Server: ' + ng.conf.server_ip + ':' + ng.conf.server_port)
server.listen(ng.conf.server_port, ng.conf.server_ip, function() {
console.log(arguments)
})
}
server.configure(function(){
server.use(express.logger());
server.use(express.methodOverride());
server.use(express.bodyParser()); // añadido xmlencoded.js para parsear text/xml el 09/08/2012
server.use(connect.cookieParser(session.secretString()));
server.use(connect.session({cookie:{maxAge:60000000}, store:sessionStore}));
server.use(server.router);
server.use(function(err,req,res,next){
console.error(err.stack);
res.send(500,'Something broke!');
});
});
'test req.session.destroy()': function(){
var prev
, port = ++portno
, app = create(
connect.cookieParser()
, connect.session({ secret: 'keyboard cat' })
, function(req, res, next){
req.session.lastAccess.should.not.equal(prev);
req.session.count = req.session.count || 0;
var n = req.session.count++
, sid = req.session.id;
req.sessionID.should.equal(sid);
switch (req.url) {
case '/destroy':
req.session.destroy(function(err){
should.equal(null, err);
should.equal(null, req.session);
res.end('count: ' + n);
});
break;
}
res.end('count: ' + n);
}
);
app.listen(port, function(){
var options = { port: port, buffer: true };
// 0
http.get(options, function(res){
var prev = sid(res);
options.headers = { Cookie: 'connect.sid=' + prev };
res.body.should.equal('count: 0');
// destroy
options.path = '/destroy';
http.get(options, function(res){
res.headers.should.not.have.property('set-cookie');
res.body.should.equal('count: 1');
// 1
options.path = '/';
http.get(options, function(res){
prev.should.not.equal(sid(res));
res.body.should.equal('count: 0');
app.close();
});
});
});
});
},
ni._initialize(function(){
connect.createServer(
connect.bodyParser(),
connect.static('public'),
connect.query(),
connect.cookieParser('ni_cookie'),
connect.session({secret: 'kM43QtvEhmhH2KK9sJac',cookie: {maxAge: 36000}}),
ni.router,
ni.not_found
).listen(80);
console.log('Application Started on Port: '+80);
});
before(function() {
app = connect(
connect.cookieParser(),
connect.session({
secret: 'i m secret'
}),
userauth(/^\/user/i, {
loginURLForamter: function (url, rootPath) {
return rootPath + '/mocklogin?redirect=' + url;
},
rootPath: '/hello/world/',
loginPath: '/win32/login',
protocol: 'https',
getUser: function (req, callback) {
process.nextTick(function () {
var user = req.session.user;
if (req.headers.mocklogin) {
user = {
nick: 'mock user',
userid: 1234
};
}
callback(null, user);
});
}
})
);
app.use('/mocklogin', function (req, res, next) {
var redirect = req.query.redirect;
res.statusCode = 302;
res.setHeader('Location', redirect);
res.end();
});
app.use(function (req, res, next) {
res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify({
user: req.session.user || null,
message: req.method + ' ' + req.url
}));
});
app.use(function (err, req, res, next) {
res.setHeader('Content-Type', 'application/json');
res.statusCode = 500;
res.end(JSON.stringify({
error: err.message,
message: req.method + ' ' + req.url
}));
});
});
bounce.call(params, params.store, function (err, store) {
if (err) {
if (cb) { cb(err) } else { throw err }
}
pipeline.use(muddle(
connect.cookieParser(),
connect.session({secret: params.secret, store: store, cookie: params.sessionCookie || {maxAge: params.sessionDuration}}),
passport.initialize(),
passport.session()
))
process.nextTick(function () { cb() })
})
app.configure(function(){
app.use( connect.session({
secret: env.get( "SESSION_SECRET" ),
store: sessionStore,
cookie: { maxAge: ( 365 ).days }
}));
require( "express-persona" )( app, {
audience: env.get( "PERSONA_AUDIENCE" )
});
});
Server.prototype.configure = function() {
var instance = this;
var configuration = instance.configuration;
var staticResourceDir = simpleportal.util.getServerPath(configuration.resources.root + 'public/');
instance.server.use(connect.compress({
filter : function(req, res){
return /html|text|css|javascript/.test(res.getHeader('Content-Type'));
}
}));
if (fs.existsSync(staticResourceDir + '/favicon.ico'))
instance.server.use(connect.favicon(staticResourceDir + '/favicon.ico'));
else if(fs.existsSync(__dirname+'/../../resources/favicon.ico'))
instance.server.use(connect.favicon(__dirname+'/../../resources/favicon.ico'));
if(instance.configureconnect)
instance.configureconnect();
else{
instance.server.use(connect.cookieParser('keyboard cat'));
if(configuration.secure)
instance.server.use(connect.session({ secret:'keyboard cat', cookie: { maxAge: 60000, secure:true }}));
else
instance.server.use(connect.session({ secret:'keyboard cat', cookie: { maxAge: 60000}}));
}
if (fs.existsSync(staticResourceDir))
instance.server.use(connect.static(staticResourceDir));
if(configuration.resources.publicdirs && typeof configuration.resources.publicdirs.length != 'undefined'){
configuration.resources.publicdirs.forEach(function(resource){
if(fs.existsSync(resource))
instance.server.use(connect.static(resource));
});
}
}
app.configure(function(){
//app.use(log());
//app.use(connect.logger({format : ":method :url :status"}));
app.use(connect.bodyDecoder());
app.use(connect.cookieDecoder());
app.use(connect.session({ store : memory, secret : 'foobar' }));
app.use(connect.methodOverride());
app.use(app.router);
app.use(connect.staticProvider(__dirname + '/public'));
// session management
//app.use(connect.session());
//app.use(connect.session({ store : new MemoryStore({reapInterval: -1 }) }));
app.use(connect.staticProvider({root : __dirname + '/public'}));//, cache : true}));
});
database.connect(settings.database, function(db) {
connect()
.use(connect.favicon(settings.favicon))
.use(connect.cookieParser(settings.cookieKey))
.use(connect.session(settings.session))
.use(tracking(db))
.use(connect.static(settings.html))
.use('/api/auth', auth(db))
.use(function(req, res, next) {
res.end('We dont know what you want');
})
.listen(settings.port);
console.log('Server running on port: %d', settings.port);
});
app.configure(function(){
app.use(connect.cookieDecoder());
app.use(connect.session());
app.use(auth( [
//auth.Twitter({consumerKey: twitterConsumerKey, consumerSecret: twitterConsumerSecret})
]) );
app.set('views', __dirname + '/views');
app.use(express.bodyDecoder());
app.use(express.methodOverride());
app.use(express.compiler({ src: __dirname + '/public', enable: ['less'] }));
app.use(app.router);
app.use(express.staticProvider(__dirname + '/public'));
});
module.exports = function startup(options, imports, register) {
assert(options.key, "option 'key' is required");
assert(options.secret, "option 'secret' is required");
var connect = imports.connect;
var sessionStore = imports["session-store"];
var sessionOptions = {
store: sessionStore,
key: options.key,
secret: options.secret,
cookie: {}
};
if ("proxy" in options)
sessionOptions.proxy = options.proxy;
var cookie = sessionOptions.cookie;
if ("secure" in options)
cookie.secure = options.secure;
if ("maxAge" in options)
cookie.maxAge = options.maxAge;
var connectModule = imports.connect.getModule();
var sessionRoutes = connectModule();
connect.useSession(sessionRoutes);
sessionRoutes.use(
function(req, res, next) {
if (/^\/geckolala\//.test(req.url))
return next(new error.TooManyRequests("Rate limit exceeded"));
next();
}
);
sessionRoutes.use(Session(sessionOptions, cookie));
register(null, {
session: {
getKey: function() {
return options.key;
},
get: sessionStore.get,
use: sessionRoutes.use.bind(sessionRoutes)
}
});
};
process.stdin.on("data", function(data) {
// Do the initialization bits
var processInfo = JSON.parse(data);
if (processOptions.enableCookies) {
app = express.createServer(
connect.bodyParser(),
connect.cookieParser(),
connect.session({secret : "locker"}) );
} else {
app = express.createServer(connect.bodyParser());
}
var mongoId = processOptions.id || "id";
var authLib = undefined;
if (processOptions.oauth2) {
authLib = require('connector/oauth2');
authLib.options = processOptions.oauth2;
} else {
authLib = require("auth.js");
}
var syncApi = require("sync-api.js")(app);
locker.initClient(processInfo);
process.chdir(processInfo.workingDirectory);
lstate.init();
app.meData = lfs.loadMeData();
locker.connectToMongo(function(mongo) {
require("connector/api")(app, mongoId, mongo);
app.externalBase = processInfo.externalBase;
authLib.authAndRun(app, processInfo.externalBase, function() {
syncApi.authComplete(authLib.auth, mongo);
if (!started) {
startWebServer();
}
});
if(!authLib.isAuthed())
startWebServer();
function startWebServer() {
started = true;
// Start the core web server
if(callback) callback(app, mongo);
app.listen(0, function() {
// Tell the locker core that we're done
var returnedInfo = {port: app.address().port};
process.stdout.write(JSON.stringify(returnedInfo));
});
}
})
});