gina 0.0.9-p91b → 0.1.1-alpha.2

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

@@ -0,0 +1,436 @@
+var fs      = require('fs');
+
+var CmdHelper   = require('./../helper');
+var console = lib.logger;
+var scan    = require('../port/inc/scan.js');
+
+/**
+ * Add new environment for a given project
+ *
+ *
+ * */
+function Add(opt, cmd) {
+    var self = {}, local = {};
+
+    var init = function() {
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+
+        // check CMD configuration
+        if ( !isCmdConfigured() ) return false;
+        
+        self.projects = requireJSON(_(GINA_HOMEDIR + '/projects.json'));        
+        self.bundles = [];
+        self.portsAvailable = {};
+        
+        var i = 3, envs = [];
+        for (; i<process.argv.length; ++i) {
+            if ( /^\@[a-z0-9_.]/.test(process.argv[i]) ) {
+                if ( !isValidName(process.argv[i]) ) {
+                    console.error('[ '+process.argv[i]+' ] is not a valid project name. Please, try something else: @[a-z0-9_.].');
+                    process.exit(1);
+                }
+
+            } else if (/^[a-z0-9_.]/.test(process.argv[i])) {
+                envs.push(process.argv[i])
+            }
+        }
+        
+        
+        if ( typeof(self.projectName) == 'undefined') {
+            var folder = new _(process.cwd()).toArray().last();
+            if ( isDefined('project', folder) ) {
+                self.projectName = folder
+            }
+        }
+        
+        if ( isDefined('project', self.projectName) && envs.length > 0) {
+            self.envs = envs;
+            saveEnvs()
+        } else {
+            //console.error('[ '+ self.projectName+' ] is not an existing project');
+            console.error('Missing argument @<project_name>');
+            process.exit(1)
+        }
+    }
+ 
+
+    var saveEnvs = function() {
+        var file    = _(self.projects[self.projectName].path + '/env.json')
+            , ports = require(_(GINA_HOMEDIR + '/ports.json'))
+        ;
+
+
+        if ( !fs.existsSync( _(self.projects[self.projectName].path + '/manifest.json') )) {
+            console.error('project corrupted');
+            process.exit(1)
+        }
+
+        self.project = requireJSON(_(self.projects[self.projectName].path + '/manifest.json'));
+        self.portsList = []; // list of all ports to ignore whles scanning
+        var protocols = self.projects[self.projectName].protocols;
+        var schemes = self.projects[self.projectName].schemes;
+        for (let protocol in ports) {
+            if (protocols.indexOf(protocol) < 0) continue;
+            for (let scheme in ports[protocol]) {
+                if (schemes.indexOf(scheme) < 0) continue;
+                for (let p in ports[protocol][scheme]) {
+                    if ( self.portsList.indexOf(p) > -1 ) continue;
+                    self.portsList.push(p)
+                }
+            }            
+        }
+        self.portsList.sort();
+        for (let b in self.project.bundles) {
+            self.bundles.push(b)
+        }
+
+        // to env.json file
+        if ( !fs.existsSync(file) ) {
+            lib.generator.createFileFromDataSync({}, file)
+        }
+
+        if ( typeof(self.bundles.length) == 'undefined' || self.bundles.length == 0) {
+            try {
+                addEnvToProject();
+                console.log('environment'+((self.envs.length > 1) ? 's' : '')+' [ '+ self.envs.join(', ') +' ] created');
+                process.exit(0);
+            } catch (err) {
+                console.error(err.stack||err.message);
+                process.exit(1)
+            }
+        } else {
+            // rollback infos
+            self.envPath = _(self.projects[self.projectName].path + '/env.json');
+            self.envData = requireJSON(self.envPath);
+            self.portsPath = _(GINA_HOMEDIR + '/ports.json');
+            self.portsData = require(self.portsPath);
+            self.portsReversePath = _(GINA_HOMEDIR + '/ports.reverse.json');
+            self.portsReverseData = require(self.portsReversePath);
+
+            addEnvToBundles(0)
+        }
+    }
+
+
+    /**
+     * Adding envs to /project/root/env.json
+     *
+     * @param {string} file
+     * */
+    var addEnvToBundles = function(b) {
+        if (b > self.bundles.length-1) {// done
+            try {
+                addEnvToProject();
+                console.log('environment'+((self.envs.length > 1) ? 's' : '')+' [ '+ self.envs.join(', ') +' ] created');
+                process.exit(0)
+            } catch (err) {
+                console.error(err.stack||err.message);
+                process.exit(1)
+            }
+        }
+
+        var bundle  = self.bundles[b] ;
+
+        if ( /^[a-z0-9_.]/.test(bundle) ) {
+
+            local.bundle    = bundle;
+            local.b         = b;
+                                   
+                        
+            // find available port
+            var options = {
+                ignore  : getPortsList(),
+                limit   : getBundleScanLimit(bundle)
+            };
+            console.log('['+bundle+'] starting ports scan' );
+            
+            scan(options, function(err, ports){
+                if (err) {
+                    rollback(err);
+                    return;
+                }
+
+                for (let p=0; p<ports.length; ++p) {
+                    self.portsList.push(ports[p])
+                }
+                self.portsList.sort();
+                
+                console.debug('available ports '+ JSON.stringify(ports, null, 2));
+                //self.portsAvailable = ports;
+                setPorts(local.bundle, ports, function onPortsSet(err) {
+                    if (err) {
+                        rollback(err);
+                        return;
+                    }
+                    
+                    //console.debug('available ports '+ JSON.stringify(self.portsAvailable[local.bundle], null, 2));
+                    ++local.b;
+                    addEnvToBundles(local.b)
+                });
+            })
+
+        } else {
+            console.error('[ '+ bundle+' ] is not a valid bundle name')
+            process.exit(1)
+        }
+    }
+
+    // var setPorts = function(bundle, env) {
+    //     var portsPath           = _(GINA_HOMEDIR + '/ports.json', true)
+    //         , portsReversePath  = _(GINA_HOMEDIR + '/ports.reverse.json', true)
+    //         , envDataPath       = _(self.projects[self.projectName].path + '/env.json', true)
+    //     ;
+
+
+    //     if ( typeof(require.cache[portsPath]) != 'undefined') {
+    //         delete require.cache[require.resolve(portsPath)]
+    //     }
+    //     if ( typeof(require.cache[portsReversePath]) != 'undefined') {
+    //         delete require.cache[require.resolve(portsReversePath)]
+    //     }
+    //     if ( typeof(require.cache[envDataPath]) != 'undefined') {
+    //         delete require.cache[require.resolve(envDataPath)]
+    //     }
+
+    //     var envData             = requireJSON(envDataPath)
+    //         , portsData         = require(portsPath)
+    //         , portsReverseData  = require(portsReversePath)
+    //     ;
+
+
+    //     var content                 = JSON.clone(envData)
+    //         , ports                 = JSON.clone(portsData)
+    //         , portsReverse          = JSON.clone(portsReverseData)
+    //         , allProjectEnvs        = self.projects[self.projectName].envs
+    //         , allProjectProtocols   = self.projects[self.projectName].protocols
+    //         , allProjectSchemes     = self.projects[self.projectName].schemes
+    //     ;
+        
+        
+        
+    //     // BO project/env.json
+    //     if ( typeof(content[bundle]) == 'undefined' ) {
+    //         content[bundle] = {}
+    //     }
+        
+    //     // getting available all envs
+    //     for (let n in self.envs) {
+    //         let newEnv = self.envs[n];
+    //         if (allProjectEnvs.indexOf(newEnv) < 0) {
+    //             console.debug('adding new env ['+newEnv+'] VS' + JSON.stringify(self.envs, null, 2));
+    //             allProjectEnvs.push(newEnv);
+    //         }
+    //     }
+    //     // getting available all protocols
+    //     for (let p in self.protocols) {
+    //         let newProtocol = allProjectProtocols[p];
+    //         if (allProjectProtocols.indexOf(newProtocol) < 0) {
+    //             console.debug('adding new protocol ['+newProtocol+'] VS' + JSON.stringify(self.protocols, null, 2));
+    //             allProjectProtocols.push(newProtocol);
+    //         }
+    //     }
+    //     // getting available all schemes
+    //     for (let p in self.schemes) {
+    //         let newScheme = allProjectSchemes[p];
+    //         if (allProjectSchemes.indexOf(newScheme) < 0) {
+    //             console.debug('adding new scheme ['+newScheme+'] VS' + JSON.stringify(self.schemes, null, 2));
+    //             allProjectSchemes.push(newScheme);
+    //         }
+    //     }
+        
+    //     // editing env.json to add host infos
+    //     for (let e in allProjectEnvs) {
+    //         let env = allProjectEnvs[e];
+    //         if ( typeof(content[bundle][env]) == 'undefined' ) {
+    //             content[bundle][env] = {
+    //                 "host" : "localhost"
+    //             }
+    //         }
+    //     }            
+    //     // EO project/env.json
+        
+        
+    //     // BO ~/.gina/ports.reverse.json - part 1/2
+    //     if ( typeof(portsReverse[bundle + '@' + self.projectName]) == 'undefined' ) {
+    //         portsReverse[bundle + '@' + self.projectName] = {}
+    //     }
+    //     if ( 
+    //         typeof(portsReverse[bundle + '@' + self.projectName][env]) == 'undefined'
+    //         ||
+    //         /^string$/i.test( typeof(portsReverse[bundle + '@' + self.projectName][env]) )
+    //     ) {
+    //         portsReverse[bundle + '@' + self.projectName][env] = {}
+    //     }          
+    //     // EO ~/.gina/ports.reverse.json - part 1/2
+
+        
+    //     // BO ~/.gina/ports.json
+    //     for (let p in allProjectProtocols) {
+    //         let protocol = allProjectProtocols[p];
+    //         if ( typeof(ports[protocol]) == 'undefined' ) {
+    //             ports[protocol] = {}
+    //         }
+    //         if ( typeof(portsReverse[bundle + '@' + self.projectName][env][protocol]) == 'undefined' ) {
+    //             portsReverse[bundle + '@' + self.projectName][env][protocol] = {}
+    //         }
+    //         for (let s in allProjectSchemes) {
+    //             let scheme = allProjectSchemes[s];
+    //             // skipping none `https` schemes for `http/2`
+    //             if ( /^http\/2/.test(protocol) && scheme != 'https' ) {
+    //                 console.debug('skipping none `https` schemes for `http/2`');
+    //                 continue;
+    //             }
+    //             if ( typeof(ports[protocol][scheme]) == 'undefined' ) {
+    //                 ports[protocol][scheme] = {}
+    //             }
+    //             if ( typeof(portsReverse[bundle + '@' + self.projectName][env][protocol][scheme]) == 'undefined' ) {
+    //                 portsReverse[bundle + '@' + self.projectName][env][protocol][scheme] = {}
+    //             }
+                
+    //             let assigned = [];
+    //             if ( ports[protocol][scheme].count() > 0 ) {
+    //                 for (let port in ports[protocol][scheme]) {
+    //                     let portDescription = ports[protocol][scheme][port] || null;
+    //                     // already assigned
+    //                     if ( portDescription && assigned.indexOf(portDescription) > -1 ) {
+    //                         // cleanup
+    //                         delete ports[protocol][scheme][port];
+    //                         self.portsAvailable[bundle][env].unshift(port);
+    //                         continue;
+    //                     }
+    //                     assigned.push(portDescription);                    
+    //                 }
+    //             }
+                    
+                
+    //             let stringifiedScheme = JSON.stringify(ports[protocol][scheme]);
+    //             let patt = new RegExp(bundle +'@'+ self.projectName +'/'+ env);
+    //             let found = false;
+    //             let portToAssign = null;
+    //             // do not override if existing
+    //             if ( patt.test(stringifiedScheme) ) { // there can multiple matches
+    //                 found = true;                    
+    //                 // reusing the same for portsReverse
+    //                 let re = new RegExp('([0-9]+)\"\:(|\s+)\"('+ bundle +'\@'+ self.projectName +'\/'+ env +')', 'g');
+    //                 let m;
+    //                 while ((m = re.exec(stringifiedScheme)) !== null) {
+    //                     // This is necessary to avoid infinite loops with zero-width matches
+    //                     if (m.index === re.lastIndex) {
+    //                         re.lastIndex++;
+    //                     }                        
+    //                     // The result can be accessed through the `m`-variable.
+    //                     try {
+    //                         m.forEach((match, groupIndex) => {
+    //                             //console.debug(`Found match, group ${groupIndex}: ${match}`);
+    //                             if (groupIndex == 1) {                                    
+    //                                 portToAssign = ~~match;
+    //                                 //console.debug('['+bundle+'] port to assign '+ portToAssign + ' - ' + protocol +' '+ scheme);
+    //                                 throw new Error('breakExeception');
+    //                             }
+    //                         });
+    //                     } catch (breakExeption) {
+    //                         break;
+    //                     }
+    //                 }
+                    
+    //             }
+                
+    //             if (!portToAssign) {
+    //                 //console.debug('['+bundle+'] No port to assign '+ portToAssign + ' - ' + protocol +' '+ scheme);
+    //                 portToAssign = self.portsAvailable[bundle][env][0];
+    //                 // port is no longer available
+    //                 self.portsAvailable[bundle][env].splice(0,1);
+    //             }
+    //             ports[protocol][scheme][portToAssign] = bundle +'@'+ self.projectName +'/'+ env;
+                
+    //             // BO ~/.gina/ports.reverse.json - part 2/2
+    //             //override needed since it is relying on ports definitions
+    //             portsReverse[bundle + '@' + self.projectName][env][protocol][scheme] = ~~portToAssign;
+    //             // EO ~/.gina/ports.reverse.json - part 2/2
+                    
+    //         } // EO for (let scheme in schemes)
+    //     } // for (let protocol in protocols)        
+    //     // EO ~/.gina/ports.json
+        
+        
+
+    //     try {
+    //         // save to /<project_path>/env.json
+    //         lib.generator.createFileFromDataSync(content, envDataPath);
+    //         self.envDataWrote = true;
+    //         // save to ~/.gina/projects.json
+    //         // lib.generator.createFileFromDataSync(ports, portsPath);
+    //         // self.projectsDataWrote = true;
+            
+    //         // save to ~/.gina/ports.json
+    //         lib.generator.createFileFromDataSync(ports, portsPath);
+    //         self.portsDataWrote = true;
+    //         // save to ~/.gina/ports.reverse.json
+    //         lib.generator.createFileFromDataSync(portsReverse, portsReversePath);
+    //         self.portsReverseDataWrote = true;
+
+    //         ++local.b;
+    //         addEnvToBundles(local.b, local.e)
+    //     } catch (err) {
+    //         rollback(err)
+    //     }
+    // }
+
+    /**
+     * Adding envs to ~/.gina/projects.json
+     *
+     * @param {array} envs
+     * */
+    var addEnvToProject = function() {
+        var e = 0
+            , newEnvs = self.envs
+            , projects = JSON.clone(self.projects)
+            , envs = projects[self.projectName].envs
+        ;
+        // to ~/.gina/projects.json
+        for (; e < newEnvs.length; ++e) {
+            if (envs.indexOf(newEnvs[e]) < 0 ) {
+                modified = true;
+                envs.push(newEnvs[e])
+            }
+        }
+        //writing
+        lib.generator.createFileFromDataSync(
+            projects,
+            self.projectsPath
+        );
+        self.projectDataWrote = true
+    }
+    
+    var updateManifest = function() {
+        
+    }
+
+    var rollback = function(err) {
+        console.error('could not complete env registration: ', (err.stack||err.message));
+        console.warn('rolling back...');
+
+        var writeFiles = function() {
+            //restore env.json
+            lib.generator.createFileFromDataSync(self.envData, self.envPath);            
+
+            //restore ports.json
+            lib.generator.createFileFromDataSync(self.portsData, self.portsPath);
+
+            //restore ports.reverse.json
+            lib.generator.createFileFromDataSync(self.portsReverseData, self.portsReversePath);
+            
+            // restore projects.json
+            lib.generator.createFileFromDataSync(self.projects, self.projectsPath);
+
+            process.exit(1)
+        };
+
+        writeFiles()
+    };
+
+    init()
+};
+
+module.exports = Add

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

