gina 0.1.6-alpha.15 → 0.1.6-alpha.150

package/framework/{v0.1.6-alpha.15 → v0.1.6-alpha.150}/core/router.js

@@ -1,7 +1,7 @@
 //"use strict";
 /*
  * This file is part of the gina package.
- * Copyright (c) 2009-2023 Rhinostone <contact@gina.io>
+ * Copyright (c) 2009-2025 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
@@ -94,6 +94,13 @@ function Router(env, scope) {
         return self.serverInstance;
     }
 
+    /**
+     * Check if env is running cacheless
+     * */
+    this.isCacheless = function() {
+        return (/^true$/i.test(process.env.NODE_ENV_IS_DEV)) ? true : false
+    }
+
 
     /**
      * Route on the fly
@@ -118,6 +125,73 @@ function Router(env, scope) {
         // }
         // return ;
 
+
+       var serverInstance   = self.getServerInstance();
+       var config               = null
+            , conf              = null
+            , bundle            = null
+            , env               = null
+            , scope             = null
+            , isCacheless       = self.isCacheless()
+       ;
+        try {
+            config      = new Config().getInstance();
+            if (!params.bundle) {
+                try {
+                    //params.bundle = config.bundle;
+                    //params.param = config.routing[config.reverseRouting[params.param.url]];
+                    var _rule = config.reverseRouting[params.param.url];
+                    params = merge(params, config.routing[_rule]);
+                    params.rule = _rule;
+                } catch(reverseRoutingError) {
+                    serverInstance.throwError(response, 500, reverseRoutingError);
+                    return;
+                }
+            }
+            bundle      = local.bundle = params.bundle;
+            env         = config.env;
+            scope       = config.scope;
+            conf        = config[bundle][env];
+        } catch (configErr) {
+            serverInstance.throwError(response, 500, new Error('syntax error(s) found in `'+ controllerFile +'` \nTrace: ') + (configErr.stack || configErr.message) );
+            return;
+        }
+
+        local.isCacheless   = isCacheless;
+        local.request       = request;
+        local.next          = next;
+        local.conf          = conf;
+        local.isStandalone  = conf.isStandalone;
+
+
+        /**
+         * Reverse proxy check
+         */
+        var requestPort = request.headers.port || request.headers[':port'];
+        var isProxyHost = (
+            typeof(request.headers.host) != 'undefined'
+            && typeof(requestPort) != 'undefined'
+            &&  /^(80|443)$/.test(requestPort)
+            && conf.server.scheme +'://'+ request.headers.host +':'+ requestPort != conf.hostname.replace(/\:\d+$/, '') +':'+ conf.server.port
+            ||
+            typeof(request.headers[':authority']) != 'undefined'
+            && conf.server.scheme +'://'+ request.headers[':authority'] != conf.hostname
+            ||
+            typeof(request.headers.host) != 'undefined'
+            && typeof(requestPort) != 'undefined'
+            && /^(80|443)$/.test(requestPort)
+            && request.headers.host == conf.host
+            ||
+            typeof(request.headers['x-nginx-proxy']) != 'undefined'
+            && /^true$/i.test(request.headers['x-nginx-proxy'])
+            ||
+            typeof(process.gina.PROXY_HOSTNAME) != 'undefined'
+        ) ? true : false;
+
+        setContext('isProxyHost', isProxyHost);
+
+
+
         /**
         * ExpressJS modules + HTTP2 fix
         * Hack required until `express-<plugin>` get support for http2 `express-session`
@@ -140,6 +214,9 @@ function Router(env, scope) {
             ||
             typeof(request.session) != 'undefined'
             && typeof(request.isAuthenticated) == 'undefined'
+            ||
+            typeof(request.session) != 'undefined'
+            && typeof(request.session.passport) != 'undefined'
        ) {
             request.isAuthenticated = function() {
                 var property = 'user';
@@ -284,44 +361,8 @@ function Router(env, scope) {
         * EO Passport JS HTTP2 fix
         */
 
