@reldens/server-utils 0.43.0 → 0.45.0

package/lib/app-server-factory.js

@@ -10,6 +10,8 @@ const { ServerDefaultConfigurations } = require('./server-default-configurations
 const { ServerFactoryUtils } = require('./server-factory-utils');
 const { ServerHeaders } = require('./server-headers');
 const { ServerErrorHandler } = require('./server-error-handler');
+const { RequestLogger } = require('./request-logger');
+const { EventDispatcher } = require('./event-dispatcher');
 const { DevelopmentModeDetector } = require('./app-server-factory/development-mode-detector');
 const { ProtocolEnforcer } = require('./app-server-factory/protocol-enforcer');
 const { SecurityConfigurer } = require('./app-server-factory/security-configurer');
@@ -113,10 +115,14 @@ class AppServerFactory
         this.http2CdnCorsAllowAll = false;
         this.http2CdnMimeTypes = {};
         this.http2CdnCacheConfig = {};
+        this.http2CdnSecurityHeaders = {};
         this.http2CdnServer = false;
         this.reverseProxyEnabled = false;
         this.reverseProxyRules = [];
         this.onError = null;
+        this.onRequestSuccess = null;
+        this.onRequestError = null;
+        this.onEvent = null;
     }
 
     buildStaticHeaders(res, path)
@@ -148,6 +154,7 @@ class AppServerFactory
         this.setupCors();
         this.setupRateLimiting();
         this.setupRequestParsing();
+        this.setupRequestLogging();
         this.setupTrustedProxy();
         try {
             this.appServer = this.createServer();
@@ -161,6 +168,13 @@ class AppServerFactory
             }
             return false;
         }
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'app-server-created',
+            'appServerFactory',
+            this,
+            {port: this.port, useHttps: this.useHttps, isDevelopmentMode: this.isDevelopmentMode}
+        );
         if(this.http2CdnEnabled){
             if(!this.createHttp2CdnServer()){
                 this.error = {message: 'The createHttp2CdnServer() returned false.'};
@@ -190,7 +204,13 @@ class AppServerFactory
         }
         this.http2CdnServer.corsOrigins = this.http2CdnCorsOrigins;
         this.http2CdnServer.corsAllowAll = this.http2CdnCorsAllowAll;
+        if(this.http2CdnSecurityHeaders && 0 < Object.keys(this.http2CdnSecurityHeaders).length){
+            this.http2CdnServer.securityHeaders = this.http2CdnSecurityHeaders;
+        }
         this.http2CdnServer.onError = this.onError;
+        this.http2CdnServer.onRequestSuccess = this.onRequestSuccess;
+        this.http2CdnServer.onRequestError = this.onRequestError;
+        this.http2CdnServer.onEvent = this.onEvent;
         if(!this.http2CdnServer.create()){
             this.error = this.http2CdnServer.error;
             return false;
@@ -199,6 +219,13 @@ class AppServerFactory
             this.error = this.http2CdnServer.error;
             return false;
         }
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'http2-cdn-created',
+            'appServerFactory',
+            this,
+            {port: this.http2CdnPort}
+        );
         return true;
     }
 
@@ -226,7 +253,8 @@ class AppServerFactory
     {
         let detectConfig = {
             developmentDomains: this.developmentDomains,
-            domains: this.domains
+            domains: this.domains,
+            onEvent: this.onEvent
         };
         if(0 < this.developmentPatterns.length){
             detectConfig['developmentPatterns'] = this.developmentPatterns;
@@ -260,7 +288,8 @@ class AppServerFactory
         this.protocolEnforcer.setup(this.app, {
             isDevelopmentMode: this.isDevelopmentMode,
             useHttps: this.useHttps,
-            enforceProtocol: this.enforceProtocol
+            enforceProtocol: this.enforceProtocol,
+            onEvent: this.onEvent
         });
     }
 
@@ -270,11 +299,13 @@ class AppServerFactory
             isDevelopmentMode: this.isDevelopmentMode,
             useHelmet: this.useHelmet,
             helmetConfig: this.helmetConfig,
-            developmentExternalDomains: this.developmentExternalDomains
+            developmentExternalDomains: this.developmentExternalDomains,
+            onEvent: this.onEvent
         });
         this.securityConfigurer.setupXssProtection(this.app, {
             useXssProtection: this.useXssProtection,
-            sanitizeOptions: this.sanitizeOptions
+            sanitizeOptions: this.sanitizeOptions,
+            onEvent: this.onEvent
         });
     }
 
