@reldens/server-utils 0.42.0 → 0.44.0

package/lib/http2-cdn-server.js

@@ -5,11 +5,13 @@
  */
 
 const http2 = require('http2');
-const path = require('path');
 const { FileHandler } = require('./file-handler');
 const { ServerDefaultConfigurations } = require('./server-default-configurations');
 const { ServerFactoryUtils } = require('./server-factory-utils');
 const { ServerHeaders } = require('./server-headers');
+const { ServerErrorHandler } = require('./server-error-handler');
+const { EventDispatcher } = require('./event-dispatcher');
+const { CdnRequestHandler } = require('./cdn-request-handler');
 
 class Http2CdnServer
 {
@@ -34,6 +36,11 @@ class Http2CdnServer
         this.corsHeaders = this.serverHeaders.http2CorsHeaders;
         this.securityHeaders = this.serverHeaders.http2SecurityHeaders;
         this.varyHeader = this.serverHeaders.http2VaryHeader;
+        this.onError = null;
+        this.onRequestSuccess = null;
+        this.onRequestError = null;
+        this.onEvent = null;
+        this.requestHandler = new CdnRequestHandler(this);
     }
 
     create()
@@ -60,71 +67,167 @@ class Http2CdnServer
             }
         }
         this.http2Server = http2.createSecureServer(options);
-        this.setupStreamHandler();
+        this.setupEventHandlers();
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'cdn-server-created',
+            'http2CdnServer',
+            this,
+            {port: this.port, allowHTTP1: this.allowHTTP1}
+        );
         return true;
     }
 
-    setupStreamHandler()
+    setupEventHandlers()
     {
         this.http2Server.on('stream', (stream, headers) => {
             this.handleStream(stream, headers);
         });
+        this.http2Server.on('request', (req, res) => {
+            this.handleHttp1Request(req, res);
+        });
+        this.http2Server.on('error', (err) => {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'server-error',
+                err,
+                {port: this.port}
+            );
+        });
+        this.http2Server.on('tlsClientError', (err, tlsSocket) => {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'tls-client-error',
+                err,
+                {port: this.port, remoteAddress: tlsSocket.remoteAddress}
+            );
+        });
+        this.http2Server.on('sessionError', (err) => {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'session-error',
+                err,
+                {port: this.port}
+            );
+        });
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'cdn-handlers-setup',
+            'http2CdnServer',
+            this,
+            {port: this.port}
+        );
     }
 
