gina 0.0.9-p91b → 0.1.1-alpha.2

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

@@ -0,0 +1,129 @@
+var fs = require('fs');
+var console = lib.logger;
+/**
+ * List bundles for a given project
+ *
+ * e.g.
+ *  gina bundle:list [ @<project_name> ]
+ *  gina bundle:list --all
+ *
+ * */
+function List(opt, cmd) {
+    var self = {};
+
+    var init = function() {
+        self.projects = require(_(GINA_HOMEDIR + '/projects.json'));
+
+        if ( typeof(process.argv[3]) != 'undefined') {
+            if (process.argv[3] === '--all') {
+                listAll()
+            } else if ( !isValidName(process.argv[3]) ) {
+                console.error('[ '+process.argv[3]+' ] 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(self.name) == 'undefined' ) {
+            listAll()
+        } else if ( typeof(self.name) != 'undefined' && isDefined(self.name) ) {
+            listProjectOnly()
+        } 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 listAll = function() {
+        var projects = self.projects
+            , list = []
+            , p = ''
+            , path
+            , bundles
+            , b
+            , str = '';
+
+        for (p in projects) {
+            list.push(p)
+        }
+        list.sort();
+
+        p = 0;
+        for (; p<list.length; ++p) {
+            try {
+                path = projects[list[p]].path;
+                bundles = require( _(path +'/manifest.json')).bundles;
+
+                str += '------------------------------------\n\r';
+                if ( !fs.existsSync(projects[list[p]].path) ) {
+                    str += '?! '
+                }
+                str += list[p] + '\n\r';
+                str += '------------------------------------\n\r';
+                for (b in bundles) {
+                    if ( fs.existsSync(_(path + '/'+ bundles[b].src)) ) {
+                        str += '[ ok ] ' + b
+                    } else {
+                        str += '[ ?! ] ' + b
+                    }
+                    str += '\n\r'
+                }
+                str += '\n\r'
+            } catch (err) {
+                str += '------------------------------------\n\r';
+                if ( !fs.existsSync(projects[list[p]].path) ) {
+                    str += '?! '
+                }
+                str += list[p] + '\n\r';
+                str += '------------------------------------\n\r';
+            }
+
+        }
+
+        console.log(str)
+    }
+
+    var listProjectOnly = function () {
+        var path = self.projects[self.name].path
+            , bundles = require( _(path +'/manifest.json')).bundles
+            , b
+            , str = '';
+
+        for (b in bundles) {
+            if ( fs.existsSync(_(path + '/'+ bundles[b].src)) ) {
+                str += '[ ok ] ' + b
+            } else {
+                str += '[ ?! ] ' + b
+            }
+            str += '\n\r'
+        }
+
+        console.log(str)
+    };
+
+    init()
+};
+
+module.exports = List

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

@@ -0,0 +1,229 @@
+var fs          = require('fs');
+var readline    = require('readline');
+var rl          = readline.createInterface(process.stdin, process.stdout);
+
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+
+/**
+ * Remove existing bundle from a given project.
+ * NB.: If bundle exists, it won't be replaced. You'll only get warnings.
+ *
+ * TODO - Remove multiple bundles at once - ref. bundle/add
+ * */
+function Remove(opt, cmd) {
+
+    var self    = {}
+        , local = {
+            b : 0,
+            bundle : null,
+            force : false
+        }
+    ;
+
+    var init = function(opt) {
+
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+
+        // check CMD configuration
+        if ( !isCmdConfigured() ) return false;
+
+
+        if ( typeof(self.projects[self.projectName].path) == 'undefined' ) {
+            console.error('project path not defined in ~/.gina/projects.json for [ '+ self.projectName + ' ]');
+            process.exit(1)
+        }
+        
+        if (isDefined('project', self.projectName)) {
+            removeBundle(0)
+        } else {
+            //console.error('[ '+ self.projectName+' ] is not an existing project');
+            if ( self.bundles.length == 0) {
+                console.error('Missing argument <bundle_name>');
+            } else if  (!isDefined('project', self.projectName) ) {
+                console.error('[' + self.projectName +'] is not an existing project.');
+            } else {
+                console.error('Missing argument @<project_name>');
+            }
+
+            process.exit(1)
+        }
+
+        //var Proc = require( getPath('gina').lib + '/proc');
+
+        
+        
+    }
+
+    var removeBundle = function (b) {
+
+        if (b > self.bundles.length-1) { // exits when done
+            end()
+        }
+
+        local.b             = b;
+        local.bundle        = self.bundles[b];
+        local.envFileSaved  = false;
+        local.force         = ( typeof(self.params['force']) != 'undefined' ) ? self.params['force'] : false;
+
+
+        if (local.force) {
+            // remove without checking            
+            remove(local.bundle)
+        } else {
+            check()
+        }
+
+    }
+
+    var check = function() {
+
+
+        rl.setPrompt('['+ local.bundle +'@'+ self.projectName +'] Also remove bundle files ? (Y/n):');
+
+        rl.prompt();
+
+        rl
+            .on('line', function(line) {
+                switch( line.trim().toLowerCase() ) {
+                    case 'y':
+                    case 'yes':
+                        rl.clearLine();
+                        remove(local.bundle);
+
+                    break;
+                    case 'n':
+                    case 'no':
+                        rl.clearLine();
+                        // continue to next bundle
+                        ++local.b;
+                        removeBundle(local.b);
+                    break;
+
+                    default:
+                        console.log('Please, write "yes" or "no" to proceed.');
+                        rl.prompt();
+                        break;
+                }
+            })
+            .on('close', function() {
+                rl.clearLine();
+                console.log('Action cancelled !');
+                process.exit(0)
+            })
+    }
+    
+    var remove = function (bundle) {
+        
+        // reload assets context with changes
+        loadAssets();
+                
+        var hasFolder = true, folderPath = null, folder = null;
+        console.debug('Removing bundle: ', bundle);
+        try {
+            folderPath = _(self.projects[self.projectName].path + '/' + self.projectData.bundles[bundle].src, true);
+            folder = new _(folderPath);
+            
+            if ( !folder.isValidPath() ) {
+                console.warn('`'+ folder.toString() +'` is not a valid path')
+            } else {
+    
+                // removing mounting point: just in case
+                var coreEnv = getCoreEnv(bundle);
+                new _(coreEnv.mountPath +'/'+ bundle, true).rmSync();
+                
+                // removing folder
+                folder = folder.rmSync();
+                if (folder instanceof Error) {
+                    console.error(folder.stack);
+                    process.exit(1)
+                }
+            }
+        } catch(folderException) {
+            hasFolder = false;
+        }
+        
+        
+
+        // updating project env
+        if ( typeof(self.envData) != 'undefined' && typeof(self.envData[bundle]) != 'undefined' ) (
+            delete self.envData[bundle]
+        )
+
+        // updating project bundles
+        if ( typeof(self.projectData.bundles) != 'undefined' && typeof(self.projectData.bundles[bundle]) != 'undefined' ) (
+            delete self.projectData.bundles[bundle]
+        )
+
+        // removing ports
+        var ports               = JSON.clone(self.portsData)
+            , portsReverse      = JSON.clone(self.portsReverseData)
+            , re                = null
+        ;
+
+        for (let protocol in ports) {                
+            for (let scheme in ports[protocol]) {                    
+                for (let port in ports[protocol][scheme]) {
+                    re = new RegExp(bundle +"\@"+ self.projectName +"\/");
+                    if ( re.test(ports[protocol][scheme][port]) ) {
+                        delete ports[protocol][scheme][port];
+                    }
+                }
+            }
+        }
+        
+        for (let bundleAddress in portsReverse) {
+            re = new RegExp(bundle +"\@"+ self.projectName);
+            if ( re.test(bundleAddress) ) {
+                delete portsReverse[bundleAddress];
+            }
+        }
+
+        // now writing
+        lib.generator.createFileFromDataSync(ports, self.portsPath);
+        lib.generator.createFileFromDataSync(portsReverse, self.portsReversePath);
+        
+        // env
+        // var envData = JSON.clone(self.envData);
+        // if ( typeof(envData[bundle]) != 'undefined' ) {
+        //     delete envData[bundle];
+            lib.generator.createFileFromDataSync(
+                self.envData,
+                self.envPath
+            );
+        // }            
+        
+        // manifest
+        // var projectData = JSON.clone(self.projectData);
+        // if ( typeof(projectData.bundles) != 'undefined' && typeof(projectData.bundles[bundle]) != 'undefined' ) {
+        //     delete projectData.bundles[bundle];
+            // if (projectData.bundles.count() == 0) {
+            //     delete projectData.bundles
+            // }
+            lib.generator.createFileFromDataSync(
+                self.projectData,
+                self.projectPath
+            );
+        // }
+        
+
+        console.log('Bundle [ '+ bundle+'@'+self.projectName+' ] removed');
+                
+
+        ++local.b;
+        removeBundle(local.b);
+    }
+
+
+    var end = function() {
+
+        
+
+        process.exit(0)
+    };
+
+    init(opt)
+};
+
+module.exports = Remove

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

@@ -0,0 +1,4 @@
+/**
+ * Rename a given bundle
+ * ! config, source & target project must be identical
+ */

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

@@ -0,0 +1,235 @@
+var fs          = require('fs');
+const { runMain } = require('module');
+var exec        = require('child_process').exec;
+
+var CmdHelper   = require('./../helper');
+var console     = lib.logger;
+// var Shell       = lib.Shell;
+
+/**
+ * Restart a given bundle or Restart all running bundles at once
+ *
+ * e.g.
+ *  gina bundle:restart <bundle_name> @<project_name>
+ *  gina bundle:restart @<project_name>
+ *  gina bundle:restart --online
+ *
+ * */
+function Restart(opt, cmd) {
+
+    var self    = {};
+
+    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;
+
+        self.cmdStr = process.argv.splice(0, 2).join(' ');
+
+        self.inheritedArgv = [];
+        for (let i = 0, len = process.argv.length; i < len; i++) {
+            if ( /^\-\-/.test(process.argv[i]) ) {
+                self.inheritedArgv.push(process.argv[i])
+            }
+        }
+
+        // start all bundles
+        opt.onlineCount = 0;
+        opt.notStarted = [];
+        if (!self.name) {
+            restart(opt, cmd, 0);
+        } else {
+            restart(opt, cmd);
+        }
+    }
+
+    var restart = function(opt, cmd, bundleIndex) {
+
+        var isBulkRestart = (typeof(bundleIndex) != 'undefined') ? true : false;
+        var bundle = (isBulkRestart) ? self.bundles[bundleIndex] : self.name;
+
+        // console.debug('bundle -> ', bundle);
+        var env = ( typeof(self.bundlesByProject[self.projectName][bundle].def_env) != 'undefined') ? self.bundlesByProject[self.projectName][bundle].def_env : self.defaultEnv;
+        // console.debug('env -> ', env);
+        var protocol = self.bundlesByProject[self.projectName][bundle].def_protocol;
+        // console.debug('protocol -> ', protocol);
+        var scheme = self.bundlesByProject[self.projectName][bundle].def_scheme;
+        // console.debug('scheme -> ', scheme);
+        var bundlePort = self.portsReverseData[bundle + '@' + self.projectName][env][protocol][scheme];
+        // console.debug('port -> ', bundlePort);
+
+        var msg = null;
+        if (!isDefined('bundle', bundle)) {
+
+            msg = 'Bundle [ ' + bundle + ' ] is not registered inside `@' + self.projectName + '`';
+            console.error(msg);
+            opt.client.write(msg);
+            end(opt, cmd, isBulkRestart, bundleIndex, true)
+
+        } else {
+
+            isRealApp(bundle, function(err, appPath) {
+                if (err) {
+                    console.error(err.stack || err.message)
+                }
+
+
+                var error = null;
+                //console.debug(' OPTIONS => ', opt.debugPort, opt.debugBrkEnabled);
+                //console.info('running: gina bundle:restart '+ bundle + '@' + self.projectName);
+                msg = 'Restarting, please wait ...';
+                cmd = '$gina bundle:stop ' + bundle + ' @' + self.projectName + ' && $gina bundle:start ' + bundle + ' @' + self.projectName;
+                if (self.inheritedArgv != '') {
+                    cmd += ' '+ self.inheritedArgv;
+                }
+                if (opt.debugPort) {
+                    cmd += ' --inspect';
+                    if (opt.debugBrkEnabled) {
+                        cmd += '-brk'
+                    }
+                    cmd += '='+ opt.debugPort;
+                    msg = 'You should now start your debug session on port #'+opt.debugPort;
+                }
+                cmd = cmd.replace(/\$(gina)/g, self.cmdStr);
+
+                console.debug('Executing: '+cmd);
+
+                opt.client.write('\n\r'+msg +'\n');
+
+                // If it is stuck, the problem is not here ... cmd.start should be a good start
+                exec(cmd, function(err, stdout, stderr) {
+
+                    if (err) {
+                        error = err.toString();
+                        console.error(error);
+                        //opt.notStopped.push(bundle + '@' + self.projectName);
+                        return setTimeout(() => {
+                            end(opt, cmd, isBulkRestart, bundleIndex, true)
+                        }, 500);
+                    }
+
+                    // retrieve messages from the parent stdout
+                    if (stdout) {
+                        console.log(stdout.replace(/\n\rTrying to.*/gm, ''));
+                    }
+                    setTimeout(() => {
+                        //opt.client.write('  => bundle [ ' + bundle + '@' + self.projectName + ' ] restarted on port #'+ bundlePort+' :D\n');
+                        end(opt, cmd, isBulkRestart, bundleIndex)
+                    }, 500);
+                })
+            })//EO isRealApp
+        }
+    }
+
+    var end = function (opt, cmd, isBulkRestart, i, error) {
+        if (isBulkRestart) {
+            ++i;
+            if ( typeof(self.bundles[i]) != 'undefined' ) {
+                restart(opt, cmd, i)
+            } else {
+
+                if ( typeof(error) != 'undefined') {
+                    return process.exit(1);
+                }
+                if (!opt.client.destroyed)
+                    opt.client.emit('end');
+
+                process.exit(0);
+            }
+        } else {
+            if ( typeof(error) != 'undefined') {
+                return process.exit(1);
+            }
+
+            if (!opt.client.destroyed)
+                opt.client.emit('end');
+
+            process.exit(0);
+        }
+    }
+
+    var isRealApp = function(bundle, callback) {
+
+        var p               = null
+            , d             = null
+            , env           = self.projects[self.projectName]['def_env']
+            , isDev         = GINA_ENV_IS_DEV
+            , root          = self.projects[self.projectName].path
+            , bundleDir     = null
+            , bundlesPath   = null
+            , bundleInit    = null
+        ;
+
+        try {
+            //This is mostly for dev.
+            var pkg = require( _(root + '/manifest.json') ).bundles;
+
+            if ( typeof(pkg[bundle].version) == 'undefined' && typeof(pkg[bundle].tag) != 'undefined') {
+                pkg[bundle].version = pkg[bundle].tag
+            }
+            if (
+                pkg[bundle] != 'undefined' && pkg[bundle]['src'] != 'undefined' && isDev
+            ) {
+                var path = pkg[bundle].src;
+
+                p = _( root +'/'+ path );//path.replace('/' + bundle, '')
+                d = _( root +'/'+ path + '/index.js' );
+
+                bundleDir   = path.replace('/' + bundle, '');
+                setContext('bundle_dir', bundleDir);
+                bundlesPath =  _( root +'/'+ bundleDir );
+                bundleInit  = d;
+
+            } else {
+                //Others releases.
+                var path    = 'releases/'+ bundle +'/' + env +'/'+ pkg[bundle].version;
+                var version = pkg[bundle].version;
+                p = _( root +'/'+ path );//path.replace('/' + bundle, '')
+                d = _( root +'/'+ path + '/index.js' );
+
+                bundleDir   = path;
+                bundlesPath = _(root + '/'+ bundleDir);
+                bundleInit  = d;
+            }
+
+        } catch (err) {
+            // default bundlesPath.
+            // TODO - log warn ?
+            console.warn(err.stack||err.message);
+            bundleDir   = 'bundles';
+            bundlesPath = _(root +'/'+ bundleDir);
+            p = _(root +'/'+ bundleDir +'/'+ bundle);
+            d = _(root + '/'+ bundleDir +'/'+ bundle + '/index.js');
+            bundleInit = d;
+        }
+
+
+        //Checking root.
+        if ( new _(d, true).existsSync() ) {
+            //checking bundle directory.
+            fs.stat(p, function(err, stats) {
+
+                if (err) {
+                    callback(err)
+                } else {
+
+                    if (stats.isDirectory()) {
+                        callback(false, d)
+                    } else {
+                        callback(new Error('[ ' + d + ' ] is not a directory'))
+                    }
+                }
+            })
+        }
+        else {
+            console.debug('[ ' + d + ' ] does not exists');
+            callback(false)
+        }
+    }
+
+    init(opt, cmd)
+};
+
+module.exports = Restart

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

@@ -0,0 +1,2 @@
+// alias
+module.exports = require('./remove')