gina 0.0.9-p91c → 0.1.1-alpha.3

package/{core/utils → framework/v0.1.1-alpha.3}/lib/inherits/src/main.js

@@ -1,18 +1,18 @@
+'use strict';
 /**
  * This file is part of the gina package.
- * Copyright (c) 2016 Rhinostone <gina@rhinostone.com>
+ * Copyright (c) 2009-2022 Rhinostone <contact@gina.io>
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-'use strict';
 
 /**
  * @class Inherits
  *
  * @package gina.utils
  * @namesame gina.utils.inherits
- * @author Rhinostone <gina@rhinostone.com>
+ * @author Rhinostone <contact@gina.io>
  *
  * @api Public
  * */
@@ -25,7 +25,6 @@ function Inherits(a, b) {
     var init = function(a, b) {
         var err = check(a, b);
 
-
         if (!err) {
 
             var z = (function() {
@@ -45,52 +44,52 @@ function Inherits(a, b) {
 
                             //makes it compatible with node.js classes like EventEmitter
                             for (var prop in b.prototype) {
-                                if (!this[prop] /**&& prop != 'instance'*/) {// all but instances
-                                    this[prop] = b.prototype[prop]
+                                if (!this[prop]) {
+                                    this[prop] = b.prototype[prop];
                                 }
                             }
 
                             b.apply(this, arguments);
                             cache.apply(this, arguments);
                         }
-                    }
+                    };
                 }
 
             }(a, b));
 
             //makes it compatible with node.js classes like EventEmitter
             if (a.prototype == undefined) {
-                a.prototype = {}
+                a.prototype = {};
             }
 
             if (b.prototype == undefined) {
-                b.prototype = {}
+                b.prototype = {};
             }
 
             a.prototype = Object.create(b.prototype, {});
             z.prototype = Object.create(a.prototype, {}); //{ name: { writable: true, configurable: true, value: name }
 
-            return z
+            return z;
         } else {
-            throw new Error(err)
+            throw new Error(err);
         }
-    }
+    };
 
     var check = function(a, b) {
         if ( typeof(a) == 'undefined' || typeof(b) == 'undefined') {
             return 'inherits(a, b): neither [ a ] nor [ b ] can\'t be undefined or null'
         }
-        return false
-    }
+        return false;
+    };
 
-    return init
-};
+    return init;
+}
 
 
 if ( ( typeof(module) !== 'undefined' ) && module.exports ) {
     // Publish as node.js module
-    module.exports = Inherits()
+    module.exports = Inherits();
 } else if ( typeof(define) === 'function' && define.amd) {
     // Publish as AMD module
-    define( function() { return Inherits() })
-}
+    define( function() { return Inherits(); });
+}

package/framework/v0.1.1-alpha.3/lib/logger/README.md

@@ -0,0 +1,7 @@
+# Logger documentation
+
+## Debuging your test with nodeunit
+
+```tty
+ node --inspect-brk=6959 `which nodeunit` ./test/01-find.js
+```

package/framework/v0.1.1-alpha.3/lib/logger/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "logger",
+  "version": "1.0.0",
+  "description": "Logs hanlder",
+
+  "author": {
+    "name": "Maritn-Luther ETOUMAN",
+    "email": "contact@gina.io"
+  },
+  "copyright": "Copyright (c) 2009-2022 Rhinostone <contact@gina.io>",
+  "engines": {
+    "node": ">=0.10.22"
+  },
+  "main": "src/main",
+  "scripts": {
+    "test": "nodeunit test"
+  },
+  "license": "MIT",
+  "readmeFilename": "README.md"
+}

package/framework/v0.1.1-alpha.3/lib/logger/src/containers/default/index.js

