gina 0.0.9-p91b → 0.1.1-alpha.2

package/framework/v0.1.1-alpha.2/lib/cmd/framework/restart.js

@@ -0,0 +1,124 @@
+var fs          = require('fs');
+const {spawn}       = require('child_process');
+const {execSync}    = require('child_process');
+const util = require('util');
+
+var CmdHelper   = require('./../helper');
+// const { start } = require('repl');
+var console     = lib.logger;
+/**
+ * Framework restart
+ *
+ * e.g.
+ *  gina framework:restart
+ *  or
+ *  gina restart
+ *  or
+ *  gina restart @1.0.0 
+ *
+ * */
+function Restart(opt, cmd) {
+    var self    = {
+        // Current version of the framework by default 
+        // But can be overriden with argument: @{version_number}
+        // eg.: gina stop @1.0.0
+        version: GINA_VERSION
+    };
+    
+
+    var init = function(opt, cmd) {        
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+        var err = null;
+        // check CMD configuration
+        //if (!isCmdConfigured()) return false;
+        // checkcking version number
+        if ( typeof(opt.argv[3]) != 'undefined' && /^@/.test(opt.argv[3]) ) {
+            var version = opt.argv[3].replace(/\@/, '');            
+            var shortVersion = version.split('.').splice(0,2).join('.');
+            if ( !/^\d\.\d/.test(shortVersion) ) {
+                err = new Error('Wrong version: '+ version);
+                console.log(err.message);
+                return;
+            }
+            var availableVersions = requireJSON(_(GINA_HOMEDIR +'/main.json', true)).frameworks[shortVersion];
+            if ( availableVersions.indexOf(version) < 0 ) {
+                err = new Error('Version not installed: '+ version);
+                console.log(err.message);
+                return;
+            }
+            
+            self.version = version;
+        }
+        console.debug('Restarting framework v'+ self.version);
+        
+        // if (!self.name) {
+        //     stop(opt, cmd, 0);
+        // } else {
+            restart(opt, cmd);
+        // }        
+    }
+    
+    var restart = function(opt, cmd) {
+        stop();
+        start();
+    }
+    
+    var stop = function() {
+        var out = null;
+        try {
+            out = execSync('gina stop @'+self.version).toString();
+            console.debug(out);
+        } catch (err) {
+            throw err;
+        }
+    }
+    
+    /**
+     * start
+     * 
+     * We need to spawn this one as detached
+     * because of the `process.kill(..., 'SIGSTOP')` used inside the orginal `start` script
+     * or else, the restart script will be pending forever.
+     */
+    var start = async function() {        
+        try {            
+            var child = spawn('gina', ['start', '@'+self.version, '--restart-pid='+ process.pid],
+                {
+                    detached: true
+                }
+            );
+            
+            var frameworkPid = null;
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', function(data) {
+                //process.stdout.write(data);
+                if ( new RegExp('Gina server started with PID','gi').test(data) ) {
+                    frameworkPid = data.match(/\`\d+\`/)[0];
+                    process.stdout.write('Gina server started with PID '+ frameworkPid + '\r\n');
+                }
+                
+                if ( /\[ quit \]/.test(data) ) {
+                    // TODO - restart all running bundles
+                    
+                    process.exit(0)
+                }
+            });
+            
+            child.stderr.setEncoding('utf8');
+            var error = null;
+            child.stderr.on('data', function(err) {
+                error = err.toString();
+                console.error(error);
+            });            
+            
+        } catch (err) {
+            throw err;
+        }        
+    }
+    
+
+    init(opt, cmd)
+}
+
+module.exports = Restart;

package/framework/v0.1.1-alpha.2/lib/cmd/framework/set.js

@@ -0,0 +1,161 @@
+var console = lib.logger;
+
+function Set(opt){
+    
+    var mainConfPath        = _(GINA_HOMEDIR + '/main.json')
+        , mainConf          = require(mainConfPath)
+        , mainSettingsPath  = _(GINA_HOMEDIR +'/'+ GINA_SHORT_VERSION + '/settings.json')
+        , mainSettingsConf  = require(mainSettingsPath)
+    ;
+
+    var init = function(opt){
+        
+        var a = [], k = null, v = null;
+        for (let i=3; i<process.argv.length; ++i) {
+            a = process.argv[i].split(/=/);
+            k = a[0];
+            v = a[1];
+            console.debug('Preprocessing `framework:set '+ process.argv[i] +'`');
+            set(k,v);
+        }
+    };
+
+
+
+    var set = function(k, v) {
+        var err = null;
+        if ( /^-—/.test(k) ) {
+            k = k.replace(/-—/, '--');
+        }
+        switch(k) {
+            case '--log_level':
+            case '--log-level':
+                setLogLevel(v);
+            break;
+            
+            case '--env':
+                setEnv(v);
+            break;
+            
+            case '--scope':
+                setScope(v)
+            break;
+            
+            case '--culture':
+                setCulture(v);
+            break;
+            
+            case '--port':
+                setPort(v);
+            break;  
+            
+            case '--debug_port':
+            case '--debug-port':
+                setDebugPort(v);
+            break;            
+            
+            case '--timezone':
+                setTimezone(v);
+            break;
+            
+            default:
+                err = new Error('Setting environment variable `'+ k +'` is not supported');
+                console.error(err.message);
+                
+        }
+    }
+
+    var setLogLevel = function(level) {
+        var supported   = mainConf['log_levels'][GINA_SHORT_VERSION]
+            , err       = null
+        ;
+        if (supported.indexOf(level) < 0) {
+            err = new Error('Log level `'+ level +'` is not supported at the moment');
+            console.error(err.message);
+            return;
+        }
+        // save to ~/.gina/main.json
+        mainConf['def_log_level'][GINA_SHORT_VERSION] = level;        
+        lib.generator.createFileFromDataSync(mainConf, mainConfPath);
+        // save to ~/.gina/{GINA_VERSION_SHORT}/settings.json
+        process['gina']['log_level'] = level;
+        mainSettingsConf['log_level'] = level;
+        lib.generator.createFileFromDataSync(mainSettingsConf, mainSettingsPath);
+    }
+        
+    var setEnv = function(env) {
+        var supported   = mainConf['envs'][GINA_SHORT_VERSION]
+            , err       = null
+        ;
+        if (supported.indexOf(env) < 0) {
+            err = new Error('Environment `'+ env +'` is not supported at the moment');
+            console.error(err.message);
+            return;
+        }
+        mainConf['def_env'][GINA_SHORT_VERSION] = env;
+        // save to ~/.gina/main.json
+        lib.generator.createFileFromDataSync(mainConf, mainConfPath);
+    }
+    
+    var setScope = function(scope) {
+        var supported   = mainConf['scopes'][GINA_SHORT_VERSION]
+            , err       = null
+        ;
+        if (supported.indexOf(scope) < 0) {
+            err = new Error('Scope `'+ scope +'` is not supported at the moment');
+            console.error(err.message);
+            return;
+        }
+        mainConf['def_scope'][GINA_SHORT_VERSION] = scope;
+        // save to ~/.gina/main.json
+        lib.generator.createFileFromDataSync(mainConf, mainConfPath);
+    }
+    
+    var setCulture = function(culture) {        
+        var supported   = mainConf['cultures'][GINA_SHORT_VERSION]
+            , err       = null
+        ;
+        if (supported.indexOf(culture) < 0) {
+            err = new Error('Culture `'+ culture +'` is not supported at the moment');
+            console.error(err.message);
+            return;
+        }
+        // save to ~/.gina/main.json
+        mainConf['def_culture'][GINA_SHORT_VERSION] = culture;        
+        lib.generator.createFileFromDataSync(mainConf, mainConfPath);
+        // save to ~/.gina/{GINA_VERSION_SHORT}/settings.json
+        process['gina']['culture'] = culture;
+        mainSettingsConf['culture'] = culture;
+        lib.generator.createFileFromDataSync(mainSettingsConf, mainSettingsPath);
+    }
+    
+    var setPort = function(port) {
+        console.debug('Setting `port` to #'+ port);
+        // save to ~/.gina/{GINA_VERSION_SHORT}/settings.json
+        process['gina']['port'] = ~~port;
+        mainSettingsConf['port'] = ~~port;
+        lib.generator.createFileFromDataSync(mainSettingsConf, mainSettingsPath);
+    }
+    
+    var setDebugPort = function(port) {
+        console.debug('Setting `debug port` to #'+ port);
+        // save to ~/.gina/{GINA_VERSION_SHORT}/settings.json
+        process['gina']['debug_port'] = ~~port;
+        mainSettingsConf['debug_port'] = ~~port;
+        lib.generator.createFileFromDataSync(mainSettingsConf, mainSettingsPath);
+    }
+    
+    var setTimezone = function(timezone) {
+        // save to ~/.gina/main.json
+        mainConf['def_timezone'][GINA_SHORT_VERSION] = timezone;        
+        lib.generator.createFileFromDataSync(mainConf, mainConfPath);
+        // save to ~/.gina/{GINA_VERSION_SHORT}/settings.json
+        process['gina']['timezone'] = timezone;
+        mainSettingsConf['timezone'] = timezone;
+        lib.generator.createFileFromDataSync(mainSettingsConf, mainSettingsPath);
+    }
+
+    init(opt)
+};
+
+module.exports = Set

package/framework/v0.1.1-alpha.2/lib/cmd/framework/start.js

@@ -0,0 +1,96 @@
+'use strict';
+var fs      = require('fs');
+var help    = require( getPath('gina').root + '/utils/helper');
+// var child   = require('child_process');
+var lib     = require( getPath('gina').lib );
+//var helpers     = require( getPath('gina').helpers );
+var console = lib.logger;
+/**
+ * Framework start command - Needs to be launched as [sudo], [admin] or [root]
+ *
+ * NB.: Another alternative is to set appropriate permissions for `/var/run/gina`
+ * e.g. if you have a `gina` user in the `www-data` group
+ *  $ sudo mkdir /var/run/gina
+ *  $ sudo chown -R gina:www-data /var/run/gina
+ *
+ * @param {object} opt - Constructor options
+ * */
+function Start(opt){
+
+    //Get services list.
+    var self = {};
+
+    var console = lib.logger;
+
+    //var self = {
+    //    opt : opt,
+    //    cmd : 'framework:start',
+    //    servicesList : list.services[opt.release]
+    //};
+
+    var init = function(opt){
+        
+        
+        self.pid        = opt.pid;
+        setEnvVar('GINA_PID', opt.pid);
+        self.projects   = require(GINA_HOMEDIR + '/projects.json');
+        self.services   = [];
+        self.bundles    = [];
+
+        cleanPIDs();
+        console.notice('Framework ready for connections\n');
+
+    };
+
+    var cleanPIDs = function() {
+        var f = 0
+            , path = _(GINA_RUNDIR)
+            , files = null
+        ;
+
+        if ( fs.existsSync( path ) ) {
+            try {
+
+                files = fs.readdirSync( path );
+
+            } catch (err) {
+
+                //if (err.stack)
+                //    err.stack = 'Possible write privilege exception: grant access to your user or run the command as sudo/admin\n'+ err.stack;
+
+                console.crit(err.stack||err.message);
+                process.exit(1);
+            }
+
+
+            for (;f < files.length; ++f) {
+                
+                // skip all but framework pid files
+                if ( files[f] != process.title +'.pid' ) {
+                    continue;
+                }
+                
+                let filePid = null;
+                try {
+                    filePid = fs.readFileSync(_(path +'/'+ files[f], true)).toString().trim();
+                } catch(fileErr) {
+                    fs.unlinkSync(_(path +'/'+ files[f], true));
+                    continue;
+                }
+                // remove old framework pid files
+                if (filePid && filePid != self.pid) {
+                    try {
+                        new _(path +'/'+ files[f]).rmSync()
+                    } catch(err) {
+                        console.error(err.stack||err.message);
+                        process.exit(1);
+                    }
+                }
+            }
+        }
+    }
+
+    init(opt)
+}
+
+module.exports = Start;

package/framework/v0.1.1-alpha.2/lib/cmd/framework/status.js

@@ -0,0 +1,72 @@
+var fs          = require('fs');
+const {spawn}       = require('child_process');
+const {execSync}    = require('child_process');
+//const { debug } = require('console');
+
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+/**
+ * Framework status
+ *
+ * e.g.
+ *  gina framework:status
+ *  or
+ *  gina status
+ *
+ * */
+function Status(opt, cmd) {
+    var self    = {};
+    
+
+    var init = function(opt, cmd) {
+        
+        console.debug('Getting framework status');
+        
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+                        
+        // check CMD configuration
+        //if (!isCmdConfigured()) return false;
+        
+        
+        // if (!self.name) {
+        //     status(opt, cmd, 0);
+        // } else {
+            status(opt, cmd);
+        // }        
+    }
+    
+    var status = function(opt, cmd) {
+        var pidFiles = null;
+        try {
+            pidFiles = fs.readdirSync(GINA_RUNDIR);
+        } catch (fileError) {
+            throw fileError
+        }
+        
+        var runningVersions = [];
+        for (let i=0, len=pidFiles.length; i<len; i++) {
+            let file = pidFiles[i];
+            if ( !/^gina\-/.test(file) ) {
+                continue;
+            }
+            let pid = fs.readFileSync(_(GINA_RUNDIR +'/'+ file)).toString().trim() || null;
+            runningVersions.push({
+                title   : file.replace(/\.pid$/, ''),
+                pid     : ~~pid
+            });
+        }
+        
+        if ( runningVersions.length > 0 ) {
+            console.log('Gina is running');
+            return
+        }
+        
+        console.log('Gina is not running');
+    }
+    
+
+    init(opt, cmd)
+}
+
+module.exports = Status;

package/framework/v0.1.1-alpha.2/lib/cmd/framework/stop.js

@@ -0,0 +1,159 @@
+var fs          = require('fs');
+const {spawn}       = require('child_process');
+const {execSync}    = require('child_process');
+//const { debug } = require('console');
+
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+/**
+ * Framework stop
+ *
+ * e.g.
+ *  gina framework:stop
+ *  or
+ *  gina stop
+ *  or
+ *  gina stop @1.0.0 
+ *
+ * */
+function Stop(opt, cmd) {
+    var self    = {
+        // Current version of the framework by default 
+        // But can be overriden with argument: @{version_number}
+        // eg.: gina stop @1.0.0
+        version: GINA_VERSION,
+        // Used to close suspended parent process if exists
+        // This is required if you don't use gina (gina/bin/cli) as a daemon
+        fakeDeamonPid: false
+    };
+    
+
+    var init = function(opt, cmd) {        
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+        
+        // check CMD configuration
+        //if (!isCmdConfigured()) return false;
+        
+        var err = null;
+        var argv = opt.argv;
+        for (let i = 0, len = argv.length; i < len; i++) {            
+            // checkcking version number
+            if ( /^\@/.test(argv[i]) ) {
+                let version = argv[i].replace(/\@/, '');            
+                let shortVersion = version.split('.').splice(0,2).join('.');
+                if ( !/^\d\.\d/.test(shortVersion) ) {
+                    err = new Error('Wrong version: '+ version);
+                    console.log(err.message);
+                    break;
+                }
+                let availableVersions = requireJSON(_(GINA_HOMEDIR +'/main.json', true)).frameworks[shortVersion];
+                if ( availableVersions.indexOf(version) < 0 ) {
+                    err = new Error('Version not installed: '+ version);
+                    console.log(err.message);
+                    break;
+                }
+                
+                self.version = version;
+                continue;
+            }
+        }
+        
+        if ( err ) {
+            return;
+        }
+        console.debug('Stopping framework v'+ self.version);
+        
+        // if (!self.name) {
+        //     stop(opt, cmd, 0);
+        // } else {
+            stop(opt, cmd);
+        // }        
+    }
+    
+    var stop = function(opt, cmd) {
+        var pidFiles = null, err = null;
+        try {
+            pidFiles = fs.readdirSync(GINA_RUNDIR);
+        } catch (fileError) {
+            throw fileError
+        }
+        
+        var runningVersions = [];
+        for (let i=0, len=pidFiles.length; i<len; i++) {
+            let file = pidFiles[i];
+            if ( !/^gina\-/.test(file) ) {
+                continue;
+            }
+            let pid = fs.readFileSync(_(GINA_RUNDIR +'/'+ file)).toString().trim() || null;
+            runningVersions.push({
+                title   : file.replace(/\.pid$/, ''),
+                pid     : ~~pid
+            });
+        }
+        var pid = null, fakeDaemonPid = null;
+        if ( runningVersions.length > 0 ) {
+            // retrieve running pid vs running version
+            var runningProcs = requireJSON(_(GINA_HOMEDIR +'/procs.json', true));            
+            for (let name in runningProcs) {
+                if (runningProcs[name].version == self.version) {
+                    pid = runningProcs[name].pid;
+                    // checking for fake daemon
+                    if ( typeof(runningProcs[name].fakeDaemonPid) != 'undefined' ) {
+                        fakeDaemonPid = runningProcs[name].fakeDaemonPid;
+                    }
+                    break;
+                }
+            }
+            // Resume halted fake daemon process
+            if (fakeDaemonPid) {
+                try {
+                    process.kill(fakeDaemonPid, 'SIGCONT');
+                } catch (fakeDaemonErr) {
+                    // this only means that it does not exists or has already been killed
+                }
+                
+            }
+            if (pid) {
+                for (let i=0, len=runningVersions.length; i<len; i++) {
+                    if (runningVersions[i].pid == pid) {
+                        console.debug('Sending `SIGTERM` for pid `'+ pid +'`');
+                        process.kill(pid, 'SIGTERM');
+                        break;
+                    }
+                }
+                
+                console.log('Gina v'+ self.version + ' has been stopped');
+                return
+            }   
+        }
+        
+        // Double check in case of a bug ...
+        if ( !isWin32() ) {
+            var out  = null;
+            try {
+                // Retrive pid
+                // ps -ef | grep -v grep | grep "gina-v0.1.0" | awk '{print $2}'
+                out = execSync("ps -ef | grep -v grep | grep 'gina-v"+ self.version +"' | awk '{print $2}'").toString() || null;
+                if ( out && typeof(out) == 'string' && out.trim().length > 0) {
+                    pid = out.trim();
+                    console.debug('Found unlinked process ['+ pid +']\nNow trying to kill it ...');
+                    
+                    process.kill(pid, 'SIGTERM');
+                    console.log('Gina v'+ self.version + ' has been stopped');
+                    return   
+                }
+            } catch(execErr) {
+                // Silence is golden ...
+                throw execErr
+            }            
+        }
+        
+        console.log('Gina v'+ self.version + ' is not running');        
+    }
+    
+
+    init(opt, cmd)
+}
+
+module.exports = Stop;