-       var serverInstance   = self.getServerInstance();
-       var config               = null
-            , conf              = null
-            , bundle            = null
-            , env               = null
-            , scope             = null
-            , cacheless         = (/^true$/i.test(process.env.NODE_ENV_IS_DEV)) ? true : false
-       ;
-        try {
-            config      = new Config().getInstance();
-            if (!params.bundle) {
-                try {
-                    //params.bundle = config.bundle;
-                    //params.param = config.routing[config.reverseRouting[params.param.url]];
-                    var _rule = config.reverseRouting[params.param.url];
-                    params = merge(params, config.routing[_rule]);
-                    params.rule = _rule;
-                } catch(reverseRoutingError) {
-                    serverInstance.throwError(response, 500, reverseRoutingError);
-                    return;
-                }
-            }
-            bundle      = local.bundle = params.bundle;
-            env         = config.env;
-            scope       = config.scope;
-            conf        = config[bundle][env];
-        } catch (configErr) {
-            serverInstance.throwError(response, 500, new Error('syntax error(s) found in `'+ controllerFile +'` \nTrace: ') + (configErr.stack || configErr.message) );
-            return;
-        }
-
-        local.cacheless     = cacheless;
-        local.request       = request;
-        local.next          = next;
-        local.conf          = conf;
-        local.isStandalone  = conf.isStandalone;
 