@@ -291,7 +322,8 @@ class AppServerFactory
         let corsConfig = {
             isDevelopmentMode: this.isDevelopmentMode,
             useCors: this.useCors,
-            corsOrigin: this.corsOrigin
+            corsOrigin: this.corsOrigin,
+            onEvent: this.onEvent
         };
         if(0 < this.corsMethods.length){
             corsConfig['corsMethods'] = this.corsMethods;
@@ -321,7 +353,8 @@ class AppServerFactory
             maxRequests: this.maxRequests,
             developmentMultiplier: this.developmentMultiplier,
             applyKeyGenerator: this.applyKeyGenerator,
-            tooManyRequestsMessage: this.tooManyRequestsMessage
+            tooManyRequestsMessage: this.tooManyRequestsMessage,
+            onEvent: this.onEvent
         });
     }
 
@@ -345,6 +378,14 @@ class AppServerFactory
         }
     }
 
+    setupRequestLogging()
+    {
+        if(!this.onRequestSuccess && !this.onRequestError){
+            return;
+        }
+        this.app.use(RequestLogger.createMiddleware(this.onRequestSuccess, this.onRequestError));
+    }
+
     setupReverseProxy()
     {
         if(!this.reverseProxyEnabled || 0 === this.reverseProxyRules.length){
@@ -354,7 +395,8 @@ class AppServerFactory
             reverseProxyRules: this.reverseProxyRules,
             isDevelopmentMode: this.isDevelopmentMode,
             useVirtualHosts: this.useVirtualHosts,
-            onError: this.onError
+            onError: this.onError,
+            onEvent: this.onEvent
         });
     }
 
@@ -446,7 +488,15 @@ class AppServerFactory
     createServer()
     {
         if(!this.useHttps){
-            return http.createServer(this.app);
+            let httpServer = http.createServer(this.app);
+            EventDispatcher.dispatch(
+                this.onEvent,
+                'http-server-created',
+                'appServerFactory',
+                this,
+                {port: this.port}
+            );
+            return httpServer;
         }
         if(this.useVirtualHosts && 0 < this.domains.length){
             return this.createHttpsServerWithSNI();
@@ -473,7 +523,15 @@ class AppServerFactory
                 credentials.ca = ca;
             }
         }
-        return https.createServer(credentials, this.app);
+        let httpsServer = https.createServer(credentials, this.app);
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'https-server-created',
+            'appServerFactory',
+            this,
+            {port: this.port}
+        );
+        return httpsServer;
     }
 
     createHttpsServerWithSNI()
@@ -517,7 +575,15 @@ class AppServerFactory
             let ctx = tls.createSecureContext({key, cert});
             callback(null, ctx);
         };
-        return https.createServer(httpsOptions, this.app);
+        let sniServer = https.createServer(httpsOptions, this.app);
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'sni-server-created',
+            'appServerFactory',
+            this,
+            {port: this.port, domainsCount: this.domains.length}
+        );
+        return sniServer;
     }
 
     loadDefaultCredentials()
@@ -543,6 +609,13 @@ class AppServerFactory
             return false;
         }
         this.appServer.listen(listenPort);
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'app-server-listening',
+            'appServerFactory',
+            this,
+            {port: listenPort}
+        );
         return true;
     }
 
@@ -604,6 +677,13 @@ class AppServerFactory
             return false;
         }
         this.domains.push(domainConfig);
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'domain-added',
+            'appServerFactory',
+            this,
+            {hostname: domainConfig.hostname}
+        );
         return true;
     }
 

package/lib/cdn-request-handler.js