@@ -0,0 +1,62 @@
+var console = lib.logger;
+/**
+ * Get framework settings
+ *
+ * e.g.
+ *  // get all
+ *  $ gina env:get
+ *
+ *  // get rundir
+ *  $ gina env:get --rundir
+ *
+ *  //get rundir & log_level
+ *  $ gina env:get --rundir --log-level
+ *
+ *  // set or change log_level
+ *  $ gina env:set --log-level=debug
+ *
+ * */
+function Get(opt, cmd){
+    var self = {};
+
+    var init = function(){
+        self.target     = _(GINA_HOMEDIR +'/' + GINA_RELEASE + '/settings.json');
+        self.settings   = require(self.target);
+        self.bulk       = false;
+
+        if ( process.argv.length > 3 ) {
+            self.bulk = true
+        }
+        get()
+    }
+
+    var get = function() {
+        var str = ''
+            , key = ''
+            , settings = self.settings;
+        if (!self.bulk) {
+            for(var prop in settings) {
+                str += prop +' = '+ settings[prop] +'\n'
+            }
+        } else {
+            for (var i=0; i<process.argv.length; ++i) {
+                if ( /^(\-\-)/.test(process.argv[i]) ) {
+                    key = process.argv[i].replace(/\-\-/, '').replace(/\-/, '_');
+                    if ( typeof(settings[key]) != 'undefined' ) {
+                        str += settings[key] +'\n'
+                    }
+                }
+            }
+
+        }
+
+        if (str != '')
+            console.log(str.substr(0, str.length-1));
+
+        process.exit(0)
+    }
+
+    init()
+};
+
+module.exports = Get

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

