gina 0.0.9-p91c → 0.1.1-alpha.3

package/bin/cli

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs          = require('fs');
+var net         = require('net');
+var util        = require('util');
+var promisify   = util.promisify;
+
+async function onExec() {
+    
+    // process.stdout.write('GINA CLI LOADED !! ' + JSON.stringify(process.argv, null, 2) + '\n');
+
+    var isWin32         = (process.platform === 'win32') ? true : false;
+    var binPath         = __dirname;
+    var ginaPath        = (binPath.replace(/\\/g, '/')).replace('/bin', '');
+    ginaPath = (isWin32) ? ginaPath.replace(/\//g, '\\') : ginaPath;
+    var help            = require(ginaPath + '/utils/helper.js');
+    // loading pack
+    var pack            = ginaPath + '/package.json';
+    pack = (isWin32) ? pack.replace(/\//g, '\\') : pack;
+    var home            = getUserHome();// jshint ignore:line
+    var frameworkPath   = null;
+    
+    var debugPort           = null
+        , debugBrkEnabled   = false
+        , isUpdateRequired  = false
+        , params            = process.argv
+    ;
+    try {
+        var packObj         = require(pack);
+        var version         = getEnvVar('GINA_VERSION') || packObj.version;// jshint ignore:line
+        frameworkPath   = ginaPath + '/framework/v' + version;
+        var generator   = require(frameworkPath + '/lib/generator');
+
+        require(frameworkPath + '/lib');
+        var aliases     = require(frameworkPath + '/lib/cmd/aliases.json');
+        
+        // catching debug|inspect arg
+        //process.stdout.write('params '+ params.join(', ') + '\n');    
+        if ( params.length > 0 ) {
+            for (var p = 0, len = params.length; p < len; ++p) {
+                
+                if ( /^\-\-port/.test(params[p]) ) {
+                    let port = params[p].split(/\=/)[1];
+                    setEnvVar('GINA_PORT', ~~port);// jshint ignore:line
+                    isUpdateRequired = true;            
+                    continue;
+                }
+                
+                if ( /^\-\-debug(\_|\-)port/.test(params[p]) ) {
+                    let port = params[p].split(/\=/)[1];
+                    setEnvVar('GINA_DEBUG_PORT', ~~port);// jshint ignore:line
+                    isUpdateRequired = true;            
+                    continue;
+                }
+                
+                if ( /^\-\-(inspect|debug)/.test(params[p]) ) {
+                    debugBrkEnabled = ( /\-brk/.test(params[p]) ) ? true : false;
+                    debugPort       = params[p].split(/\=/)[1];
+                    params.splice(p,1);            
+                    break;
+                }
+            }
+        }
+        
+
+        var shortVersion = version.split('.');
+        shortVersion.splice(2);
+        shortVersion = shortVersion.join('.');
+        setEnvVar('GINA_SHORT_VERSION', shortVersion);// jshint ignore:line
+        
+        
+        if ( typeof(getEnvVar('GINA_HOMEDIR')) == 'undefined') {// jshint ignore:line
+            setEnvVar('GINA_HOMEDIR', home + '/.gina')// jshint ignore:line
+        }
+        home = getEnvVar('GINA_HOMEDIR');// jshint ignore:line
+        
+        var settingsPath =  _( home +'/'+ shortVersion +'/settings.json', true );// jshint ignore:line
+        var settings = requireJSON(settingsPath);// jshint ignore:line
+        
+        setEnvVar('GINA_LOG_LEVEL', settings['log_level']);// jshint ignore:line
+        setEnvVar('GINA_VERSION', version);// jshint ignore:line
+
+        // Loading logger.
+        console = lib.logger;// jshint ignore:line
+        // reporting exception
+        if ( /^(tail|framework\:tail)$/.test(process.argv[2]) ) {
+            console.pauseReporting();
+        }
+        console.setLevel(settings['log_level'], 'gina');
+                
+        // Loading logger listner vs ~/.gina/user/extensions/logger/mq/config.json & ~/.gina/{shortVersion}/settings.json
+        if ( /(gina\/bin\/cli|gina\/\/bin\/gina)$/.test(process.argv[1]) ) {
+            
+            var MQListener = require(frameworkPath + '/lib/logger/src/containers/mq/listener.js');
+            
+            var mqPort = 8125;
+            var mqListener = await new MQListener({ port: 8125 });
+            // required for tail command
+            var mqPortFile = './tmp/mq-listener-v'+ version +'.port';
+            console.debug('Writting: '+ mqPortFile);
+            fs.writeFileSync( mqPortFile, ''+mqPort );
+            process.on('exit', function() {
+                fs.unlinkSync(mqPortFile);
+                mqListener.close();
+                mqListener.unref();
+            })
+        }
+        
+        if ( !fs.existsSync(frameworkPath) ) {
+            console.alert('Could not find version ' + version + '.\nFirst try:\n$ gina framework:install ' + version);
+            process.exit(1)
+        }
+
+        try {
+        } catch (err) {
+            console.alert("Package.json is missing or corrupted.\n", err.stack);
+            process.exit(1)
+        }
+    } catch (err) {
+        process.stdout.write('gina: could not load [ ' + pack + ' ]\n' + err.stack);
+        process.exit(1)
+    }
+
+
+
+    filterArgs();// jshint ignore:line
+    //check for $HOME path, alert if empty.
+    if (!home) {
+        console.error('No ' + ((isWin32) ? 'USERPROFILE' : 'HOME') + ' path found.')
+    } else {
+        setEnvVar('GINA_HOMEDIR', home);// jshint ignore:line
+        setEnvVar('GINA_DIR', ginaPath);// jshint ignore:line
+        setEnvVar('GINA_FRAMEWORK_DIR', frameworkPath);// jshint ignore:line
+        setEnvVar('GINA_CORE', frameworkPath + '/core');// jshint ignore:line
+    }
+    setEnvVar('GINA_IS_WIN32', isWin32, true);// jshint ignore:line
+
+    if (isUpdateRequired) {    
+        settings['port'] = getEnvVar('GINA_PORT') || null;// jshint ignore:line
+        settings['debug_port'] = getEnvVar('GINA_DEBUG_PORT') || null;// jshint ignore:line
+        console.debug('Updating debug settings: #'+  getEnvVar('GINA_DEBUG_PORT'));// jshint ignore:line
+        generator.createFileFromDataSync(settings, settingsPath);// jshint ignore:line
+    }
+
+
+    /**
+     * Framework port
+     * TODO - Add a port scanner & compare with ~/.gina/{shortVersion}/settings.json on `post_install`
+     * */
+    var port = 8124;
+
+    // |-> framework/{version}/lib/cmd
+    var allowedOffline = [
+        'build:',
+        'bundle:',
+        'dev:',
+        'env:',
+        'framework:',
+        'port:',
+        'project:',
+        'protocol:',
+        'scheme:',
+        'scope:',
+        'view:',
+        '--', //options or other aliases.
+        '-' //options or other aliases.
+    ];
+
+    if ( process.argv.count() < 3 ) {
+        if (isWin32)
+            console.log('Check out the help section:\n$ gina -h')
+        else
+            console.log('Check out the manpage:\n$ man gina')
+
+        process.exit(0)
+    }
+
+    if (process.argv[2].indexOf(':') < 0) {
+        process.argv[2] = 'framework:' + process.argv[2];
+    }
+
+    if (
+        typeof(process.argv[2]) != 'undefined'
+            && process.argv[2] === 'start'
+        || typeof(process.argv[2]) != 'undefined'
+            && process.argv[2] === 'framework:start'
+    ) {
+
+        //Start framework || launch online CMD.
+        require(binPath + '/cmd')({
+            binPath         : binPath,
+            ginaPath        : ginaPath,
+            frameworkPath   : frameworkPath,
+            homedir         : home,
+            port            : port,
+            debugPort       : debugPort,
+            debugBrkEnabled : debugBrkEnabled,
+            pack            : pack
+        });
+        
+
+    } else if (
+        typeof(process.argv[2]) != 'undefined'
+        && allowedOffline.indexOf( (process.argv[2].split(':')[0] + ':')) > -1
+        &&  process.argv[2] !== 'bundle:start'
+        || process.argv[2].substr(0, 2) === '--'
+        || process.argv[2].substr(0, 1) === '-'
+    ) {
+            
+        require(binPath + '/cmd')({
+            binPath         : binPath,
+            ginaPath        : ginaPath,
+            frameworkPath   : frameworkPath,
+            homedir         : home,
+            port            : port,
+            debugPort       : debugPort,
+            debugBrkEnabled : debugBrkEnabled,
+            pack            : pack
+        }, true)
+
+    } else if ( typeof(process.argv[2]) != 'undefined'
+                && allowedOffline.indexOf( (process.argv[2].split(':')[0] + ':')) < 0
+    ) {
+        // check allowedOffline ;)
+        process.argv.splice(0,2);
+        console.error( '[ $ gina ' + process.argv.join(' ') + ' ] is not a valid command line' )
+    } else {
+
+        //Connect to framework.
+        var client = net.connect({port: port},
+            function() {
+                //Forwarding cmd.
+                // retieving debug infos
+                var debugOption = null;
+                if ( debugPort ) {
+                    debugOption = '--inspect=' + debugPort;     
+                        
+                    if (debugBrkEnabled) {
+                        debugOption = debugOption.replace(/\-\-inspect/, '--inspect-brk')
+                    }
+                    
+                    process.argv.push(debugOption)
+                }
+                
+                client.write( JSON.stringify(process.argv) );
+            }
+        );
+
+        client.on('data', function(data) {       
+            
+            //Acknowledging ready state.
+            if ( /\[ quit \]/.test(data) ) {
+                client.end();
+                return
+            }
+            // printing out
+            console.log( data.toString() + '\n');
+            // intercept printed output
+            if (/address already in use/.test(data)) {
+                console.log('If you have previously started a debugger process, you should stop it before.\nIf not running, try to start it then stop it before relaunching your command line.');
+                client.end();
+                return
+            }
+            
+        });
+
+        //client end event.
+        client.on('end', function() {
+            process.exit(0)
+        });
+
+        client.on('error', function(err) {
+            if (isWin32) {
+                console.log('[ gina ] not started, try to start framework as Administrator :\n$ gina start')
+            } else {
+                console.log('[ gina ] not started, try to start framework with :\n$ sudo gina start')
+            }
+            
+            console.debug(err.stack||err);
+            
+            process.exit(1)
+        });    
+    }
+}
+
+onExec();

package/bin/cli-debug

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Mainly used to debug framework CMD lib - default port should be #5858 by default
+ * To modify the debug port :
+ * 
+ * $ gina framework:set --debug-port=<your new debug port>
+ */
+const fs    = require('fs');
+const {exec} = require('child_process');
+const os    = require('os');
+
+var isWin32 = function() {
+    return (os.platform() == 'win32') ? true : false;
+}
+
+var argv = process.argv.splice(2);
+argv = argv.join(' ');
+
+console.log('running: gina ' + argv );
+
+// fetching config
+var homeDir = (process.env[(isWin32()) ? 'USERPROFILE' : 'HOME'] );
+homeDir += (isWin32()) ? '\\.gina' :  '/.gina';
+var mainConf = require(homeDir + ((isWin32()) ? '\\main.json' : '/main.json'));
+
+var version = mainConf.def_framework.split(/\./g);
+version = version.splice(0, 2).join('.');
+
+var settings = require(homeDir + ((isWin32()) ? '\\' + version + '\\settings.json' : '/' + version +'/settings.json'));
+
+var debugPort = null;
+var params = argv.split(/\s+/g);
+if ( params.length > 0 ) {
+    for (var p = 0, len = params.length; p < len; ++p) {
+        if ( /^\-\-port/.test(params[p]) ) {
+            setEnvVar('GINA_PORT', ~~params[p].split(/\=/)[1]);
+            continue;
+        }
+        if ( /^\-\-debug(\_|\-)port/.test(params[p]) ) {
+            setEnvVar('GINA_DEBUG_PORT', ~~params[p].split(/\=/)[1]);
+            continue;
+        }
+        if ( /^\-\-(inspect|debug)/.test(params[p]) ) {
+            debugPort = ~~params[p].split(/\=/)[1];
+            process.argv.splice(p,1);   
+        }
+    }
+}
+
+// gina defaullt debug port
+debugPort = (debugPort != null) ? debugPort : '--inspect-brk=' + settings.debug_port;
+console.log('You should now start debug on port #'+ settings.debug_port);
+exec('node ' + debugPort +' '+ __dirname +'/cli ' + argv, (error, stdout, stderr) => {
+    if (error) {
+        console.error(`exec error: ${error}`);
+        return;
+    }
+    console.log(`${stdout}`);
+});

package/bin/cmd

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs      = require('fs');
+var net     = require('net');
+// `lib` is previously defiened as this file is required by another
+var console = lib.logger;// jshint ignore:line
+
+function Cmd(opt, runOffine) {
+
+    var local = {};
+    var lib = {};
+    
+    var init = function(opt, runOffine) {
+        
+        local.port              = opt.port;
+        local.debugPort         = opt.debugPort;
+        local.debugBrkEnabled   = opt.debugBrkEnabled;
+        local.binPath           = opt.binPath;
+        local.pack              = opt.pack;
+        local.ginaPath          = opt.ginaPath;
+        local.homedir           = opt.homedir;
+        local.frameworkPath     = opt.frameworkPath;
+        
+        lib = require(local.frameworkPath + "/lib");
+
+        checkIfSettings();
+
+        if ( typeof(runOffine) != 'undefined' && /^true$/i.test(runOffine) ) {
+            launchCmd()
+        } else {
+            launchFramework()
+        }
+    };
+    
+
+    var launchFramework = function(){
+
+        var framework = net.createServer( function(conn) {//'connection' listener
+            //feedback.
+            conn.once('end', function() {
+                console.debug('[ CLI ] task completed');
+                // required to allow regular CMD to exit properly
+                conn.end();
+            });
+            // force exit
+            conn.once('exit', function() {
+                //console.info('[ CLI ] task forced to exit')
+                // required to allow regular CMD to exit properly
+                conn.end();
+            });
+
+            //Receiving.
+            conn.on('data', function(data) {
+
+                var argv = JSON.parse( data.toString() );
+
+                console.debug( '[ FRAMEWORK ] CMD received "'+ argv.join(' ') +'"' );
+
+                argv[0] = process.execPath;
+                argv[1] = argv[1] + '/bin/cli';
+                //Launch.
+                lib.cmd.load({
+                    isOnlineCommand : true,
+                    ginaPath : local.ginaPath,
+                    frameworkPath : local.frameworkPath,
+                    pack : local.pack,
+                    argv : argv,
+                    client : conn,
+                    homedir : local.homedir,
+                    debugPort : local.debugPort,
+                    debugBrkEnabled : local.debugBrkEnabled
+                })
+            })
+        });
+
+
+        framework.on('error', function(err) {
+            if (err.code === 'EADDRINUSE') {
+                if (process.argv[2] == 'framework:start') {
+                    var pid = null;
+                    var port  = err.port || getEnvVar('GINA_PORT');// jshint ignore:line
+                    var runningProcs = requireJSON( _(getEnvVar('GINA_HOMEDIR') +'/procs.json', true) );// jshint ignore:line
+                    for (let i in runningProcs) {
+                        if (runningProcs[i].port == port) {
+                            pid = runningProcs[i].pid;
+                            break;
+                        }
+                    }
+                    
+                    
+                    console.warn('Framework already running: [ '+ pid+' ]');
+                } else {
+
+                }
+            } else {
+                console.emerg('Could not start framework. ', err.stack)
+            }
+        });
+
+        framework.listen(local.port, function() { //'listening' listener
+
+            //First time launch.
+            lib.cmd.load({
+                ginaPath : local.ginaPath,
+                frameworkPath : local.frameworkPath,
+                pack : local.pack,
+                argv : process.argv,
+                client : process.stdout,
+                isFromFramework : true,
+                homedir : local.homedir,
+                debugPort : local.debugPort,
+                debugBrkEnabled : local.debugBrkEnabled,
+                task : {
+                    topic : "framework",
+                    action : "start"
+                }
+            })
+        })
+    };
+
+    var launchCmd = function() {
+        
+        var cmd         = process.argv[2].split(':')
+            , topic     = cmd[0]
+            , action    = cmd[1]
+        ;
+                        
+        
+        lib.cmd.load({
+            ginaPath : local.ginaPath,
+            frameworkPath : local.frameworkPath,
+            pack : local.pack,
+            argv : process.argv,
+            client : process.stdout,
+            isFromFramework : true,
+            homedir : local.homedir,
+            debugPort : local.debugPort,
+            debugBrkEnabled : local.debugBrkEnabled,
+            task : {
+                topic : topic,
+                action : action
+            }
+        })
+    };
+
+    var checkIfSettings = function() {
+
+        var home        = getEnvVar('GINA_HOMEDIR');// jshint ignore:line
+        var mainFile    = home + '/main.json';
+        
+        if ( !fs.existsSync(mainFile) ) {
+
+            var mainSrc = getEnvVar('GINA_DIR') + '/resources/home/main.json';// jshint ignore:line
+            var version = getEnvVar('GINA_VERSION');// jshint ignore:line
+            var release = getEnvVar('GINA_SHORT_VERSION');// jshint ignore:line
+
+            try {
+
+                if ( !fs.existsSync(home) ) {
+                    fs.mkdirSync(home, '0775')
+                }
+
+                var data = require(mainSrc);
+                var dic = {
+                    'release' : release,
+                    'version' : version
+                };
+
+                data = whisper(dic, data);// jshint ignore:line
+
+                lib.generator.createFileFromDataSync(data, mainFile)
+
+            } catch (err) {
+                console.error(err.stack);
+                process.exit(1)
+            }
+        }
+
+    }
+
+    init(opt, runOffine)
+}
+module.exports = Cmd;