alchemymvc 1.2.8 → 1.3.1

package/lib/class/conduit.js

@@ -1,7 +1,8 @@
-var fileCache  = alchemy.shared('files.fileCache'),
-    libstream  = alchemy.use('stream'),
+const FILECACHE = alchemy.getCache('served_files'),
+      RX_TEXT = /svg|xml|javascript|text/i;
+
+var libstream  = alchemy.use('stream'),
     libpath = alchemy.use('path'),
-    libmime = alchemy.use('mime'),
     libua   = alchemy.use('useragent'),
     zlib    = alchemy.use('zlib'),
     BODY    = Symbol('body'),
@@ -345,7 +346,7 @@ Conduit.setMethod(function setRequestFiles(files) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.2.0
- * @version  1.2.0
+ * @version  1.3.0
  *
  * @param    {Conduit}   conduit
  * @param    {Array}     files
@@ -370,7 +371,7 @@ function _setRequestFiles(conduit, files, target) {
 
 			_setRequestFiles(conduit, entry, context);
 		} else {
-			target[key] = Classes.Alchemy.Inode.File.from(entry);
+			target[key] = Classes.Alchemy.Inode.File.fromUntrusted(entry);
 		}
 	}
 }
@@ -980,7 +981,7 @@ Conduit.setMethod(function getRouteByName(name) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.7
+ * @version  1.3.0
  *
  * @param    {Route}   after_route   Only check routes after this one
  *
@@ -1009,7 +1010,7 @@ Conduit.setMethod(async function parseRoute(after_route) {
 
 		if (temp) {
 			this.route = temp.route;
-			this.params = temp.parameters;
+			this.setRouteParameters(temp.parameters);
 			this.route_string_parameters = temp.original_parameters;
 			this.path_definition = temp.definition;
 		} else {
@@ -1048,11 +1049,11 @@ Conduit.setMethod(async function parseRoute(after_route) {
 		}
 
 		if (temp) {
-			this.params = temp.parameters || {};
+			this.setRouteParameters(temp.parameters);
 			this.route_string_parameters = temp.original_parameters || {};
 			this.path_definition = temp.definition;
 		} else {
-			this.params = {};
+			this.setRouteParameters();
 		}
 	}
 });
@@ -1230,19 +1231,67 @@ Conduit.setMethod(function callHandler() {
 	this.route.callHandler(this);
 });
 
+/**
+ * Put this request in a queue
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Object}   options   Options or url
+ */
+Conduit.setMethod(function postponeAndQueue(options) {
+
+	if (!options) {
+		options = {};
+	}
+
+	const postponement = this.postponeRequest({
+		put_in_queue : true,
+	});
+
+	return postponement;
+});
+
+/**
+ * Postpone the response and the request
+ *
+ * This does not stop the current request from processing.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Number|Object}   options   Options or time to wait
+ *
+ * @return   {Alchemy.Conduit.Postponement}
+ */
+Conduit.setMethod(function postponeRequest(options) {
+
+	let postponement = this.postponeResponse(options);
+
+	this.afterOnce('get-postponed-response', () => {
+		this.callMiddleware();
+	});
+
+	return postponement;
+});
+
 /**
  * End the current request with a 202 status
- * and tell the client to look at another url later
+ * and tell the client to look at another url later.
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * This does not stop the current request from processing.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.2.5
+ * @version  1.3.1
  *
- * @param    {String|Object}   options   Options or url
+ * @param    {Number|Object}   options   Options or time to wait
+ *
+ * @return   {Alchemy.Conduit.Postponement}
  */
-Conduit.setMethod(function postpone(options) {
-
-	let session = this.getSession();
+Conduit.setMethod(function postponeResponse(options) {
 
 	if (typeof options == 'number') {
 		options = {
@@ -1252,55 +1301,100 @@ Conduit.setMethod(function postpone(options) {
 		options = {};
 	}
 
-	// Make sure the scene id exists
-	this.createScene();
+	return this._postpone(options);
+});
 
-	// Already set the cookies
-	if (this.new_cookie_header.length) {
-		this.response.setHeader('set-cookie', this.new_cookie_header);
-	}
+/**
+ * Handle the postponement
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @param    {Object}   options
+ *
+ * @return   {Alchemy.Conduit.Postponement}
+ */
+Conduit.setMethod(function _postpone(options) {
 
-	let postponed_id = session.postpone(this),
-	    url = '/alchemy/postponed/' + postponed_id;
+	let session = this.getSession();
 
-	// Set the location header where the client should look at later
-	this.response.setHeader('Location', url);
-	this.response.setHeader('Content-Type', 'text/html');
+	let postponement = session.getExistingPostponement(this);
 
-	if (options.expected_duration) {
-		this.response.setHeader('Expected-Duration', Number(options.expected_duration / 1000).toFixed(2));
+	if (postponement) {
+		return postponement.showPostponementMessage(this);
 	}
 
-	// Write the headers & 202 status
-	this.response.writeHead(202);
+	let response = this.response;
 
-	// End the response
-	this.response.end('The response has been postponed, you can find it at <a href="' + url + '">' + url + '</a>');
+	this.postponed_response = response;
+
+	// Make sure the scene id exists
+	this.createScene();
+
+	postponement = session.postpone(this, options);
+
+	if (options.put_in_queue) {
+		postponement.putInQueue();
+	}
+
+	if (options.show_postponement_message !== false) {
+		postponement.showPostponementMessage();
+	}
 
 	// Nullify the response
 	this.response = null;
 
 	// Set the original url
-	this.overrideResponseUrl(this.url)
+	this.overrideResponseUrl(this.url);
+
+	// Return the postponement
+	return postponement;
 });
 
 /**
  * Set the response url
  *
+ * @deprecated   Use {@link #setResponseUrl} instead
+ *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.2.5
- * @version  1.2.5
+ * @version  1.3.0
  *
  * @param    {String|RURL}   url
  */
 Conduit.setMethod(function overrideResponseUrl(url) {
+	return this.setResponseUrl(url);
+});
 
-	if (typeof url != 'string') {
-		url = String(url);
+/**
+ * Set the response url
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {String|RURL|Boolean}   new_url
+ */
+Conduit.setMethod(function setResponseUrl(new_url) {
+
+	if (new_url == null) {
+		return;
 	}
 
-	this.setHeader('x-history-url', url);
-	this.expose('redirected_to', url);
+	if (!new_url) {
+		this.renderer.history = false;
+		return;
+	} else {
+		this.renderer.history = true;
+	}
+
+	if (typeof new_url != 'string') {
+		new_url = String(new_url);
+	}
+
+	this.setHeader('x-history-url', new_url);
+	this.expose('redirected_to', new_url);
 });
 
 /**
@@ -1409,15 +1503,17 @@ Conduit.setMethod(function redirect(status, options) {
 /**
  * Respond with an error
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {Nulber}  status       Response statuscode
  * @param    {Error}   message      Optional error to send
- * @param    {Boolean} printError   Print the error, defaults to true
+ * @param    {Boolean} print_error  Print the error, defaults to true
  */
-Conduit.setMethod(function error(status, message, printError) {
+Conduit.setMethod(function error(status, message, print_error) {
+
+	let print_dev = false;
 
 	if (status instanceof Classes.Alchemy.Error.HTTP) {
 		message = status;
@@ -1439,14 +1535,33 @@ Conduit.setMethod(function error(status, message, printError) {
 		message = error;
 	}
 
-	let subject = 'Error found on ' + this.original_path + '';
+	let is_400 = (status >= 400 && status <= 500);
 
-	if (printError === false) {
-		log.error(subject + ':\n' + message);
-	} else if (message instanceof Error) {
-		alchemy.printLog('error', [subject, String(message), message], {err: message, level: -2});
-	} else {
-		log.error(subject + ':\n' + message);
+	if (alchemy.settings.environment == 'dev') {
+		print_dev = true;
+	}
+
+	if (print_error == null) {
+		if (is_400) {
+			print_error = false;
+		} else {
+			print_error = true;
+		}
+	}
+
+	if (print_dev) {
+		let subject = 'Error found on ' + this.original_path + '';
+		log.error(subject + ':\n' + message, this);
+	} else if (print_error) {
+		let subject = 'Error found on ' + this.original_path + '';
+
+		if (is_400) {
+			log.error(subject + ':\n' + message);
+		} else if (message instanceof Error) {
+			alchemy.printLog('error', [subject, String(message), message], {err: message, level: -2});
+		} else {
+			log.error(subject + ':\n' + message);
+		}
 	}
 
 	// Make sure the client doesn't expect compression
@@ -1470,7 +1585,12 @@ Conduit.setMethod(function error(status, message, printError) {
 		} else {
 			this.set('status', status);
 			this.set('message', message);
-			this.render(['error/' + status, 'error/unknown']);
+
+			if (alchemy.isTooBusyForRequests()) {
+				this._end(`Error ${status}:\n${message}`);
+			} else {
+				this.render(['error/' + status, 'error/unknown']);
+			}
 		}
 	} else {
 		// Requests for images or scripts just get a non-expensive string response
@@ -1583,9 +1703,9 @@ Conduit.setMethod(function notModified() {
 /**
  * Respond with text. Objects get JSON-dry encoded
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String|Object}   message
  */
@@ -1659,7 +1779,7 @@ Conduit.setMethod(function end(message) {
 
 	// Compress the output if the client accepts it,
 	// but only if the file is at least 150 bytes
-	if (alchemy.settings.compression && message.length > 150 && this.accepts('gzip')) {
+	if (alchemy.settings.compression !== false && message.length > 150 && this.accepts('gzip')) {
 
 		// Set the decompressed content-length for use in progress bars
 		this.setHeader('x-decompressed-content-length', Buffer.byteLength(message));
@@ -1683,9 +1803,9 @@ Conduit.setMethod(function end(message) {
 /**
  * Call the actual end method
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  */
 Conduit.setMethod(function _end(message, encoding = 'utf-8') {
 
@@ -1701,6 +1821,8 @@ Conduit.setMethod(function _end(message, encoding = 'utf-8') {
 
 		this._end_arguments = args;
 
+		this.emit('after-postponed-end', args);
+
 		return;
 	}
 
@@ -1865,295 +1987,237 @@ function bufferToStream(buffer) {
 }
 
 /**
- * Send a file to the browser.
- * Uses cache-control by default.
+ * Send a file to the browser
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String}   path      The path on the server to send to the browser
  * @param    {Object}   options   Options, including headers
  */
-Conduit.setMethod(function serveFile(path, options) {
+Conduit.setTypedMethod([Types.String, Types.Object.optional()], function serveFile(path, options = {}) {
 
-	var that = this,
-	    tasks = [],
-	    stats,
-	    isStream;
-
-	// Create an options object if it doesn't exist yet
-	if (options == null) {
-		options = {};
-	}
+	let file = FILECACHE.get(path);
 
-	// Error handling function
-	if (!options.onError) {
-		options.onError = function onError(err) {
-			that.notFound(err);
-		};
+	if (!file) {
+		file = new Classes.Alchemy.Inode.File(path);
 	}
 
-	// See if we have a stats object
-	if (Object.isObject(path)) {
-
-		if (Buffer.isBuffer(path)) {
-			path = bufferToStream(path);
-		}
+	return this.serveFile(file, options);
+});
 
-		if (path.readable) {
-			isStream = true;
-			stats = {
-				mimetype: 'application/octet-stream'
-			};
-		} else {
-			stats = path;
-		}
-	} else {
-		stats = fileCache[path];
+/**
+ * Send a file to the browser
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.2.0
+ * @version  1.3.0
+ *
+ * @param    {Alchemy.Inode.File}   file      The file to serve
+ * @param    {Object}               options   Options, including headers
+ */
+Conduit.setTypedMethod([Types.Alchemy.Inode.File, Types.Object.optional()], async function serveFile(file, options = {}) {
 
-		if (stats == null) {
-			stats = {
-				path: path
-			};
-		}
+	if (file.path && !FILECACHE.has(file.path)) {
+		FILECACHE.set(file.path, file);
+	}
+	
+	if (alchemy.settings.cache && (!options.cache_time && options.cache_time !== false)) {
+		let stats = await file.getStats();
+		options.cache_time = stats.mtime;
 	}
 
-	// Don't check for file information when it's a stream
-	if (!isStream) {
-
-		if (!stats.path) {
-			return options.onError(new Error('No file to serve'));
-		}
-
-		// Make sure the stats object is in the cache
-		if (fileCache[stats.path] == null) {
-			fileCache[stats.path] = stats;
-		}
-
-		// Get file stats if it isn't available yet
-		if (stats.mtime == null) {
-			tasks.push(function getFileStats(next) {
-
-				fs.stat(stats.path, function gotStats(err, fileStats) {
-
-					if (err) {
-						stats.err = err;
-						stats.mtime = new Date();
-					} else {
-						Object.assign(stats, fileStats);
-					}
-
-					next();
-				});
-			});
-		}
-
-		// Get the mimetype if it isn't available yet
-		if (!options.mimetype && stats.mimetype == null) {
-			tasks.push(function getMimetype(next) {
-
-				// Don't use libmime if it isn't loaded,
-				// that could be the case on NW.js
-				if (!libmime) {
-					return next();
-				}
-
-				// Lookup the mimetype by the extension alone
-				stats.mimetype = libmime.getType(stats.path);
-
-				// Return the result if a valid mimetype was found
-				if (stats.mimetype !== 'application/octet-stream') {
-					return next();
-				}
+	if (!options.mimetype) {
+		options.mimetype = await file.getMimetype();
+	}
 
-				// If no mimetype was found,
-				// see if we can find it using the original path (for resized images)
-				if (options.original_path) {
-					stats.mimetype = libmime.getType(options.original_path);
+	if (!options.filename) {
+		options.filename = file.name;
+	}
+	
+	return this.serveFile(file.createReadStream(), options);
+});
 
-					if (stats.mimetype !== 'application/octet-stream') {
-						return next();
-					}
-				}
+/**
+ * Send a buffer to the client
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Stream}   buffer    The buffer to send
+ * @param    {Object}   options   Options, including headers
+ */
+Conduit.setTypedMethod([Buffer, Types.Object.optional()], function serveFile(buffer, options = {}) {
+	return this.serveFile(bufferToStream(buffer), options);
+});
 
-				// "magic" currently doesn't work in nw.js
-				if (Blast.isNW) {
-					return next();
-				}
+/**
+ * Send a stream to the client
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Stream}   stream    The stream to send
+ * @param    {Object}   options   Options, including headers
+ */
+Conduit.setTypedMethod([Types.Stream, Types.Object.optional()], function serveFile(stream, options = {}) {
 
-				// Don't try to use magic if it's not loaded
-				if (!getMagic()) {
-					return next();
-				}
+	let is_text = false;
 
-				// Look inside the data (using "magic") for a better mimetype
-				magic.detectFile(stats.path, function detectedMimetype(err, result) {
+	if (options.mimetype && RX_TEXT.test(options.mimetype)) {
+		options.mimetype += '; charset=utf-8';
+		is_text = true;
+	}
 
-					if (!err) {
-						stats.mimetype = result;
-					}
+	if (alchemy.settings.cache === false) {
+		options.cache_time = null;
+	}
 
-					next();
-				});
-			});
-		}
+	if (options.compress == null) {
+		options.compress = is_text;
 	}
 
-	Function.parallel(tasks, function gotFileInfo(err) {
+	if (options.compress && (alchemy.settings.compression === false || !this.accepts('gzip'))) {
+		options.compress = false;
+	}
 
-		var disposition,
-		    outStream,
-		    mimetype,
-		    headers,
-		    isText,
-		    since,
-		    key;
+	if (options.cache_time && !alchemy.settings.cache) {
+		options.cache_time = false;
+	}
 
-		if (err) {
-			return that.error(err);
-		}
+	if (!options.onError) {
+		options.onError = err => this.notFound(err);
+	}
 
-		if (stats.err) {
-			return options.onError(stats.err);
-		}
+	return this._sendStream(stream, options);
+});
 
-		if (!isStream && !stats.path) {
-			return options.onError(new Error('File not found'));
-		}
+/**
+ * Send a stream to the client
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Stream}   stream    The stream to send
+ * @param    {Object}   options   Options, including headers
+ */
+Conduit.setMethod(function _sendStream(stream, options) {
 
-		// Check the if-modified-since header if it's supplied
-		if (alchemy.settings.cache !== false && that.headers['if-modified-since'] != null) {
+	if (options.cache_time) {
+		let modified_since = this.headers['if-modified-since'];
 
-			// Turn the string into a date
-			since = new Date(that.headers['if-modified-since']);
+		if (modified_since != null) {
+			let since = new Date(modified_since);
 
 			// If the file's modifytime is smaller or equal to the since time,
 			// don't serve the contents!
-			if (stats.mtime <= since) {
-				return that.notModified();
-			}
-		}
-
-		mimetype = stats.mimetype;
-
-		// If we get a general mimetype, and an alternative is provided, use that one
-		if (!mimetype || mimetype === 'application/octet-stream') {
-			if (options.mimetype != null) {
-				mimetype = options.mimetype;
+			if (options.cache_time <= since) {
+				return this.notModified();
 			}
 		}
 
-		isText = /svg|xml|javascript|text/.test(mimetype);
-
-		// Serve text files as utf-8
-		if (isText) {
-			mimetype += '; charset=utf-8';
-		}
-
-		that.setHeader('content-type', mimetype);
-
-		// Setting the disposition makes the browser download the file
-		// This is on by default, but can be disabled
-		if (options.disposition == 'inline') {
-			disposition = 'inline';
-
-			if (options.filename) {
-				disposition += '; filename=' + JSON.stringify(options.filename)
-			}
-
-			that.setHeader('content-disposition', disposition);
-		} else if (options.disposition !== false) {
-			if (options.filename) {
-				disposition = 'attachment; filename=' + JSON.stringify(options.filename);
-			} else {
-				disposition = 'attachment';
-			}
+		// Allow the browser to cache this for 60 minutes,
+		// after which it has to revalidate the content
+		// by seeing if it has been modified
+		this.setHeader('cache-control', 'public, max-age=3600, must-revalidate');
+		this.setHeader('last-modified', options.cache_time.toGMTString());
+	} else {
+		this.setHeader('cache-control', 'no-cache');
+	}
 
-			that.setHeader('content-disposition', disposition);
-		}
+	let disposition,
+	    key;
 
-		if (stats.mtime && alchemy.settings.cache) {
-			// Allow the browser to cache this for 60 minutes,
-			// after which it has to revalidate the content
-			// by seeing if it has been modified
-			that.setHeader('cache-control', 'public, max-age=3600, must-revalidate');
-			that.setHeader('last-modified', stats.mtime.toGMTString());
-		} else if (!alchemy.settings.cache) {
-			that.setHeader('cache-control', 'no-cache');
-		}
+	if (options.mimetype) {
+		this.setHeader('content-type', options.mimetype);
+	}
 
-		for (key in options.headers) {
-			that.setHeader(key, options.headers[key]);
-		}
+	// Setting the disposition makes the browser download the file
+	// This is on by default, but can be disabled
+	if (options.disposition == 'inline') {
+		disposition = 'inline';
 
-		// End now if it's just a HEAD request
-		if (that.method == 'head') {
-			return that.end();
+		if (options.filename) {
+			disposition += '; filename=' + JSON.stringify(options.filename)
 		}
 
-		if (isStream) {
-			outStream = path;
+		this.setHeader('content-disposition', disposition);
+	} else if (options.disposition !== false) {
+		if (options.filename) {
+			disposition = 'attachment; filename=' + JSON.stringify(options.filename);
 		} else {
-			outStream = fs.createReadStream(path, {bufferSize: 64*1024});
-
-			// Listen for file errors
-			outStream.on('error', options.onError);
+			disposition = 'attachment';
 		}
 
-		// Compress text responses
-		if (isText && alchemy.settings.compression && that.accepts('gzip')) {
+		this.setHeader('content-disposition', disposition);
+	}
+
+	// Set all the headers
+	for (key in options.headers) {
+		this.setHeader(key, options.headers[key]);
+	}
 
-			// Set the gzip header
-			that.setHeader('content-encoding', 'gzip');
-			that.setHeader('vary', 'accept-encoding');
+	// Don't send anything if it's a HEAD request
+	if (this.method == 'head') {
+		return this.end();
+	}
 
-			// Create the gzip stream
-			outStream = outStream.pipe(zlib.createGzip());
-		}
+	const response = this.response;
+	let out_stream = stream;
 
-		// If we received a stream as parameter...
-		if (isStream) {
-			that.response.on('end', cleanup);
-			that.response.on('finish', cleanup);
-			that.response.on('error', cleanup);
-			that.response.on('close', cleanup);
-		}
+	if (options.compress) {
+		// Set the gzip header
+		this.setHeader('content-encoding', 'gzip');
+		this.setHeader('vary', 'accept-encoding');
 
-		function cleanup() {
+		// Create the gzip stream
+		out_stream = out_stream.pipe(zlib.createGzip());
+	}
 
+	if (options.cleanup_stream) {
+		const cleanup = function cleanupOriginalStream() {
 			// Remove all pipes
-			outStream.unpipe();
+			stream.unpipe();
 
-			if (outStream.destroy) {
-				outStream.destroy();
-			} else if (outStream.end) {
-				outStream.end();
+			if (stream.destroy) {
+				stream.destroy();
+			} else if (stream.end) {
+				stream.end();
 			}
-		}
+		};
 
-		// Send the headers
-		for (key in that.response_headers) {
-			that.response.setHeader(key, that.response_headers[key]);
-		}
+		response.on('end', cleanup);
+		response.on('finish', cleanup);
+		response.on('error', cleanup);
+		response.on('close', cleanup);
+	}
 
-		if (that.new_cookie_header.length) {
-			that.response.setHeader('set-cookie', that.new_cookie_header);
-		}
+	// Set the response headers
+	for (key in this.response_headers) {
+		response.setHeader(key, this.response_headers[key]);
+	}
+
+	if (this.new_cookie_header.length) {
+		response.setHeader('set-cookie', this.new_cookie_header);
+	}
 
-		that.response.statusCode = 200;
+	// If we got this far, the file has been found!
+	response.statusCode = 200;
 
-		// Stream the file to the client
-		outStream.pipe(that.response);
-	});
+	// Actually stream the contents to the client
+	out_stream.pipe(response);
 });
 
 /**
  * Create a session
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.1
  *
  * @param    {Boolean}   create   Create a session if none exist
  *
@@ -2161,16 +2225,16 @@ Conduit.setMethod(function serveFile(path, options) {
  */
 Conduit.setMethod(function getSession(allow_create = true) {
 
-	var cookie_name,
-	    fingerprint,
-	    session_id,
-	    session;
-
 	// Only do this once per request
 	if (this.sessionData != null) {
 		return this.sessionData;
 	}
 
+	let cookie_name,
+	    fingerprint,
+	    session_id,
+	    session;
+
 	// Set the name of the cookie (could change in the future)
 	cookie_name = alchemy.settings.session_key || 'alchemy_sid';
 
@@ -2307,6 +2371,24 @@ Conduit.setMethod(function routeParam(name) {
 	return this.params[name];
 });
 
+/**
+ * Set route parameters
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+Conduit.setMethod(function setRouteParameters(data) {
+
+	if (!this.params) {
+		this.params = {};
+	}
+
+	if (data) {
+		Object.assign(this.params, data);
+	}
+});
+
 /**
  * Get/set a cookie
  *
@@ -2370,7 +2452,7 @@ Conduit.setMethod(function cookie(name, value, options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String}   name
  * @param    {Mixed}    value
@@ -2382,7 +2464,7 @@ Conduit.setMethod(function setHeader(name, value) {
 	}
 
 	if (this.websocket) {
-		throw new Error("Can't set a header on a websocket connection");
+		throw new Error("Can't set header `" + name + "` on a websocket connection");
 	}
 
 	this.response_headers[name] = value;
@@ -2511,6 +2593,72 @@ Conduit.setMethod(function supports(feature) {
 	return null;
 });
 
+/**
+ * Should this request be delayed because the server is too busy?
+ * This performs an early check, the controller might also check this later.
+ * This is mainly so we can prevent Server-Side-Renders from happening
+ * when the system is already overloaded.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.1
+ * @version  1.3.1
+ *
+ * @return   {Boolean}
+ */
+Conduit.setMethod(function shouldBePostponed() {
+
+	if (!alchemy.settings.postpone_requests_on_overload) {
+		return false;
+	}
+
+	const route = this.route;
+
+	// If no route is found, it can be allowed.
+	// Most of the time this means it's a middleware-request
+	// (like stylesheets, images, scripts, ...)
+	// But also 404s (This can be delayed later by the controller)
+	if (route == null) {
+		return false;
+	}
+
+	// Some routes can't even be postponed
+	if (!route.can_be_postponed) {
+		return false;
+	}
+
+	// If alchemy isn't even too busy, it's obviously allowed
+	if (!alchemy.isTooBusyForRequests()) {
+		return false;
+	}
+
+	// Some users have the permission to skip postponements
+	if (this.hasPermission('alchemy.queue.skip')) {
+		return false;
+	}
+
+	let session = this.getSession(false);
+
+	if (session) {
+
+		// Do not postpone clients that have already been in the queue
+		if (session.hasAlreadyQueued()) {
+			return false;
+		}
+
+		// Do not postpone clients that have already rendered something
+		if (session.render_counter > 0 && session.is_active) {
+			return false;
+		}
+	}
+
+	// AJAX requests are allowed a bit more
+	if (this.ajax) {
+		return alchemy.isTooBusyForAjax();
+	}
+
+	return true;
+});
+
 /**
  * Broadcast data to every connected user
  *