@@ -0,0 +1,130 @@
+/**
+ *
+ * Reldens - CdnRequestHandler
+ *
+ */
+
+const { FileHandler } = require('./file-handler');
+const { ServerFactoryUtils } = require('./server-factory-utils');
+const { ServerErrorHandler } = require('./server-error-handler');
+
+class CdnRequestHandler
+{
+
+    constructor(cdnServer)
+    {
+        this.cdnServer = cdnServer;
+    }
+
+    handleRequest(requestContext)
+    {
+        let startTime = Date.now();
+        let requestData = {
+            serverType: 'cdn',
+            method: requestContext.method,
+            path: requestContext.path,
+            hostname: requestContext.hostname,
+            statusCode: 200,
+            responseTime: 0,
+            ip: requestContext.ip,
+            userAgent: requestContext.userAgent,
+            timestamp: new Date().toISOString()
+        };
+        try {
+            if(!requestData.path){
+                requestContext.sendResponse(400);
+                return;
+            }
+            let requestOrigin = requestContext.origin || '';
+            let allowedOrigin = ServerFactoryUtils.validateOrigin(
+                requestOrigin,
+                this.cdnServer.corsOrigins,
+                this.cdnServer.corsAllowAll
+            );
+            if('OPTIONS' === requestData.method){
+                this.handleOptionsRequest(requestContext, allowedOrigin);
+                return;
+            }
+            let filePath = this.cdnServer.resolveFilePath(requestData.path);
+            if(!filePath){
+                requestData.statusCode = 404;
+                requestData.responseTime = Date.now()-startTime;
+                requestContext.sendResponse(404);
+                this.cdnServer.invokeRequestError(requestData);
+                return;
+            }
+            let responseHeaders = this.buildResponseHeaders(allowedOrigin, filePath, requestContext.isHttp2);
+            requestContext.onSuccess(() => {
+                requestData.responseTime = Date.now()-startTime;
+                this.cdnServer.invokeRequestSuccess(requestData);
+            });
+            requestContext.onError((err) => {
+                requestData.statusCode = 500;
+                requestData.responseTime = Date.now()-startTime;
+                requestData.error = err;
+                ServerErrorHandler.handleError(
+                    this.cdnServer.onError,
+                    'http2CdnServer',
+                    this.cdnServer,
+                    requestContext.isHttp2 ? 'stream-error' : 'http1-stream-error',
+                    err,
+                    {port: this.cdnServer.port, path: requestData.path}
+                );
+                this.cdnServer.invokeRequestError(requestData);
+            });
+            requestContext.sendFile(filePath, responseHeaders);
+        } catch (err) {
+            requestData.statusCode = 500;
+            requestData.responseTime = Date.now()-startTime;
+            requestData.error = err;
+            ServerErrorHandler.handleError(
+                this.cdnServer.onError,
+                'http2CdnServer',
+                this.cdnServer,
+                requestContext.isHttp2 ? 'handle-stream-error' : 'handle-http1-request-error',
+                err,
+                {port: this.cdnServer.port, path: requestData.path}
+            );
+            this.cdnServer.invokeRequestError(requestData);
+            requestContext.sendResponse(500);
+        }
+    }
+
+    handleOptionsRequest(requestContext, allowedOrigin)
+    {
+        let optionsHeaders = requestContext.isHttp2 ? {':status': 200} : {};
+        if(allowedOrigin){
+            optionsHeaders['access-control-allow-origin'] = allowedOrigin;
+        }
+        optionsHeaders['access-control-allow-methods'] = this.cdnServer.corsMethods;
+        optionsHeaders['access-control-allow-headers'] = this.cdnServer.corsHeaders;
+        requestContext.sendResponse(200, optionsHeaders);
+    }
+
+    buildResponseHeaders(allowedOrigin, filePath, isHttp2)
+    {
+        let ext = FileHandler.extension(filePath);
+        let cacheAge = ServerFactoryUtils.getCacheConfigForPath(filePath, this.cdnServer.cacheConfig);
+        let responseHeaders = isHttp2 ? {':status': 200} : {};
+        let securityKeys = Object.keys(this.cdnServer.securityHeaders);
+        for(let headerKey of securityKeys){
+            responseHeaders[headerKey] = this.cdnServer.securityHeaders[headerKey];
+        }
+        if(allowedOrigin){
+            responseHeaders['access-control-allow-origin'] = allowedOrigin;
+        }
+        if(this.cdnServer.varyHeader){
+            responseHeaders['vary'] = this.cdnServer.varyHeader;
+        }
+        if(cacheAge){
+            responseHeaders['cache-control'] = 'public, max-age='+cacheAge+', immutable';
+        }
+        if(this.cdnServer.mimeTypes[ext]){
+            responseHeaders['content-type'] = this.cdnServer.mimeTypes[ext];
+        }
+        return responseHeaders;
+    }
+
+}
+
+module.exports.CdnRequestHandler = CdnRequestHandler;

package/lib/event-dispatcher.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * Reldens - EventDispatcher
+ *
+ */
+
+class EventDispatcher
+{
+
+    static dispatch(onEventCallback, eventType, instanceName, instance, data = {})
+    {
+        if('function' !== typeof onEventCallback){
+            return;
+        }
+        onEventCallback({
+            eventType: eventType,
+            instanceName: instanceName,
+            instance: instance,
+            data: data,
+            timestamp: new Date().toISOString()
+        });
+    }
+
+}
+
+module.exports.EventDispatcher = EventDispatcher;

