.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)); }); } }) });