exports.run = function (options) {
for (option in options) {
global.options[option] = options[option];
}
var application = create_app(global.options.url_conf.mappings);
sys.puts((global.options.debug ? '(debug) ' : '') + 'jimi running on port ' + global.options.port + '...\n');
if (global.options.debug) {
if (!global.options.public_path) {
sys.puts('[warning]: You have not defined the global public_path option, and will not be able to serve static media.');
}
return connect.createServer(
connect.logger(),
connect.staticProvider(global.options.public_path),
application,
connect.errorHandler({
dumpExceptions: true,
showStack: true
})
).listen(global.options.port);
} else {
return connect.createServer(
connect.staticProvider(global.options.public_path),
application
).listen(global.options.port);
}
};
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}));
});
exports.staticProvider = function (root, mount) {
var staticGzip = exports.staticGzip({
root : path.normalize(root),
compress : [
"application/javascript",
"application/xml",
"text/css",
"text/html"
]
});
var staticProvider = connect.staticProvider(path.normalize(root));
return function (request, response, next) {
var url = request.url;
var pathname = require("url").parse(url).pathname;
if (pathname.indexOf(mount) === 0) {
request.url = url.replace(mount, "") || "/";
staticGzip(request, response, function (err) {
if (err) {
request.url = url;
return next(err);
}
staticProvider(request, response, function (err) {
request.url = url;
next(err);
});
});
} else
next();
};
}
exports.main = function(projectDir, port, ip) {
var commonProvider = function() {
var common = connect.staticProvider(__dirname + "/../../../common");
return function(req, resp, next) {
var path = require("url").parse(req.url).pathname;
if (path.indexOf("/common") === 0) {
req.url = req.url.replace("/common", "");
common(req, resp, next);
}
else {
next();
}
};
};
server = connect.createServer(
//connect.logger(),
connect.conditionalGet(),
// connect.gzip(),
commonProvider(),
connect.staticProvider(__dirname + "/../../../client")
);
if (ip === "all" || ip === "0.0.0.0")
ip = null;
server.listen(port, ip);
new IdeServer(projectDir, server);
};
server.configure(function(){
server.set('views', __dirname + '/views');
server.use(connect.methodOverride());
server.use(connect.bodyDecoder());
server.use(connect.staticProvider(__dirname + '/static'));
server.use(server.router);
});
dreadnode.configure(function() {
dreadnode.set("views", __dirname+"/views");
dreadnode.use(connect.bodyDecoder());
dreadnode.use(connect.methodOverride());
dreadnode.use(dreadnode.router);
dreadnode.use(connect.staticProvider(__dirname+"/public"));
});
app.configure(function(){
app.set('views', __dirname + '/views');
app.use(connect.bodyDecoder());
app.use(connect.methodOverride());
app.use(connect.compiler({ src: __dirname + '/public', enable: ['sass'] }));
app.use(connect.staticProvider(__dirname + '/public'));
});
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 })
);
};
app.configure(function(){
app.set('views', __dirname + '/views');
app.use(connect.bodyDecoder());
app.use(connect.methodOverride());
app.use(app.router);
app.use(connect.staticProvider(__dirname + '/public'));
});
app.configure(function() {
app.set('views', __dirname + '/views');
app.use(connect.bodyDecoder());
app.use(connect.gzip());
app.use(connect.staticProvider(__dirname + '/static'));
app.use(app.router);
});
createStacks = function(roots)
{
publicStacks = [];
for (var rootIndex = 0; rootIndex < roots.length; ++rootIndex)
{
publicStacks.push(connect.createServer(connect.staticProvider({ root: roots[rootIndex], maxAge: 1})));
}
}
test: function(){
var server = helpers.run(
connect.compiler({ src: __dirname + '/fixtures', enable: ['sass'] }),
connect.staticProvider(__dirname + '/fixtures')
);
server.assertResponse('GET', '/doesnotexist.css', 404, 'Not Found');
server.assertResponse('GET', '/style.css', 200, 'body {\n font-size: 12px;\n color: #000;}\n');
server.assertResponse('GET', '/style.css', 200, 'body {\n font-size: 12px;\n color: #000;}\n');
server.assertResponse('GET', '/foo.bar.baz.css', 200, 'foo {\n color: #000;}\n');
server.assertResponse('GET', '/foo.bar.baz.css', 200, 'foo {\n color: #000;}\n');
}
app.configure(function()
{
//var db = mongoose.connect('mongodb://localhost/');
app.use(connect.logger({ format : ":method :url"}));
app.use(connect.compiler({ src: __dirname + '/public', enable: ['less'] }));
app.use(connect.staticProvider(__dirname + '/public'));
app.use(connect.methodOverride());
app.set('views', __dirname + '/app/views');
app.set('view engine', 'jade');
});
var commonProvider = (function() {
var common = connect.staticProvider(__dirname + "/../../../common");
return function(req, resp, next) {
var path = require("url").parse(req.url).pathname;
if (path.indexOf("/common") === 0) {
req.url = req.url.replace("/common", "");
common(req, resp, next);
}
else {
next();
}
};
})();
'test configurable cache-control': function(){
var server = helpers.run(
connect.staticProvider({ root: fixturesPath, lifetime: 60000 })
);
var req = server.request('GET', '/user.json');
req.buffer = true;
req.addListener('response', function(res){
res.addListener('end', function(){
assert.ok(res.headers['cache-control'] == 'public max-age=60000', 'Test configurable Cache-Control support');
});
});
req.end();
},
'test non-compressable': function(){
var server = helpers.run(
connect.staticGzip({ root: fixturesPath, compress: ['text/html'] }),
connect.staticProvider(fixturesPath)
);
var req = server.request('GET', '/style.css', { Accept: 'gzip' });
req.buffer = true;
req.on('response', function(res){
res.on('end', function(){
assert.notEqual('gzip', res.headers['content-encoding']);
});
});
req.end();
},
var server = function() {
var server = express.createServer();
server.use(connect.compiler({ src: __dirname + '/public', enable: ['less'] }));
server.use(connect.staticProvider(__dirname + '/public'));
server.use(connect.bodyDecoder());
server.use(connect.methodOverride());
server.use(server.router);
server.use(connect.errorHandler({ dumpExceptions: true, showStack: true }));
database.connect('localhost', 27017, 'uvid', function() {
server.listen(80);
});
return server;
}();
app.configure('development', function() {
app.set('view engine', 'jade');
app.set('views', __dirname + '/dev/views');
app.stack.unshift({
route: '/dev',
handle: function(req, res, next) {
req.dev = true;
next();
}
});
app.use(connect.logger());
app.use('/dev', connect.router(require('./dev/app')));
app.use(connect.staticProvider(__dirname + '/dev/public'));
app.use(connect.errorHandler({dumpExceptions: true, showStack: true}));
});
'test valid file': function(){
var server = helpers.run(
connect.staticProvider(fixturesPath)
);
var req = server.request('GET', '/user.json');
req.buffer = true;
req.addListener('response', function(res){
res.addListener('end', function(){
var headers = res.headers,
body = '{\n "name": "tj",\n "email": "*****@*****.**"\n}';
assert.equal(200, res.statusCode, 'Test static with valid file status code');
assert.equal(body, res.body, 'Test static with valid file response body');
assert.equal('application/json', headers['content-type'], 'Test static with valid file Content-Type');
assert.equal(body.length, headers['content-length'], 'Test static with valid file Content-Length');
assert.ok(headers['last-modified'], 'Test static with valid file Last-Modified');
assert.ok(headers['cache-control'] == 'public max-age=31536000', 'Test static with valid file Cache-Control');
});
});
req.end();
},
exports.main = function(projectDir, port) {
var commonProvider = (function() {
var common = connect.staticProvider(__dirname + "/../../../common");
return function(req, resp, next) {
var path = require("url").parse(req.url).pathname;
if (path.indexOf("/common") === 0) {
req.url = req.url.replace("/common", "");
common(req, resp, next);
}
else {
next();
}
};
})();
server = connect.createServer(
//connect.logger(),
connect.staticProvider(__dirname + "/../../../client"),
commonProvider
);
server.listen(port);
new IdeServer(projectDir, server);
};
'test compressable': function(){
var server = helpers.run(
connect.staticGzip({ root: fixturesPath, compress: ['text/css', 'text/html'] }),
connect.staticProvider(fixturesPath)
);
try {
var stat = fs.statSync(fixturesPath + '/style.css'),
path = fixturesPath + '/style.css.' + Number(stat.mtime) + '.gz';
fs.unlinkSync(path);
} catch (err) {
// Ignore
}
server.pending = 2;
// Pre-compression
var req = server.request('GET', '/style.css', { 'Accept-Encoding': 'gzip' });
req.buffer = true;
req.on('response', function(res){
res.on('end', function(){
assert.notEqual('gzip', res.headers['content-encoding'], 'Content-Encoding: gzip when not gzipped');
// Post-compression
var req = server.request('GET', '/style.css', { 'Accept-Encoding': 'gzip' });
req.buffer = true;
req.on('response', function(res){
res.on('end', function(){
assert.equal('text/css', res.headers['content-type']);
assert.equal('gzip', res.headers['content-encoding'], 'missing Content-Encoding: gzip when gzipped');
});
});
req.end();
});
});
req.end();
}
'test invalid file': function(){
var server = helpers.run(
connect.staticProvider({ root: fixturesPath })
);
server.assertResponse('GET', '/foo.json', 404, 'Cannot GET /foo.json', 'Test invalid static file.');
}
/**
* @author Nils Dehl <*****@*****.**>
*/
var http = require('http'),
sys = require('sys'),
fs = require('fs'),
io = require('socket.io');
var Connect = require('connect');
var server = Connect.createServer(
Connect.logger(), // Log responses to the terminal using Common Log Format.
//Connect.responseTime(), // Add a special header with timing information.
Connect.conditionalGet(), // Add HTTP 304 responses to save even more bandwidth.
Connect.cache(), // Add a short-term ram-cache to improve performance.
Connect.gzip(), // Gzip the output stream when the browser wants it.
Connect.staticProvider(__dirname) // Serve all static files in the current dir.
);
var socket = io.listen(server);
socket.on('connection', function(client) {
var user;
client.on('message', function(message) {
if (!user) {
user = message;
client.send({ message: 'Welcome, ' + user.nickname + '!', nickname: 'server', gravatar: '' });
return;
}
var response = {
var connect = require('connect'),
sys = require('sys'),
url = require('url'),
socketIO = require("../socketIO").socketIO,
buffer = [];
var server = connect.createServer(
connect.staticProvider(__dirname),
socketIO( function (client) {
client.send(JSON.stringify({ buffer: buffer }));
client.broadcast(JSON.stringify({ announcement: client.sessionId + ' connected' }));
client.on('message', function(message){
var msg = { message: [client.sessionId, message] };
buffer.push(msg);
if (buffer.length > 15) buffer.shift();
client.broadcast(JSON.stringify(msg));
});
client.on('disconnect', function(){
client.broadcast(JSON.stringify({ announcement: client.sessionId + ' disconnected' }));
});
}),
function (req, res) {
// your normal server code
var path = url.parse(req.url).pathname;
switch (path){
case '/':
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<h1>Welcome. Try the <a href="/chat.html">chat</a> example.</h1>');
app.configure(function() {
app.use(connect.logger({ format: ':req[x-real-ip]\t:status\t:method\t:url\t' }));
app.use(assets);
app.use(connect.staticProvider(__dirname + '/public'));
});
const DB_CONNECT_STRING = 'mongodb://localhost/blog',
BLOG_DETAILS = {
title: 'My Awesome blog',
tagline: 'Epic awesomesauce',
name: 'Bender Bending Rodriguez',
item_limit: 10,
username: '******',
password: require('crypto').createHash('md5').update('changeme').toString('ascii') // SHOULD be replaced with a real hash
};
var connect = require('connect'),
express = require('express'),
mongoose = require('./vendor/mongoose/mongoose').Mongoose,
app = express.createServer(
connect.staticProvider(__dirname + '/public'),
connect.bodyDecoder(),
express.cookieDecoder(),
express.session()
);
// Config
app.set('view engine', 'jade');
app.set('db', mongoose.connect(DB_CONNECT_STRING));
app.set('blog-details', BLOG_DETAILS);
app.use(app.router);
// Models
require('./models/article').ArticleModel(mongoose);
// Controllers
exports.connect = function() {
return connect.staticProvider({ root: __dirname + "/../../lib", cache: true});
};
var connect = require('connect');
//var form = require('connect-form');
var main = require('./endpoints/main');
var matches = require('./endpoints/matches');
var games = require('./endpoints/games');
var sampledata = require('./endpoints/sampledata');
var server = connect.createServer(
//form({ keepExtensions: false }),
connect.logger({ buffer: true })
);
var vhost = connect.vhost('gunslinger', server);
server.use("/www", connect.staticProvider(__dirname + '/www'));
server.use("/www/resources/css", connect.staticProvider(__dirname + '/www/resources/css'));
server.use("/www/resources/imgs", connect.staticProvider(__dirname + '/www/resources/imgs'));
server.use("/www/resources/js", connect.staticProvider(__dirname + '/www/resources/js'));
server.use("/www/resources/templates", connect.staticProvider(__dirname + '/www/resources/templates'));
server.use("/sampledata/", connect.router(sampledata.endpoints));
server.use("/games/", connect.router(games.endpoints));
server.use("/matches/", connect.router(matches.endpoints));
server.use(main.defaultResponse);
server.use(main.renderResponse);
//server.use("/session/", connect.router(session.endpoints));
meryl.h('GET /public/', function(req, resp) {
connect.staticProvider()
});
var jade = require('jade'),
connect = require('connect'),
meryl = require('meryl');
var opts = {
port: 8124,
templateDir: 'templates',
templateExt: '.jade',
templateFunc: function (src, data) {
return jade.render(src, {locals: data});
}
};
meryl.p(
connect.staticProvider()
)
meryl.h('GET /', function (req, resp) {
resp.render('layout',
{content: 'home', context:{}}
);
});
//File static provider at /public
meryl.h('GET /public/', function(req, resp) {
connect.staticProvider()
});
meryl.run(opts);
console.log('Server running at http://127.0.0.1:8124/');