@@ -0,0 +1,28 @@
+var fs          = require('fs');
+
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+
+/**
+ * Help
+ *
+ * */
+function Help(opt, cmd) {
+    var self = {};
+
+    var init = function() {
+
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+
+        // check CMD configuration
+        if ( !isCmdConfigured() ) return false;
+
+
+        getHelp()
+    }
+
+    init()
+};
+
+module.exports = Help

package/framework/v0.1.1-alpha.2/lib/cmd/env/help.txt

@@ -0,0 +1,33 @@
+******************************
+* Env command lines e.g.     *
+******************************
+
+
+[ Adding a new environment ]
+
+    Adding/refreshing environment to a project
+    ----------
+
+    To add a new environment or to refresh an existing one, use the following command line.
+
+    $ gina env:add <env_name> @<project_name>
+    
+    
+    Adding/refreshing environment to a bundle
+    ----------
+    
+    $ gina env:add <bundle_name>/<env_name> @<project_name>
+
+
+[ Removing an existing environment ]
+
+    $ gina env:remove <env_name> @<project_name>
+
+
+[ Listing all environments inside your project ]
+
+    $ gina env:list @<project_name>
+
+    or to list all projects environments
+
+    $ gina env:list

package/framework/v0.1.1-alpha.2/lib/cmd/env/link-dev.js

