socket.io/lib/static.js

/*!
* socket.io-node
* Copyright(c) 2011 LearnBoost <dev@learnboost.com>
* MIT Licensed
*/

/**
 * Module dependencies.
 */

var client = require('socket.io-client')
  , cp = require('child_process')
  , fs = require('fs')
  , util = require('./util');


/**
 * File type details
 */

var mime = {
    js: {
        type: 'application/javascript'
      , encoding: 'utf8'
      , gzip: true
    }
  , swf: {
      type: 'application/x-shockwave-flash'
    , encoding: 'binary'
    , gzip: false
  }
};

/**
 * Export the constructor
 */

exports = module.exports = Static;

/**
 * Static constructor
 *
 * @api public
 */

function Static (manager) {
  this.manager = manager;
  this.cache = {};
  this.paths = {};
  this.etag = client.version;

  this.init(manager);
}

/**
 * Initialize the Static by adding default file paths
 *
 * @api public
 */

Static.prototype.init = function (manager) {
  manager.on('set:transports', function (value, key){
  
  });
};

/**
 * Gzip compress buffers
 *
 * @param {Buffer} data The buffer that needs gzip compression
 * @param {Function} callback
 * @api public
 */

Static.prototype.gzip = function (data, callback) {
  var gzip = cp.spawn('gzip', ['-9'])
    , buffer = []
    , err;

  gzip.stdout.on('data', function (data) {
    buffer.push(data);
  });

  gzip.stderr.on('data', function (data) {
    err = data +'';
    buffer.length = 0;
  });

  gzip.on('exit', function () {
    if (err) return callback(err);

    var size = 0
      , index = 0
      , i = buffer.length
      , content;

    while (i--) {
      size += buffer[i].length;
    }

    content = new Buffer(size);
    i = buffer.length;

    buffer.forEach(function (buffer) {
      var length = buffer.length;

      buffer.copy(content, index, 0, length);
      index += length;
    });

    buffer.length = 0;
    callback(null, content);
  });

  gzip.stdin.write(data, 'utf8');
  gzip.stdin.end();
};

/**
 * Is the path a staic file
 *
 * @param {String} path The path that needs to be checked
 * @api public
 */

Static.prototype.has = function (path) {
  // fast case
  if (this.paths[path]) return this.paths[path];

  var keys = Object.keys(this.paths)
    , i = keys.length;

  while (i--) {
    if (!!~path.indexOf(keys[i])) return this.paths[keys[i]];
  }

  return false;
};

/**
 * Add new paths new paths that can be served using the static provider
 *
 * @param {String} path The path to respond to
 * @param {Options} options Options for writing out the response
 * @param {Function} [callback] Optional callback if no options.file is
 * supplied this would be called instead.
 * @api public
 */

Static.prototype.add = function (path, options, callback) {
  var extension = /(?:\.(\w{1,4}))$/.exec(path)
    , mime = options.mime || (extension ? mime[extension[1]] : false);

  if (callback) options.callback = callback;
  if (!options.file || !options.callback) return false;

  this.paths[path] = options;

  return true;
};

/**
 * Writes a static response
 *
 * @param {String} path The path for the static content
 * @param {HTTPRequest} req The request object
 * @param {HTTPResponse} res The response object
 * @api public
 */

Static.prototype.write = function (path, req, res) {
  /**
   * Write a response without throwing errors because can throw error if the
   * response is no longer writable etc.
   *
   * @api private
   */

  function write (status, headers, content, encoding) {
    try {
      res.writeHead(status, headers || undefined);
      res.end(content || '', encoding || undefined);
    } catch (e) {}
  }

  /**
   * Answers requests depending on the request properties and the reply object.
   *
   * @param {Object} reply The details and content to reply the response with
   * @api private
   */

  function answer (reply) {
    var cached = req.headers['if-none-match'] === self.etag;
    if (cached && self.manager.enabled('browser client etag')) {
      return write(304);
    }

    var accept = req.headers['accept-encoding'] || ''
      , gzip = !!~accept.toLowerCase().indexOf('gzip')
      , mime = reply.mime
      , headers = {
          'Content-Type': mime.type
      };

    // check if we can add a etag
    if (self.manager.enabled('browser client etag') && self.etag) {
      headers['Etag'] = self.etag;
    }

    // check if we can send gzip data
    if (gzip && reply.gzip) {
      headers['Content-Length'] = reply.gzip.length;
      headers['Content-Encoding'] = 'gzip';
      write(200, headers, reply.gzip.content, mime.encoding);
    } else {
      headers['Content-Length'] = reply.length;
      write(200, headers, reply.content, mime.encoding);
    }

    self.manager.log.debug('served static content ' + path);
  }

  var self = this
    , details;

  // most common case first
  if (this.manager.enabled('browser client cache') && this.cache[path]) {
    return answer(this.cache[path]);
  } else if (this.manager.get('browser client handler')) {
    return this.manager.get('browser client handler').call(this, req, res);
  } else if ((details = this.has(path))) {
    /**
     * A small helper function that will let us deal with fs and dynamic files
     *
     * @param {Object} err Optional error
     * @param {Buffer} content The data
     * @api private
     */

    function ready (err, content) {
      if (err) {
        self.manager.log.warn('Unable to serve file. ' + (err.message || err));
        return write(500, null, 'Error serving static ' + path);
      }

      // store the result in the cache
      var reply = self.cache[path] = {
            content: content
          , length: content.length
          , mime: details.mime
        };

      // check if gzip is enabled
      if (details.mime.gzip && self.manager.enabled('browser client gzip')){
        self.gzip(content, function (err, content) {
          if (!err) {
            reply.gzip = {
                content: content
              , length: content.length
            }
          }

          answer(reply);
        });
      } else {
        answer(reply);
      }
    }

    if (details.file) {
      fs.readFile(details.file, ready);
    } else if(details.callback) {
      details.callback.call(this, path, ready);
    } else {
      write(404, null, 'File handle not found');
    }
  } else {
    write(404, null, 'File not found');
  }
};