crixalis/lib/plugins/static.js

'use strict';

/**
 * Static plugin.
 * Provides basic file-serving capabilities. By default tries to serve all paths
 * with extensions. To disable this behaviour set `route` parameter to `false`
 *
 *     // Default options
 *     Crixalis.plugin('static');
 *
 *     // Custom options
 *     Crixalis.plugin('static', {
 *         // Do not create route
 *         route     : false,
 *
 *         // Do not follow symlinks
 *         symlinks  : false,
 *
 *         // Cache files and stat calls for 10 seconds
 *         cacheTime : 10000
 *     });
 *
 * @module Crixalis
 * @submodule static
 * @for Controller
 */

var Crixalis   = require('../controller'),
	fs         = require('fs'),
	zlib       = require('zlib'),
	crypto     = require('crypto'),
	mime       = require('mime'),
	normalize  = require('path').normalize,
	AsyncCache = require('async-cache'),
	extensions = {
		gzip    : '.gz',
		deflate : '.def'
	};

function send (context, file, size) {
	context.emit('response');

	context.sendHeaders();

	if (!context.is_head && file) {
		if (size > context._streamLimit) {
			/* Stream big files */
			fs.createReadStream(file)
				.on('end', function () {
					context._destroy();
				})
				.pipe(context.res);
		} else {
			/* Serve small files from cache */
			context._fileCache.get(file, function (error, result) {
				context.res.end(result);
				context._destroy();
			});
		}
	} else {
		context.res.end();
		context._destroy();
	}
}

module.exports = function (options) {
	options = Object(options);

	/* TODO: configurable cache size */

	var stat      = options.symlinks === false? fs.stat : fs.lstat,
		cacheTime = Number(options.cacheTime || 307),
		statCache = new AsyncCache({
			max    : 1 << 7,
			maxAge : cacheTime,
			length : function () { return 1 },
			load   : function (file, callback) {
				stat(file, function (error, result) {
					fileCache.del(file);
					callback(error, result);
				})
			}
		}),
		fileCache  = new AsyncCache({
			max    : 1 << 20,
			length : function () { return arguments[0].length },
			load   : fs.readFile
		});

	/* Default static route */
	if (options.route !== false) {
		Crixalis.router().set({
			methods: ['GET', 'HEAD'],
			pattern: /^\/(.+?)(\.[^.\/]+)$/,
			capture: {
				'$1': 'path',
				'$2': 'extension'
			}
		}).to(function () {
			var that      = this,
				extension = this.params.extension.slice(1),
				path      = normalize(this.staticPath + '/' + this.params.path + '.' + extension);

			this.async = true;

			if (path.indexOf(normalize(this.staticPath))) {
				this.emit('default');
				that.render();
				return;
			}

			this[typeof this[extension] === 'function'? extension : 'serve'](path, function (error) {
				that.emit('default');
				that.render();
			});
		});
	}

	/**
	 * Where Crixalis should look for static files. Crixalis will not
	 * create any directories, you should do it yourself.
	 * @property staticPath
	 * @type String
	 * @default public
	 */
	Crixalis.define('property', 'staticPath', 'public');

	/**
	 * Where Crixalis should store compressed files. Crixalis will not
	 * create any directories, you should do it yourself.
	 * @property cachePath
	 * @type String
	 * @default .
	 */
	Crixalis.define('property', 'cachePath', '.');

	/**
	 * Expirity data by mime type in milliseconds
	 * @property expires
	 * @type Object
	 */
	Crixalis.define('property', 'expires', {});

	/**
	 * Files smaller than 32K will not be streamed
	 * @property _streamLimit
	 * @type Number
	 * @default 32768
	 * @private
	 */
	Crixalis.define('property', '_streamLimit', 32768);

	/**
	 * Cache for small files
	 * @property _fileCache
	 * @type AsyncCache
	 * @private
	 */
	Crixalis.define('property', '_fileCache', fileCache, { writable: false });

	/**
	 * Cache for data from fs.stat and fs.lstat calls
	 * @property _statCache
	 * @type AsyncCache
	 * @private
	 */
	Crixalis.define('property', '_statCache', statCache, { writable: false });

	/**
	 * Serve static file
	 *
	 *     this.serve('../public/index.html');
	 *
	 * When callback is omitted this.error() is called
	 * in case of any errors
	 *
	 * @method serve
	 * @param {String} path Path to file
	 * @param {Function} [callback] Callback
	 * @async
	 * @chainable
	 */
	Crixalis.define('method', 'serve', function (path, callback) {
		var that = this,
			stats;

		callback = callback || this.error;

		if (typeof callback !== 'function') {
			throw new Error('Callback must be a function');
		}

		this._statCache.get(path, function (error, result) {
			if (error) {
				callback.call(that, error);
				return;
			}

			if (!result.isFile()) {
				callback.call(that, new Error('Not a file'));
				return;
			}

			that.stash.path = path;
			that.stash.stat = result;

			that.render('file');
		});

		return this;
	});

	Crixalis.define('view', 'file', function () {
		var that        = this,
			stash       = this.stash,
			headers     = this.headers,
			contentType = mime.lookup(stash.path),
			expires     = this.expires[contentType],
			mtime       = stash.stat.mtime,
			file, compression;

		/* Add charset to content-type */
		contentType += '; charset=';
		contentType += stash.charset || 'utf-8';

		headers['Last-Modified'] = mtime.toUTCString();

		/* TODO: Check ETag */

		/* Check file modification time */
		if (+mtime === Date.parse(this.req.headers['if-modified-since'])) {
			this.code = 304;
			send(this);
			return false;
		}

		headers['Vary']           = 'Accept-Encoding';
		headers['Content-Length'] = stash.stat.size;
		headers['Content-Type']   = contentType;

		if (expires) {
			headers['Expires'] = (new Date(this.start + expires)).toUTCString();
		}

		/* Detect compression support */
		if (typeof this.compression === 'function') {
			compression = this.compression();
		}

		/* Compress if possible */
		if (compression) {
			headers['Content-Encoding'] = compression;

			file  = this.cachePath;
			file += '/';

			/* Create unique file name in cache directory */
			file += crypto.createHash('md5')
				.update(stash.path + mtime)
				.digest('hex');
			file += extensions[compression];

			this._statCache.get(file, function (error, result) {
				if (!error) {
					send(that, file, headers['Content-Length'] = result.size);
					return;
				}

				var compressor = zlib[compression === 'gzip'? 'createGzip' : 'createDeflate'](),
					length     = 0,

					/* Source file */
					stream     = fs.createReadStream(stash.path),

					/* Compressed file in cache */
					cache      = fs.createWriteStream(file);

				compressor
					.on('data', function (data) {
						length += data.length;
					});

				cache
					.on('close', function () {
						send(that, file, headers['Content-Length'] = length);
					});

				stream
					.pipe(compressor)
					.pipe(cache);
			});

			return false;
		}

		/* Send file */
		send(this, stash.path, headers['Content-Length']);

		return false;
	});
};