@@ -0,0 +1,55 @@
+'use strict';
+// Imports
+// const fs                  = require('fs');
+// const util                = require('util');
+
+function DefaultContainer(opt, loggers) {
+    var self = {
+        // flow or container name/id
+        name: 'default'
+    };
+    var loggerHelper    = require(__dirname +'/../../helper.js')(opt, loggers);
+    var format          = loggerHelper.format;
+
+    function init() {
+        onPayload();
+        // ----------------------------Debug---------------------------------------
+        var level = 'debug';
+        // Init debugging - Logs not in hierarchy will just be ignored
+        if (opt.hierarchies[opt.hierarchy].indexOf( opt.levels[level].code) > -1) {
+            process.emit('logger#'+self.name, JSON.stringify({
+                group       : opt.name,
+                level       : level,
+                // Raw content !
+                content     : '`'+ self.name +'` logger container loaded !'
+            }));
+        }
+        // ------------------------------------------------------------------------
+    }
+
+    function onPayload() {
+        process.on('logger#'+self.name, function onPayload(payload) {
+
+            try {
+                var payloadObj = JSON.parse(payload);
+
+                // loggerServer.emit('logger#default', JSON.stringify({
+                //     group       : payload.group,
+                //     level       : payload.level,
+                //     // Raw content !
+                //     content     : payload.content
+                // }));
+
+                process.stdout.write( format(payloadObj.group, payloadObj.level, payloadObj.content, payloadObj.skipFormating) );
+            } catch (e) {
+                process.stdout.write( format('', '', payload, true) );
+            }
+
+        });
+    }
+
+
+
+    init();
+}
+module.exports = DefaultContainer;

package/framework/v0.1.1-alpha.3/lib/logger/src/containers/file/index.js