package/lib/http2-cdn-server.js

@@ -10,6 +10,8 @@ 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
 {
@@ -35,6 +37,10 @@ class Http2CdnServer
         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()
@@ -62,6 +68,13 @@ class Http2CdnServer
         }
         this.http2Server = http2.createSecureServer(options);
         this.setupEventHandlers();
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'cdn-server-created',
+            'http2CdnServer',
+            this,
+            {port: this.port, allowHTTP1: this.allowHTTP1}
+        );
         return true;
     }
 
@@ -103,160 +116,111 @@ class Http2CdnServer
                 {port: this.port}
             );
         });
+        EventDispatcher.dispatch(
+            this.onEvent,
+            'cdn-handlers-setup',
+            'http2CdnServer',
+            this,
+            {port: this.port}
+        );
+    }
+
+    invokeRequestSuccess(requestData)
+    {
+        if('function' !== typeof this.onRequestSuccess){
+            return;
+        }
+        this.onRequestSuccess(requestData);
+    }
+
+    invokeRequestError(errorData)
+    {
+        if('function' !== typeof this.onRequestError){
+            return;
+        }
+        this.onRequestError(errorData);
     }
 
     handleStream(stream, headers)
     {
-        try {
-            let requestPath = headers[':path'];
-            if(!requestPath){
-                stream.respond({':status': 400});
-                stream.end();
-                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;
+        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;
                 }
-                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.respond({':status': statusCode});
                 stream.end();
-                return;
+            },
+            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;
             }
-            let ext = FileHandler.extension(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.on('error', (err) => {
-                ServerErrorHandler.handleError(
-                    this.onError,
-                    'http2CdnServer',
-                    this,
-                    'stream-error',
-                    err,
-                    {port: this.port, path: requestPath}
-                );
-            });
-            stream.respondWithFile(filePath, responseHeaders);
-        } catch (err) {
-            ServerErrorHandler.handleError(
-                this.onError,
-                'http2CdnServer',
-                this,
-                'handle-stream-error',
-                err,
-                {port: this.port, path: headers[':path']}
-            );
-            if(!stream.destroyed){
-                stream.respond({':status': 500});
-                stream.end();
-            }
-        }
+        };
+        this.requestHandler.handleRequest(requestContext);
     }
 
     handleHttp1Request(req, res)
     {
-        try {
-            let requestPath = req.url;
-            if(!requestPath){
-                res.writeHead(400);
-                res.end();
-                return;
-            }
-            let requestOrigin = req.headers['origin'] || '';
-            let allowedOrigin = ServerFactoryUtils.validateOrigin(requestOrigin, this.corsOrigins, this.corsAllowAll);
-            if('OPTIONS' === req.method){
-                let optionsHeaders = {};
-                if(allowedOrigin){
-                    optionsHeaders['access-control-allow-origin'] = allowedOrigin;
-                }
-                optionsHeaders['access-control-allow-methods'] = this.corsMethods;
-                optionsHeaders['access-control-allow-headers'] = this.corsHeaders;
-                res.writeHead(200, optionsHeaders);
-                res.end();
-                return;
-            }
-            let filePath = this.resolveFilePath(requestPath);
-            if(!filePath){
-                res.writeHead(404);
-                res.end();
-                return;
-            }
-            let ext = FileHandler.extension(filePath);
-            let cacheAge = ServerFactoryUtils.getCacheConfigForPath(filePath, this.cacheConfig);
-            let responseHeaders = {};
-            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];
-            }
-            let fileStream = FileHandler.createReadStream(filePath);
-            fileStream.on('error', (err) => {
-                ServerErrorHandler.handleError(
-                    this.onError,
-                    'http2CdnServer',
-                    this,
-                    'http1-stream-error',
-                    err,
-                    {port: this.port, path: requestPath}
-                );
-                if(!res.headersSent){
-                    res.writeHead(500);
+        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(200, responseHeaders);
-            fileStream.pipe(res);
-        } catch (err) {
-            ServerErrorHandler.handleError(
-                this.onError,
-                'http2CdnServer',
-                this,
-                'handle-http1-request-error',
-                err,
-                {port: this.port, path: req.url}
-            );
-            if(!res.headersSent){
-                res.writeHead(500);
+                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)
@@ -282,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;
     }