-        if (cacheless) {
+        if (isCacheless) {
             refreshCoreDependencies();
         }
 
@@ -416,14 +457,18 @@ function Router(env, scope) {
             rootPath        : conf.executionPath || null,
             executionPath   : conf.executionPath || null,
             //instance: self.serverInstance,
-            isUsingTemplate: local.isUsingTemplate,
-            cacheless: cacheless,
-            path: params.param.path || null, // user custom path : namespace should be ignored or left blank
-            assets: {}
+            isUsingTemplate : local.isUsingTemplate,
+            isCacheless     : isCacheless,
+            path            : params.param.path || null, // user custom path : namespace should be ignored or left blank
+            assets          : {}
         };
 
         if (routeHasViews) {
             options.template = (routeHasViews) ? conf.content.templates[templateName] || conf.content.templates._common : undefined;
+            options.template.externalPlugins = [];
+            if ( /http\/2/.test(conf.server.protocol) ) {
+                options.template.h2Links = '';
+            }
         }
 
         // Options need to be protected by a clone to allow overrides
@@ -456,7 +501,7 @@ function Router(env, scope) {
             }
             setupFileObj = null;
 
-            if (cacheless) {
+            if (isCacheless) {
                 if (hasControllerNamespace) {
                     delete require.cache[require.resolve(_(mainControllerFile, true))];
                 }
@@ -504,7 +549,7 @@ function Router(env, scope) {
              * */
             var requireController = function (namespace, options) {
 
-                var cacheless   = (process.env.NODE_ENV_IS_DEV == 'false') ? false : true;
+                var isCacheless = (process.env.NODE_ENV_IS_DEV == 'false') ? false : true;
                 var corePath    = getPath('gina').core;
                 var config      = getContext('gina').Config.instance;
                 var bundle      = config.bundle;
@@ -524,7 +569,7 @@ function Router(env, scope) {
 
                 try {
 
-                    //if (cacheless) {
+                    //if (isCacheless) {
                         // Super controller
                         delete require.cache[require.resolve(_(corePath +'/controller/index.js', true))];
                         require.cache[_(corePath +'/controller/index.js', true)] = require( _(corePath +'/controller/index.js', true) );
@@ -713,7 +758,7 @@ function Router(env, scope) {
                 filename = sharedFilename;
             }
 
-            if (local.cacheless) delete require.cache[require.resolve(_(filename, true))];
+            if (local.isCacheless) delete require.cache[require.resolve(_(filename, true))];
 
             var MiddlewareClass = function(req, res, next) {
                 // getting rid of the middleware context
@@ -725,7 +770,7 @@ function Router(env, scope) {
                         sharedFilenameObj.existsSync()
                         && filename != sharedFilename
                     ) {
-                        if (local.cacheless) delete require.cache[require.resolve(_(sharedFilename, true))];
+                        if (local.isCacheless) delete require.cache[require.resolve(_(sharedFilename, true))];
                         // sharedFilename as SuperClass
                         Middleware = inherits(require(_(filename, true)), require(_(sharedFilename, true)));
                     }

package/framework/{v0.1.6-alpha.15 → v0.1.6-alpha.150}/core/server.isaac.js

@@ -4,13 +4,17 @@
  *
  */
 const fs                    = require('fs');
+const { execSync }          = require('child_process');
 const {EventEmitter}        = require('events');
 const Eio                   = require('engine.io');
+// const zlib                  = require('zlib'); // gzip / deflate
 
 const lib               = require('./../lib');
 const inherits          = lib.inherits;
 const merge             = lib.merge;
 const console           = lib.logger;
+const Collection        = lib.Collection;
+const cache             = new lib.Cache();
 
 
 const env               = process.env.NODE_ENV
@@ -65,6 +69,150 @@ function ServerEngineClass(options) {
         return fs.readFileSync(filename).toString()
     }
 
+    var preferedEncoding    = options.preferedCompressionEncodingOrder
+        , acceptEncodingArr = null
+        , acceptEncoding    = null
+    ;
+
+    var localAssets             = null
+        , cachedAssets          = null
+        , cachePathObj          = null
+        , localCachePathObj     = null
+    ;
+    try {
+
+        // Adding cache directory if not found
+        cachePathObj = new _(options.cachePath, true);
+        localCachePathObj = new _(options.cachePath +'/'+ options.bundle, true);
+        if ( !cachePathObj.existsSync() ) {
+            cachePathObj.mkdirSync();
+        }
+        // Empty cache for cahceless envs
+        if ( options.isCacheless && localCachePathObj.existsSync() ) {
+            localCachePathObj.rmSync();
+        }
+        // For frontend template routing if needed
+        // TODO - Used `options.routing` instead after having filtered `options.allRoutes` vs `options.formsRules` to use only external routes exposed by `"query"` validation
+        var _routing = JSON.clone(options.allRoutes);
+        // var _routing = JSON.clone(options.routing);
+        for (let rule in _routing) {
+            if ( typeof(_routing[rule]._comment) != 'undefined' ) {
+                delete _routing[rule]._comment;
+            }
+            if ( typeof(_routing[rule].middleware) != 'undefined' ) {
+                delete _routing[rule].middleware;
+            }
+
+            // reverseRouting in done on te frontend side
+
+        }// EO for (let rule in _routing)
+
+        // Checking if brotli is installed
+        var brotliBin = null;
+        try {
+            brotliBin = execSync( 'which brotli' ).toString().trim();
+        } catch (binErr) {
+            // Means that it is not installed.
+        }
+        // Checking if gzip is installed
+        var gZipBin = null;
+        try {
+            gZipBin = execSync( 'which gzip' ).toString().trim();
+        } catch (binErr) {
+            // Means that it is not installed.
+        }
+
+        // Caching routing
+        let targetDir   = _(options.cachePath +'/'+ options.bundle +'/config', true);
+        let targetDirObj = new _(targetDir, true);
+        if ( ! targetDirObj.existsSync() ) {
+            targetDirObj.mkdirSync();
+        }
+        let targetFile  = null
+            , fd        = null
+            , buffer    = null
+            , cmd       = null
+            , brFileObj = null
+            , gzFileObj = null
+        ;
+        if (_routing) {
+            targetFile  = 'routing.json';
+            // Storing to disk
+            console.debug(`Writing ${targetFile} to: ${targetDir}/${targetFile}`);
+            fd = fs.openSync(targetDir +'/'+ targetFile, 'w'); // Open file for writing
+            buffer = Buffer.from( JSON.stringify(_routing) );
+            fs.writeSync(fd, buffer, 0, buffer.length, 0); // Write the buffer
+            fs.closeSync(fd); // Close the file descriptor
+
+            // Adding brotli version
+            // To enblable this feature, you need to install brotli on the host
+            // [ Mac Os X ] brew install brotli
+            // [ Debian/Ubuntu ] sudo apt install brotli
+            try {
+                if (brotliBin) {
+                    brFileObj = new _(targetDir +'/'+ targetFile +'.br');
+                    // Removing existing
+                    if ( brFileObj.existsSync() ) {
+                        brFileObj.rmSync();
+                    }
+                    // Creating a new br version
+                    cmd = brotliBin +' --best '+ _(targetDir +'/'+ targetFile, true);
+                    console.debug( execSync( cmd ).toString() );
+                }
+            } catch (brError) {
+                console.error('[ SERVER ] '+ brError.stack);
+            }
+
+            // Adding GZip version
+            // To enblable this feature, you need to install gzip on the host
+            // [ Mac Os X ] brew install gzip
+            // [ Debian/Ubuntu ] sudo apt install gzip
+            try {
+                if (gZipBin) {
+                    gzFileObj = new _(targetDir +'/'+ targetFile +'.gz');
+                    // Removing existing
+                    if ( gzFileObj.existsSync() ) {
+                        gzFileObj.rmSync();
+                    }
+                    // Creating a new br version
+                    cmd = gZipBin +' -9 -k '+ _(targetDir +'/'+ targetFile, true);
+                    console.debug( execSync( cmd ).toString() );
+                }
+            } catch (gzError) {
+                console.error('[ SERVER ] '+ gzError.stack);
+            }
+        }
+
+
+        buffer = null;
+        fd = null;
+
+
+        // TODO - Make a br or a gz file asside here
+        localAssets = [
+            {
+                file    : 'public_suffix_list.dat',
+                path    : getPath('gina').lib +'/domain/dist',
+                mime    : 'text/plain; charset=utf8'
+            },
+            {
+                file    : 'routing.json',
+                path    : targetDir,
+                mime    : 'application/json; charset=utf8'
+            }
+        ];
+        for (let i=0, len=localAssets.length; i<len; i++) {
+            let fileName  =  _(localAssets[i].path +'/'+ localAssets[i].file, true);
+            localAssets[i].content = readSync(fileName, 'utf8');
+        }// EO for localAssets
+
+    } catch (assetsError) {
+        // TODO - Reuse the default or the project 404 page
+        // fileContent = 'Not found';
+        console.error('[ SERVER ] '+ assetsError.stack);
+    }
+
+
     // openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj "/CN=localhost" -keyout localhost-privkey.pem -out localhost-cert.pem
     var credentials = {};
     if ( /https/.test(options.scheme) ) {
@@ -98,6 +246,7 @@ function ServerEngineClass(options) {
 
     var server = null, http = null, ioServer = null;
 
+
     if ( /^http\/2/.test(options.protocol) ) {
         var http2   = require('http2');
         switch (options.scheme) {
@@ -134,6 +283,7 @@ function ServerEngineClass(options) {
     }
 
 
+
     const middleware = function(path, cb) {
 
         // if (request.path === path) {
@@ -150,35 +300,203 @@ function ServerEngineClass(options) {
 
     const onPath = function(path, cb, allowAll) {
 
-        var queryParams = null
-            , i         = null
-            , len       = null
-            , p         = null
-            , arr       = null
-            , a         = null
+        var queryParams         = null
+            , i                 = null
+            , len               = null
+            , p                 = null
+            , arr               = null
+            , a                 = null
+            , isProxyHost       = null
+            , requestHost       = null
+            , isBinary          = null
+            , isCacheless       = options.isCacheless
+            , assetsCollection  = new Collection(localAssets)
+            , localAsset        = null
+            , cachedContents    = null
+            , cachedContentObj  = null
+            , cachedIndexes     = []
+            , cachedIndexe      = null
         ;
 
+
         // http2stream handle by the Router class & the SuperController class
         // See `${core}/router.js` & `${core}/controller/controller.js`
 
         server.on('request', (request, response) => {
+
+            acceptEncodingArr = null;
+            if ( typeof(request.headers['accept-encoding']) != 'undefined' ) {
+                acceptEncodingArr   = request.headers['accept-encoding'].replace(/\s+/g, '').split(/\,/);
+            }
+            acceptEncoding      = null;
+            isBinary            = false;
+
+            // Proxy detection
+            isProxyHost = getContext('isProxyHost') || false;
+            requestHost = request.headers.host || request.headers[':authority'];
+            // console.debug('[PROXY_HOST][isProxyHost='+ isProxyHost +'] request.headers.host -> ' + request.headers.host + '  VS request.headers[":authority"] '+ request.headers[':authority'] +' | '+ request.url);
+            if (
+                !isProxyHost
+                && !/\:[0-9]+$/.test(requestHost)
+                ||
+                !isProxyHost
+                && request.headers['x-forwarded-host']
+            ) {
+                // Enable proxied mode
+                process.gina.PROXY_HOSTNAME = process.gina.PROXY_SCHEME +'://'+ requestHost;
+                process.gina.PROXY_HOST     = requestHost;
+                // For internal services communications - Eg.: Controller::query()
+                if (request.headers['x-forwarded-host']) {
+                    process.gina.PROXY_HOSTNAME = request.headers['x-forwarded-proto'] +'://'+ request.headers['x-forwarded-host'];
+                    process.gina.PROXY_HOST     = request.headers['x-forwarded-host'];
+                    // console.debug('[PROXY_HOST][X-FORWARDED-PROTO] override request.headers["x-forwarded-host"] -> ' + request.headers['x-forwarded-host']);
+                }
+                // Forcing context - also available for workers
+                setContext('isProxyHost', true);
+            }
+
+            // TODO - remove this after k8s test
+            // if (
+            //     // skip internal requests like healthcheck
+            //     !/^localhost:[0-9]+$/.test(requestHost)
+            //     && /^true$/.test(isProxyHost)
+            //     && /\:[0-9]+$/.test(requestHost)
+            //     && !hostnameRE.test(requestHost)
+            // ) {
+            //     // Restoring non-proxied mode
+            //     console.debug('[ SERVER ] proxy disabled: '+ process.gina.PROXY_SCHEME +'://'+ requestHost);
+            //     isProxyHost = false;
+            //     setContext('isProxyHost', isProxyHost);
+            // }
+
             // healthcheck
             // TODO - add a top level API : server.api.js (check, get ...)
             // TODO - on 90% RAM usage, redirect to `come back later then restart bundle`
             // TODO - check url against wroot : getContext() ?
             if ( /^get$/i.test(request.method) && /\_gina\/health\/check$/i.test(request.url) ) {
                 // server.toApi(reques, response)
-                // console.debug('[200] '+ request.url);
-                response.setHeader('content-type', 'application/json; charset=utf8' );
-                response.setHeader('x-powered-by', 'Gina/'+ GINA_VERSION );
+                // console.debug('[ SERVER ][200] '+ request.url);
+                response.setHeader('cache-control', 'no-cache, no-store, must-revalidate');
+                response.setHeader('pragma', 'no-cache');
+                response.setHeader('expires', '0');
+                response.setHeader('content-type', 'application/json; charset=utf8');
+                response.setHeader('x-powered-by', 'Gina/'+ GINA_VERSION);
+
                 return response.end('{"status":"ok"}');
             }
+
+
+            if (
+                /^get$/i.test(request.method) && /\_gina\/assets\/public_suffix_list.dat$/i.test(request.url)
+                ||
+                /^get$/i.test(request.method) && /\_gina\/assets\/routing\.json$/i.test(request.url)
+            ) {
+                // server.toApi(reques, response)
+                // console.debug('[ SERVER ][200] '+ request.url);
+                localAsset = assetsCollection.findOne({ file: request.url.split(/\//g).slice(-1).toString() });
+                response.setHeader('content-type', localAsset.mime);
+                response.setHeader('vary', 'Origin');
+                response.setHeader('cache-control', 'public, max-age=86400');
+                response.setHeader('x-content-type-options', 'nosniff');
+                response.setHeader('x-frame-options', 'DENY');
+                response.setHeader('x-xss-protection', '1; mode=block');
+                response.setHeader('x-powered-by', 'Gina/'+ GINA_VERSION);
+
+                var filename  =  _(localAsset.path +'/'+ localAsset.file, true);
+                if (acceptEncodingArr) {
+                    for (let e=0, eLen=preferedEncoding.length; e<eLen; e++) {
+                        if ( acceptEncodingArr && acceptEncodingArr.indexOf(preferedEncoding[e]) > -1 ) {
+                            acceptEncoding = options.coreConfiguration.encoding[ preferedEncoding[e] ] ;
+                            break;
+                        }
+                    }
+                }
+                // Compressed content
+                if (
+                    !isCacheless
+                    && acceptEncoding
+                    && fs.existsSync(filename + acceptEncoding)
+                ) {
+                    isBinary = true;
+                    filename += acceptEncoding;
+                    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Encoding
+                    response.setHeader('content-encoding', acceptEncoding.replace(/^\./, ''));
+                    // override content length
+                    response.setHeader('content-length', fs.statSync(filename).size);
+                }
+
+                if (!isBinary) {
+                    console.info(request.method +' [200] '+ request.url);
+                    return response.end(localAsset.content);
+                }
+
+                return fs.createReadStream(filename)
+                    .on('end', function onResponse(){
+                        console.info(request.method +' [200] '+ request.url);
+                    })
+                    .pipe(response);
+            }
+
+
             if (isDev) {
                 refreshCore()
             }
 
+            if (!isCacheless) {
+                var cacheStatus = 'gina;';
+                // Importing cache handler
+                cache.from(server._cached);
+                var cacheKey = 'html:' + request.url;
+                if ( cache.has(cacheKey) ) {
+                    if ( /^GET$/i.test(request.method) ) {
+                        // Getting cache from key
+                        cachedContentObj = cache.get(cacheKey);
+
+                        // Getting the headers
+                        cacheStatus += ' hit;';
+                        if ( typeof(cachedContentObj.ttl) != 'undefined' && cachedContentObj.ttl > 0) {
+                            var createdAt = cachedContentObj.createdAt.getTime()+ (~~(cachedContentObj.ttl)*1000);
+                            var remainingSeconds = Math.floor( (createdAt - new Date().getTime()) /1000);
+
+                            cacheStatus += ' ttl='+remainingSeconds;
+                            createdAt = null;
+                            remainingSeconds = null;
+                        }
+                        response.setHeader('cache-status', cacheStatus);
+
+                        if ( typeof(cachedContentObj.responseHeaders) != 'undefined' ) {
+                            for (let h in cachedContentObj.responseHeaders ) {
+                                response.setHeader(h, cachedContentObj.responseHeaders[h]);
+                            }
+                        }
+                        if (
+                            typeof(cachedContentObj.fromMemory) != 'undefined'
+                        ) {
+                            console.info(request.method +' [200]['+ cacheStatus +'] '+ request.url);
+                            return response.end(cachedContentObj.content);
+                        }
+
+                        filename  =  _(cachedContentObj.filename, true);
+
+                        return fs.createReadStream(filename)
+                            .on('error', function onError(err) {
+                                console.error("[SERVER][CACHE][FILE ERROR] ", err.stack|err.message|err);
+                                return response.end(''+ err.stack|err.message|err);
+                            })
+                            .on('end', function onResponse(){
+                                console.info(request.method +' [200] '+ request.url);
+                            })
+                            .pipe(response);
+                    }
+                    console.warn("[SERVER][CACHE] ignoring key `"+ cacheKey+ "` because method != GET");
+
+                } // EO if ( cache.has(cacheKey) )
+            } // EO if (!isCacheless)
+
+
+
             if ( /engine.io/.test(request.url)) {
-                console.debug('io request');
+                console.debug('[ SERVER ] engine.io request');
             }
 
             if (/^\*$/.test(path) || path == request.url) {
@@ -382,6 +700,7 @@ function ServerEngineClass(options) {
 
     //------------------------------------
     // Engine IO server
+    // https://socket.io/docs/v4/server-api/#socketsendargs
     //------------------------------------
     if (
         typeof(options.ioServer) != 'undefined'
@@ -393,39 +712,6 @@ function ServerEngineClass(options) {
         // test done in case we would like to switch to socket.io-server
         ioServer = ( typeof(Eio.attach) != 'undefined' ) ? new Eio.attach(server, options.ioServer) : new Eio(server, options.ioServer);
 
-        ioServer.getClientsBySessionId = function(sessionId) {
-
-            if (this.clients.count() == 0)
-                return null;
-
-            var clients = null;
-
-            for (let id in this.clients) {
-
-                if ( typeof(this.clients[id].sessionId) == 'undefined' )
-                    continue;
-
-                if (!clients) clients = {};
-
-                clients[id] = this.clients[id];
-            }
-
-            if (clients) {
-                // allowing to send for each client found sharing the same request session
-                clients.send = function(payload, option, callback) {
-                    for ( var id in this) {
-                        if ( typeof(this[id].sessionId) == 'undefined')
-                            continue;
-
-                        this[id].send(payload, option, callback)
-                    }
-                }
-            }
-
-
-            return clients;
-        }
-
         server.eio = ioServer;
 
         ioServer.on('connection', function (socket) {