@@ -0,0 +1,251 @@
+'use strict';
+// Imports
+const fs                  = require('fs');
+const util                = require('util');
+//const {EventEmitter}             = require('events');
+const net                 = require('net');
+// var promisify           = util.promisify;
+// const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+// const { execSync }      = require('child_process');
+
+
+const merge = require(__dirname + '/../../../../merge');
+
+function FileContainer(opt, loggers) {
+    var self = {
+        // flow or container name/id
+        name: 'file'
+    };
+    var mqId = 'MQ'+ self.name.substring(0,1).toLocaleUpperCase() + self.name.substring(1);
+
+    //var defaultOptions = ;
+
+    var loggerHelper    = require(__dirname +'/../../helper.js')(opt, loggers);
+    var format          = loggerHelper.format;
+    var processProperties = null;
+    var filenames   = {};
+
+    function init() {
+
+        onPayload();
+
+        // ----------------------------Debug---------------------------------------
+        var level = 'debug';
+        // Init debugging - Logs not in hierarchy will just be ignored
+        if (opt.hierarchies[opt.hierarchy].indexOf( opt.levels[level].code) > -1) {
+            process.emit('logger#'+self.name, JSON.stringify({
+                group       : opt.name,
+                level       : level,
+                // Raw content !
+                content     : '`'+ self.name +'` logger container loaded !'
+            }));
+        }
+        // ------------------------------------------------------------------------
+    }
+
+    function setup(group, filenames, props) {
+        //var group = process.title; // gina, frontend@myproject ...
+        console.log('['+ mqId +'] setting up '+ group);
+
+        // we only want the bundle's logs
+        if (
+            !/\@/.test(group)
+            // ||
+            // props.bundles
+            // && props.bundles.length == 0
+            // ||
+            // props.bundles
+            // && props.bundles.indexOf(group) < 0
+        ) {
+            return
+        }
+
+        if ( !filenames[group] ) {
+            filenames[group] = {}
+        }
+        process.stdout.write( format(opt.name, 'info', '['+ mqId +'] setting up '+ group +'\nFilenames: '+ JSON.stringify(filenames, null, 2)) );
+        /// aready defiened
+        if ( filenames[group].filename) {
+            return
+        }
+
+        // retriving hostname
+        var bfnArr = group.split(/\@/);
+        var bundleName = bfnArr[0];
+        var projectName = bfnArr[1];
+        var homeDir = getUserHome() || process.env[(process.platform == 'win32') ? 'USERPROFILE' : 'HOME'];// jshint ignore:line
+        homeDir += '/.gina';
+        var project = requireJSON(_(homeDir +'/projects.json', true))[projectName];
+        var projectPath = project.path;
+        console.info('write env: ', bundleName, process.env.NODE_ENV || getEnvVar('GINA_ENV'));
+        var envObj      = requireJSON(_(projectPath +'/env.json', true))[bundleName][process.env.NODE_ENV || getEnvVar('GINA_ENV')]
+        var webroot     = ( !/\s+|\//.test(envObj.server && envObj.server.webroot) ) ? envObj.server.webroot +'.' : '';
+        var hostname    = envObj.host;
+        var logDir      = getLogDir() || getEnvVar('GINA_LOGDIR');
+
+        filenames[group].filename = _(logDir +'/'+ webroot + hostname +'.log', true);
+        console.debug('Log group `'+ group +'` filename set to: ' + filenames[group].filename);
+        process.stdout.write( format(opt.name, 'info', 'Log group `'+ group +'` filename set to: ' + filenames[group].filename) );
+    }
+
+    function onPayload() {
+        var port = 8125;
+        var clientOptions = {
+            port    : port,
+            request : 'writeToFile'
+        }
+        // var loggerOptions   = console.getOptions();
+        // var loggers         = console.getLoggers();
+        // var loggerHelper    = LoggerHelper(loggerOptions, loggers);
+        // var format          = loggerHelper.format;
+
+
+
+
+        var delayedMessages = [];
+        var resume = function(payload) {
+            process.stdout.write('['+ mqId +'] Resuming with group: '+ payload.group);
+            var i = 0;
+            while (i < delayedMessages.length) {
+                let pl = delayedMessages[i];
+                // debug only
+                // process.stdout.write('['+ mqId +']'+ format(pl.group, pl.level, pl.content) );
+
+                write(pl.group, format(pl.group, pl.level, pl.content) );
+                i++;
+            }
+            delayedMessages = []
+        }
+
+
+        var client = net.createConnection(clientOptions, () => {
+            // 'connect' listener.
+            console.info('['+ mqId +'] connected to server :) ', process.argv);
+            processProperties = loggerHelper.getProcessProperties();
+            console.info('['+ mqId +'] process properties ', processProperties);
+            // send request
+            client.write( JSON.stringify(clientOptions) +'\r\n');
+
+        });
+        client.on('error', (data) => {
+            var err = data.toString();
+            process.stdout.write( format(opt.name, 'warn', '['+ mqId +'] ' + err) );
+        });
+
+        var payloads = null, i = null;
+        client.on('data', (data) => {
+            //console.log('['+ mqId +']  (data): ' + data.toString());
+            payloads = data.toString();
+
+            // from speakers
+            if ( /^(\{\"|\[\{\")/.test(payloads) ) {
+                payloads = payloads.split(/\r\n/g);
+                i = -1;
+                while(i < payloads.length) {
+                    i++;
+                    let payload = payloads[i];
+                    if (
+                        /^\{/.test(payload) && /\}$/.test(payload)
+                        || /^\[\{/.test(payload) && /\}\]$/.test(payload)
+                    ) {
+                        let pl = null;
+                        try {
+                            pl = JSON.parse(payload);
+                        } catch(plErr) {
+                            process.stdout.write( '['+ mqId +'] (exception) '+ payload +'\n' );
+                            continue;
+                        }
+
+
+                        if (!pl.content) {
+                            // only for debug
+                            // process.stdout.write( '['+ mqId +'] (undefined content) '+ JSON.stringify(pl, null) +'\n' );
+
+                            // updating logger context since it can run on different processes
+                            if ( pl.sessionId && !clientOptions.sessionId ) {
+                                clientOptions.sessionId = pl.sessionId;
+                                // setting up file descriptor if not existing
+
+                                //setup(pl.group, processProperties);
+                                for ( let b = 0, bLen = processProperties.bundles.length; b < bLen; b++) {
+                                    let realGroup = processProperties.bundles[b];
+                                    setup(realGroup, filenames, processProperties);
+                                }
+
+                                // acknowledging
+                                client.write( JSON.stringify(clientOptions) +'\r\n');
+                            }
+
+                            if (pl.loggers) {
+                                loggers = merge(loggers, pl.loggers);
+                                if (delayedMessages.length > 0 /**&& /\@/.test(pl.group)*/ ) {
+                                    resume(pl)
+                                }
+                            }
+                            continue;
+                        }
+
+                        // only for debug
+                        // process.stdout.write(  '['+ mqId +'] '+ pl.content +'\n' );
+
+                        try {
+                            if (!filenames[pl.group].filename ) {
+                                return;
+                            }
+                            write(pl.group, format(pl.group, pl.level, pl.content) );
+
+                        } catch (writeErr) {
+                            // means that the related MQSpeaker is not connected yet
+                            // this can happen during `bundle:start` configuration
+                            // we'll then delay the output until MQSpeaker is ready
+                            delayedMessages.push(pl);
+                        }
+
+                    }
+                }
+            }
+
+        });
+        client.on('end', () => {
+            console.log('['+ mqId +'] disconnected from server');
+        });
+        // setInterval(() => {}, 1 << 30);
+    }
+
+    function write(group, content) {
+
+        if ( !/\@/.test(group) || !filenames[group] ) {
+            process.stdout.write( '['+ mqId +']['+ group +'] '+ content );
+            return;
+        }
+
+        if ( !filenames[group].filename ) {
+            //throw new Error('['+ mqId +'] No filename found!');
+            process.emit('logger#'+self.name, JSON.stringify({
+                group       : group,
+                level       : 'error',
+                // Raw content !
+                content     : new Error('['+ mqId +'] No filename found!')
+            }));
+            return;
+        }
+        var data = new Uint8Array(Buffer.from(content));
+        fs.writeFile(filenames[group].filename, data,
+            {
+                encoding: "utf8",
+                // https://nodejs.org/api/fs.html#file-system-flags
+                flag: "a"
+            },
+            (err) => {
+                if (err) {
+                    process.stdout.write( format(opt.name, 'err', '['+ mqId +'] ' + err) );
+                    return;
+                }
+        });
+    }
+
+
+
+    init();
+}
+module.exports = FileContainer;

package/framework/v0.1.1-alpha.3/lib/logger/src/containers/file/lib/logrotator/README.md

@@ -0,0 +1,100 @@
+![Logrotator](https://raw.githubusercontent.com/karthickapps/logrotator/master/logrotator-logo.png)
+
+# Logrotator
+
+Log rotation in pure javascript.
+
+Log rotation is performed based on the size of the file.
+If the file size reaches the designated limit, rotation takes place.
+
+Rotation is based on copying the file contents and then truncating the file size to 0.
+This way we avoid file renaming problems where programs are not always prepared to handle a log file being renamed.
+
+## Usage
+
+```javascript
+var logrotate = require('logrotator');
+
+// use the global rotator
+var rotator = logrotate.rotator;
+
+// or create a new instance
+// var rotator = logrotate.create();
+
+// check file rotation every 5 minutes, and rotate the file if its size exceeds 10 mb.
+// keep only 3 rotated files and compress (gzip) them.
+rotator.register('/var/log/myfile.log', {schedule: '5m', size: '10m', compress: true, count: 3});
+
+rotator.on('error', function(err) {
+  console.log('oops, an error occured!');
+});
+
+// 'rotate' event is invoked whenever a registered file gets rotated
+rotator.on('rotate', function(file) {
+  console.log('file ' + file + ' was rotated!');
+});
+
+```
+
+## API
+
+#### `register(file, options)`
+
+Schedules a file for rotation. emits a 'rotate' event whenever the file has been rotated.
+
+* `file` - full file path to rotate
+* `options` - rotation options:
+  * `schedule` - how often to check for file rotation conditions. possible values are '1s', '1m', '1h'. default is 5m.
+  * `size` - size of the file to trigger rotation. possible values are '1k', '1m', '1g'. default is 10m.
+  * `count` - number of files to keep. default is 3.
+  * `compress` - whether to gzip rotated files. default is true.
+  * `format` - a function to build the name of a rotated file. the function receives the index of the rotated file.
+                 default format is the index itself
+
+#### `unregister(file)`
+
+Remove the scheduled rotation of a file
+
+* `file` - the file to stop rotating
+
+#### `stop()`
+
+Remove all the scheduled file rotations.
+
+* `file` - the file to stop rotating
+
+#### `rotate(file, options, cb)`
+
+Rotate a file now if size conditions are met.
+
+* `file` - full file path to rotate
+* `options` - rotation options:
+  * `size` - size of the file to trigger rotation. possible values are '1k', '1m', '1g'. default is 10m.
+  * `count` - number of files to keep. default is 3.
+  * `compress` - whether to gzip rotated files. default is true.
+  * `format` - a function to build the name of a rotated file. the function receives the index of the rotated file.
+               default format is the index itself
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2016 Capriza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.