-    handleStream(stream, headers)
+    invokeRequestSuccess(requestData)
     {
-        let requestPath = headers[':path'];
-        if(!requestPath){
-            stream.respond({':status': 400});
-            stream.end();
+        if('function' !== typeof this.onRequestSuccess){
             return;
         }
-        let requestOrigin = headers['origin'] || '';
-        let allowedOrigin = ServerFactoryUtils.validateOrigin(requestOrigin, this.corsOrigins, this.corsAllowAll);
-        if('OPTIONS' === headers[':method']){
-            let optionsHeaders = {':status': 200};
-            if(allowedOrigin){
-                optionsHeaders['access-control-allow-origin'] = allowedOrigin;
-            }
-            optionsHeaders['access-control-allow-methods'] = this.corsMethods;
-            optionsHeaders['access-control-allow-headers'] = this.corsHeaders;
-            stream.respond(optionsHeaders);
-            stream.end();
-            return;
-        }
-        let filePath = this.resolveFilePath(requestPath);
-        if(!filePath){
-            stream.respond({':status': 404});
-            stream.end();
+        this.onRequestSuccess(requestData);
+    }
+
+    invokeRequestError(errorData)
+    {
+        if('function' !== typeof this.onRequestError){
             return;
         }
-        let ext = path.extname(filePath);
-        let cacheAge = ServerFactoryUtils.getCacheConfigForPath(filePath, this.cacheConfig);
-        let responseHeaders = {':status': 200};
-        let securityKeys = Object.keys(this.securityHeaders);
-        for(let headerKey of securityKeys){
-            responseHeaders[headerKey] = this.securityHeaders[headerKey];
-        }
-        if(allowedOrigin){
-            responseHeaders['access-control-allow-origin'] = allowedOrigin;
-        }
-        if(this.varyHeader){
-            responseHeaders['vary'] = this.varyHeader;
-        }
-        if(cacheAge){
-            responseHeaders['cache-control'] = 'public, max-age='+cacheAge+', immutable';
-        }
-        if(this.mimeTypes[ext]){
-            responseHeaders['content-type'] = this.mimeTypes[ext];
-        }
-        stream.respondWithFile(filePath, responseHeaders);
+        this.onRequestError(errorData);
+    }
+
+    handleStream(stream, headers)
+    {
+        let requestContext = {
+            isHttp2: true,
+            method: headers[':method'],
+            path: headers[':path'],
+            hostname: headers['x-forwarded-host'] || headers[':authority'],
+            origin: headers['origin'] || '',
+            ip: null,
+            userAgent: null,
+            sendResponse: (statusCode, responseHeaders) => {
+                if(responseHeaders){
+                    stream.respond(responseHeaders);
+                    stream.end();
+                    return;
+                }
+                stream.respond({':status': statusCode});
+                stream.end();
+            },
+            sendFile: (filePath, responseHeaders) => {
+                stream.on('error', (err) => {
+                    requestContext.errorCallback(err);
+                });
+                stream.on('finish', () => {
+                    requestContext.successCallback();
+                });
+                stream.respondWithFile(filePath, responseHeaders);
+            },
+            onSuccess: (callback) => {
+                requestContext.successCallback = callback;
+            },
+            onError: (callback) => {
+                requestContext.errorCallback = callback;
+            }
+        };
+        this.requestHandler.handleRequest(requestContext);
+    }
+
+    handleHttp1Request(req, res)
+    {
+        let requestContext = {
+            isHttp2: false,
+            method: req.method,
+            path: req.url,
+            hostname: req.headers['x-forwarded-host'] || req.headers.host,
+            origin: req.headers['origin'] || '',
+            ip: req.headers['x-forwarded-for'] || req.socket.remoteAddress,
+            userAgent: req.headers['user-agent'],
+            sendResponse: (statusCode, responseHeaders) => {
+                if(responseHeaders){
+                    res.writeHead(statusCode, responseHeaders);
+                    res.end();
+                    return;
+                }
+                res.writeHead(statusCode);
+                res.end();
+            },
+            sendFile: (filePath, responseHeaders) => {
+                let fileStream = FileHandler.createReadStream(filePath);
+                fileStream.on('error', (err) => {
+                    if(!res.headersSent){
+                        res.writeHead(500);
+                        res.end();
+                    }
+                    requestContext.errorCallback(err);
+                });
+                res.writeHead(200, responseHeaders);
+                fileStream.pipe(res);
+                res.on('finish', () => {
+                    requestContext.successCallback();
+                });
+            },
+            onSuccess: (callback) => {
+                requestContext.successCallback = callback;
+            },
+            onError: (callback) => {
+                requestContext.errorCallback = callback;
+            }
+        };
+        this.requestHandler.handleRequest(requestContext);
     }
 
     resolveFilePath(requestPath)
     {
         let cleanPath = ServerFactoryUtils.stripQueryString(requestPath);
         for(let staticPath of this.staticPaths){
-            let fullPath = path.join(staticPath, cleanPath);
+            let fullPath = FileHandler.joinPaths(staticPath, cleanPath);
             if(!FileHandler.exists(fullPath)){
                 continue;
             }
@@ -143,6 +246,13 @@ class Http2CdnServer
             return false;
         }
         this.http2Server.listen(this.port);
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'cdn-server-listening',
+            'http2CdnServer',
+            this,
+            {port: this.port}
+        );
         return true;
     }
 

package/lib/request-logger.js

@@ -0,0 +1,42 @@
+/**
+ *
+ * Reldens - RequestLogger
+ *
+ */
+
+class RequestLogger
+{
+
+    static createMiddleware(onRequestSuccess, onRequestError)
+    {
+        return (req, res, next) => {
+            let startTime = Date.now();
+            res.on('finish', () => {
+                let responseTime = Date.now()-startTime;
+                let requestData = {
+                    method: req.method,
+                    path: req.originalUrl,
+                    statusCode: res.statusCode,
+                    responseTime: responseTime,
+                    ip: req.headers['x-forwarded-for'] || req.ip,
+                    userAgent: req.get('user-agent'),
+                    hostname: req.headers['x-forwarded-host'] || req.get('host'),
+                    timestamp: new Date().toISOString()
+                };
+                if(400 <= res.statusCode){
+                    if('function' === typeof onRequestError){
+                        onRequestError(requestData);
+                    }
+                    return;
+                }
+                if('function' === typeof onRequestSuccess){
+                    onRequestSuccess(requestData);
+                }
+            });
+            next();
+        };
+    }
+
+}
+
+module.exports.RequestLogger = RequestLogger;

package/lib/server-error-handler.js

@@ -0,0 +1,25 @@
+/**
+ *
+ * Reldens - ServerErrorHandler
+ *
+ */
+
+class ServerErrorHandler
+{
+
+    static handleError(onErrorCallback, instanceName, instance, key, error, context = {})
+    {
+        if('function' !== typeof onErrorCallback){
+            return;
+        }
+        onErrorCallback({
+            [instanceName]: instance,
+            key: key,
+            error: error,
+            ...context
+        });
+    }
+
+}
+
+module.exports.ServerErrorHandler = ServerErrorHandler;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/server-utils",
     "scope": "@reldens",
-    "version": "0.42.0",
+    "version": "0.44.0",
     "description": "Reldens - Server Utils",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -36,7 +36,7 @@
         "url": "https://github.com/damian-pastorini/reldens-server-utils/issues"
     },
     "dependencies": {
-        "body-parser": "2.2.1",
+        "body-parser": "2.2.2",
         "compression": "1.8.1",
         "cors": "2.8.5",
         "express": "4.22.1",