@@ -0,0 +1,80 @@
+var console = lib.logger;
+/**
+ * Link environment to development - A way of renaming dev
+ * */
+function LinkDev(opt, cmd) {
+    var self = {};
+
+    var init = function() {
+        self.target = _(GINA_HOMEDIR + '/projects.json');
+        self.projects   = require(self.target);
+
+        if ( typeof(process.argv[4]) != 'undefined') {
+            if ( !isValidName(process.argv[4]) ) {
+                console.error('[ '+process.argv[4]+' ] is not a valid project name. Please, try something else: @[a-z0-9_.].');
+                process.exit(1);
+            }
+        } else {
+            // is current path == project path ?
+            var root = process.cwd();
+            var name = new _(root).toArray().last();
+            if ( isDefined(name) ) {
+                self.name = name
+            }
+        }
+
+        if ( typeof(process.argv[3]) != 'undefined' ) {
+            if ( !self.projects[self.name].envs.inArray(process.argv[3]) ) {
+                console.error('Environment [ '+process.argv[3]+' ] not found');
+                process.exit(1)
+            }
+        } else {
+            console.error('Missing argument in [ gina env:use <environment> ]');
+            process.exit(1)
+        }
+
+        if ( typeof(self.name) == 'undefined' ) {
+            console.error('Project name is required: @<project_name>');
+            process.exit(1)
+        } else if ( typeof(self.name) != 'undefined' && isDefined(self.name) ) {
+            link(process.argv[3], self.projects, self.target)
+        } else {
+            console.error('[ '+self.name+' ] is not a valid project name.');
+            process.exit(1)
+        }
+    }
+
+    var isDefined = function(name) {
+        if ( typeof(self.projects[name]) != 'undefined' ) {
+            return true
+        }
+        return false
+    }
+
+    var isValidName = function(name) {
+        if (name == undefined) return false;
+
+        self.name = name.replace(/\@/, '');
+        var patt = /^[a-z0-9_.]/;
+        return patt.test(self.name)
+    }
+
+    var link = function(env, projects, target) {
+
+        if (env !== projects[self.name]['dev_env']) {
+            if (projects[self.name]['def_env'] === projects[self.name]['dev_env']) {
+                projects[self.name]['def_env'] = env
+            }
+
+            projects[self.name]['dev_env'] = env;
+            lib.generator.createFileFromDataSync(
+                projects,
+                target
+            )
+        }
+    };
+
+    init()
+};
+
+module.exports = LinkDev