/*! * Connect - HTTPServer * Copyright(c) 2010 Sencha Inc. * Copyright(c) 2011 TJ Holowaychuk * MIT Licensed */ /** * Module dependencies. */ var http = require('http')  , parse = require('url').parse  , assert = require('assert')  , utils = require('./utils'); // environment var env = process.env.NODE_ENV || 'development'; /** * Initialize a new `Server` with the given `middleware`. * * Examples: * *     var server = connect.createServer( *         connect.favicon() *       , connect.logger() *       , connect.static(__dirname + '/public') *     ); * * @params {Array} middleware  * @return {Server} * @api public */ var Server = exports.Server = function HTTPServer(middleware) {  this.stack = [];  middleware.forEach(function(fn){    this.use(fn);  }, this);  http.Server.call(this, this.handle);}; /** * Inherit from `http.Server.prototype`. */ Server.prototype.__proto__ = http.Server.prototype; /** * Utilize the given middleware `handle` to the given `route`, * defaulting to _/_. This "route" is the mount-point for the * middleware, when given a value other than _/_ the middleware * is only effective when that segment is present in the request's * pathname. * * For example if we were to mount a function at _/admin_, it would * be invoked on _/admin_, and _/admin/settings_, however it would * not be invoked for _/_, or _/posts_. * * This is effectively the same as passing middleware to `connect.createServer()`, * however provides a progressive api. * * Examples: * *      var server = connect.createServer(); *      server.use(connect.favicon()); *      server.use(connect.logger()); *      server.use(connect.static(__dirname + '/public')); * * If we wanted to prefix static files with _/public_, we could * "mount" the `static()` middleware: * *      server.use('/public', connect.static(__dirname + '/public')); * * This api is chainable, meaning the following is valid: * *      connect.createServer() *        .use(connect.favicon()) *        .use(connect.logger()) *        .use(connect.static(__dirname + '/public')) *        .listen(3000); * * @param {String|Function} route or handle * @param {Function} handle * @return {Server} * @api public */ Server.prototype.use = function(route, handle){  this.route = '/';   // default route to '/'  if ('string' != typeof route) {    handle = route;    route = '/';  }   // wrap sub-apps  if ('function' == typeof handle.handle) {    var server = handle;    server.route = route;    handle = function(req, res, next) {      server.handle(req, res, next);    };  }   // wrap vanilla http.Servers  if (handle instanceof http.Server) {    handle = handle.listeners('request')[0];  }   // normalize route to not trail with slash  if ('/' == route[route.length - 1]) {    route = route.substr(0, route.length - 1);  }   // add the middleware  this.stack.push({ route: route, handle: handle });   // allow chaining  return this;}; /** * Handle server requests, punting them down * the middleware stack. * * @api private */ Server.prototype.handle = function(req, res, out) {  var writeHead = res.writeHead    , stack = this.stack    , removed = ''    , index = 0;   function next(err) {    var layer, path, c;    req.url = removed + req.url;    req.originalUrl = req.originalUrl || req.url;    removed = '';     layer = stack[index++];     // all done    if (!layer || res.headerSent) {      // but wait! we have a parent      if (out) return out(err);       // error      if (err) {        var msg = 'production' == env          ? 'Internal Server Error'          : err.stack || err.toString();         // output to stderr in a non-test env        if ('test' != env) console.error(err.stack || err.toString());         // unable to respond        if (res.headerSent) return req.socket.destroy();         res.statusCode = 500;        res.setHeader('Content-Type', 'text/plain');        if ('HEAD' == req.method) return res.end();        res.end(msg);      } else {        res.statusCode = 404;        res.setHeader('Content-Type', 'text/plain');        if ('HEAD' == req.method) return res.end();        res.end('Cannot ' + req.method + ' ' + utils.escape(req.originalUrl));      }      return;    }     try {      path = parse(req.url).pathname;      if (undefined == path) path = '/';       // skip this layer if the route doesn't match.      if (0 != path.indexOf(layer.route)) return next(err);       c = path[layer.route.length];      if (c && '/' != c && '.' != c) return next(err);       // Call the layer handler      // Trim off the part of the url that matches the route      removed = layer.route;      req.url = req.url.substr(removed.length);       // Ensure leading slash      if ('/' != req.url[0]) req.url = '/' + req.url;       var arity = layer.handle.length;      if (err) {        if (arity === 4) {          layer.handle(err, req, res, next);        } else {          next(err);        }      } else if (arity < 4) {        layer.handle(req, res, next);      } else {        next();      }    } catch (e) {      if (e instanceof assert.AssertionError) {        console.error(e.stack + '\n');        next(e);      } else {        next(e);      }    }  }  next();};