slower 1.1.22 → 1.1.25

package/lib/router.js

@@ -1,7 +1,7 @@
 const http = require('http');
 const https = require('https');
 const fs = require('fs');
-const { clone, noop, slugify, isSparseEqual, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders, setResponseAssessors } = require('./utils');
+const { clone, noop, slugify, isSparseEqual, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders, setResponseAssessors, isPromise, UUID } = require('./utils');
 const mimetable = require('./mimetable.json');
 
 class Route {
@@ -36,6 +36,7 @@ class SlowerRouter {
         this.blockedMethodCallback = noop;
         this.tls = { use: false, key: null, cert: null };
         this.server = null;
+        this.connectionpool = {};
     }
 
     enableStrictHeaders () {
@@ -355,10 +356,9 @@ class SlowerRouter {
      * @category Router
      * @param {Number} port The port number the server will listen to.
      * @param {String} host The host's network interface address the server will listen into (use a falsy value or '0.0.0.0' for listening on all).
-     * @param {Function} callback The function to execute after starting the server.
-     * @returns {Object<http.Server>} The server instance 
+     * @returns {Promise<http.Server>} The server instance 
     */
-    start = function (port = 8080, host = undefined, callback = () => {}) {
+    start = async function (port = 8080, host = undefined) {
         let routes = this.routes;
         let middle = this.middleware;
         let fallback = this.fallback;
@@ -372,7 +372,15 @@ class SlowerRouter {
             this.server = http.createServer({}, mainServerHandler);
         }
 
-        function mainServerHandler (req, res) {
+        this.server.on('connection', (socket) => {
+            const id = UUID();
+            this.connectionpool[id] = socket;
+            socket.on('close', () => delete this.connectionpool[id]);
+            socket.on('error', () => delete this.connectionpool[id]);
+            socket.on('timeout', () => { this.connectionpool[id].destroy(); delete this.connectionpool[id]; });
+        });
+
+        async function mainServerHandler (req, res) {
             try {
                 // Sets local req.session object
                 setSocketLocals(req);
@@ -383,7 +391,8 @@ class SlowerRouter {
                 if (!!this.strictHeaders) setSocketSecurityHeaders(req); 
                 // Runs all middlewares
                 for (let i = 0; i < middle.length; i++) { 
-                    middle[i](req, res); 
+                    const rr = middle[i](req, res); 
+                    if (isPromise(rr)) await rr;
                     if (res.writableEnded) return; // if res.end() is caller early in a middleware
                 }
                 // Only respond to allowed methods with callbacks, else, use the default empty response.
@@ -398,13 +407,15 @@ class SlowerRouter {
                             )
                         ) {
                             i = routes.length;
-                            route.callback(req, res);
+                            const rr = route.callback(req, res);
+                            if (isPromise(rr)) await rr;
                             // if (res.writableEnded) return; // if res.end() was called
                             // else res.end(); // if res.end() was not called
                             return;
                         }
                     }
-                    fallback(req,res);
+                    const rr = fallback(req,res);
+                    if (isPromise(rr)) await rr;
                     if (!res.writableEnded) res.end(); 
                 } else {
                     blockedMethodCallback(req, res);
@@ -415,14 +426,48 @@ class SlowerRouter {
             }
         }
 
-        callback(this.server);
+        this.port = port;
+        this.host = host;
         if (!host) host = undefined; // Turn falsy values into undefined, for default behaviour
-        this.server.listen(port, host);
-        return this;
+        return new Promise((resolve, reject) => this.server.listen(port, host, () => resolve(this)));
     }
+    
+    /**
+     * 
+     * @param {Object} options 
+     * @returns 
+     * Options include:
+     * forceDisconnection: boolean (default: false) - If enabled, force sockets to disconnect after a 2 seconds timeout.
+     * instantClose: boolean (default: false) - Only relevant if 'forceDisconnection' is enabled. If enabled, force sockets to disconnect immediately.
+     * silent: boolean (default: true) - If set to false, show the disconnection status messages.
+     */
+    close = async function ({ forceDisconnection = false, instantClose = false, silent = true }) {
+        return new Promise (async (resolve, reject) => {
+            this.server.on('close', () => resolve());
+            this.server.on('error', (err) => reject(err));
+
+            // After this, no more sockets can connect, but the already connected ones, remain
+            this.server.close();
+            if (!silent) console.log('<> Shutting down server...');
 
-    close = function () {
-        this.server.close();
+            if (forceDisconnection) {
+                // wait 1 second before continuing
+                if (!instantClose) await new Promise ((resolve1, reject1) => setTimeout(resolve1, 1000));
+
+                // If there are sockets still connected (waiting for timeout), 
+                // wait until all disconnected or force all to disconnect after 2 seconds
+                if (!silent) {
+                    const activesockets = await new Promise((resolve2, reject2) => this.server.getConnections((err,count) => resolve2(count)));
+                    console.log(`<> Awaiting disconnection of active sockets [${activesockets}]`);
+                }
+
+                // wait 1 second and destroy the ones still connected
+                if (!instantClose) await new Promise ((resolve1, reject1) => setTimeout(resolve1, 1000));
+                for (let sock in this.connectionpool) {
+                    this.connectionpool[sock].destroy();
+                }
+            }
+        });
     }
 }
 

package/lib/utils.js

@@ -161,4 +161,12 @@ const toBool = [() => true, () => false];
 
 const clone = (object) => JSON.parse(JSON.stringify(object));
 
-module.exports = { clone, noop, slugify, isSparseEqual, toBool, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders, setResponseAssessors };
+const isPromise = obj => {
+    return obj !== null &&
+    (typeof obj === 'object' || typeof obj === 'function') &&
+    typeof obj.then === 'function';
+}
+
+const UUID = () => '################################'.replace(new RegExp(`[#]`, 'gim'), () => Math.random().toString(16)[6]);
+
+module.exports = { clone, noop, slugify, isSparseEqual, toBool, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders, setResponseAssessors, isPromise, UUID };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "slower",
-	"version": "1.1.22",
+	"version": "1.1.25",
 	"description": "A package for simple HTTP server routing.",
 	"main": "index.js",
 	"directories": {