gina 0.1.1-alpha.21 → 0.1.1-alpha.211

package/framework/{v0.1.1-alpha.21 → v0.1.1-alpha.211}/lib/cmd/bundle/start.js

@@ -1,21 +1,39 @@
-const { debug } = require('console');
-var fs          = require('fs');
-const { spawn } = require('child_process');
+const fs            = require('fs');
+const { EventEmitter }  = require('events');
+const { spawn }     = require('child_process');
+const { execSync }  = require('child_process');
+const util = require('util');
+const promisify = require('util').promisify;
 
 var CmdHelper   = require('./../helper');
-var console     = lib.logger;
+// `lib` is previously defiened as this file is required by anoth
+// for user output
+var terminal    = lib.logger;
+// for logs/tail output thru the parent
+var console     = null;
+
 /**
  * Start a given bundle or start all bundles at once
  *
+ *
  * e.g.
  *  gina bundle:start <bundle_name> @<project_name>
  *
  * // start all bundles within the project
  *  gina bundle:start @<project_name>
+ * or
+ *  gina bundle:start @<project_name> --max-old-space-size=4096 --inspect=5858
+ *
+ *
+ * If you want to inspect/debug here, you first need to restart gina with `--inspect-gina`
+ *   gina start --inspect-gina
+ * then
+ *   gina bundle:start <bundle_name> @<project_name> --max-old-space-size=4096 --inspect=5858
  *
  * */
 function Start(opt, cmd) {
     var self    = {};
+    // terminal.register(console, opt.client.write);
 
 
     var init = function(opt, cmd) {
@@ -38,7 +56,156 @@ function Start(opt, cmd) {
         }
     }
 
+    var checkArchAgainstNodeModules = function(opt, cb) {
+
+        var currentArch         = GINA_ARCH
+            , currentPlatform   = GINA_PLATFORM
+            , projectObj        = self.projects[ self.projectName ]
+            , packagePathObj    = new _(projectObj.path +'/package.json', true)
+            , packagePath       = packagePathObj.toString()
+        ;
+
+        if ( !packagePathObj.existsSync() ) {
+            terminal.warn('[checkArchAgainstNodeModules] File`'+packagePath +'` not found');
+            return cb(false);
+        }
+
+        var gnaPath    =  _(projectObj.path +'/.gna', true);
+        var gnaPathObj  =  new _(gnaPath, true);
+        if ( ! gnaPathObj.existsSync() ) {
+            gnaPathObj.mkdirSync()
+        }
+
+        var isNodeModulesReinstallNeeded = false;
+        var nodeModulesPathObj = new _(projectObj.path +'/node_modules', true);
+
+
+        var projectArchFileObj = new _(gnaPath +'/arch', true);
+        var projectArchFile = projectArchFileObj.toString();
+        var projectPlatformFileObj = new _(gnaPath +'/platform', true);
+        var projectPlatformFile = projectPlatformFileObj.toString();
+        var nodeModulesContentArr = ( nodeModulesPathObj.existsSync() ) ? fs.readdirSync(nodeModulesPathObj.toString()) : [];
+        var newNodeModulesContentArr = [], n = 0;
+        for (let f in nodeModulesContentArr) {
+            if (/^\./.test(nodeModulesContentArr[f]) ) {
+               continue
+            }
+            newNodeModulesContentArr[n] = nodeModulesContentArr[f];
+        }
+        nodeModulesContentArr = newNodeModulesContentArr.slice();
+        newNodeModulesContentArr = null;
+
+        var pack = requireJSON(packagePath);
+
+        if (
+            !projectArchFileObj.existsSync()
+            ||
+            !projectPlatformFileObj.existsSync()
+            ||
+            projectArchFileObj.existsSync() && fs.readFileSync(projectArchFile).toString() != currentArch
+            ||
+            projectPlatformFileObj.existsSync() && fs.readFileSync(projectPlatformFile).toString() != currentPlatform
+            ||
+            !nodeModulesPathObj.existsSync()
+            ||
+            nodeModulesPathObj.existsSync()
+            && !nodeModulesContentArr.length
+            ||
+            nodeModulesPathObj.existsSync()
+            && nodeModulesContentArr.length == 1
+            && nodeModulesContentArr[0] == 'gina'
+            && typeof(pack.dependencies) != 'object'
+            && pack.dependencies.count() > 0
+        ) {
+            isNodeModulesReinstallNeeded = true;
+        }
+
+        opt.client.write('\nArch: '+ currentArch);
+        // opt.client.write('\nprojectArchFile: '+ projectArchFile);
+        opt.client.write('\nPlatform: '+ currentPlatform);
+        opt.client.write('\nisNodeModulesReinstallNeeded: '+ isNodeModulesReinstallNeeded);
+
+        // TODO - Do we want this for production ?
+        if (isNodeModulesReinstallNeeded) {
+            // remove node_modules
+            if ( nodeModulesPathObj.existsSync() ) {
+                nodeModulesPathObj.rmSync();
+            }
+        }
+
+        // reinstall node_modules if needed
+        if ( isNodeModulesReinstallNeeded ) {
+            var initialDir = process.cwd();
+            var npmCmd = ( isWin32() ) ? 'npm.cmd install' : 'npm install';
+            process.chdir( _(projectObj.path, true) );
+
+            opt.client.write('\nRe-installing node_modules to match arch & platform');
+            opt.client.write('\nrunning: `'+ npmCmd +'` from '+ process.cwd() );
+            opt.client.write('\nrunning using TMPDIR: '+  _(getTmpDir(), true) );
+            var oldConfigGlobal = process.env.npm_config_global;
+            process.env.npm_config_global = false;
+            var result = null; resultError = false;
+            try {
+                result = execSync(npmCmd).toString();
+                var ginaBin = execSync('which gina').toString().trim();
+                execSync(ginaBin +' framework:link @'+ self.projectName);
+            } catch (err) {
+                resultError = err;
+            }
+
+            process.chdir(initialDir);
+            process.env.npm_config_global = oldConfigGlobal;
+
+            if (resultError) {
+                opt.msg = resultError.stack || resultError.message || resultError;
+                return cb(resultError);
+                // return end(opt, cmd)
+            }
+
+            opt.client.write('\n'+result);
+
+            opt.client.write('\r\nPlease wait...');
+
+            // handle node_modules installed
+            var e = new EventEmitter();
+            var trigger = self.projectName +'_'+ self.name +'#node-modules-installed';
+            var nIntervId = null;
+
+            e.once(trigger, function onBundleStarted(done) {
+                clearInterval(nIntervId);
+                nIntervId = null;
+
+                opt.client.write('\nOk, I am ready :)');
+                lib.generator.createFileFromDataSync(GINA_ARCH, projectArchFile);
+                lib.generator.createFileFromDataSync(GINA_PLATFORM, projectPlatformFile);
+                setTimeout(() => {
+                    done(false)
+                }, 1000);
+
+            });
+
+            var nodeModulesPath = nodeModulesPathObj.toString();
+            var found = false;
+            nIntervId = setInterval(() => {
+                // Check for modules availability
+                found = new _(nodeModulesPath +'/gina', true).existsSync();
+
+                if ( found ) {
+                    clearInterval(nIntervId);
+                    e.emit(trigger, cb)
+                }
+            }, 200);
+
+            return;
+        }
+
+        cb(false);
+    }
+
+
+
     var start = function(opt, cmd, bundleIndex) {
+
         // getting the debug port
         var debugStr = null;
         if ( /\-\-(inspect|debug)/.test(opt.argv.join(',')) ) {
@@ -58,48 +225,62 @@ function Start(opt, cmd) {
         var isBulkStart = (typeof(bundleIndex) != 'undefined') ? true : false;
 
         var bundle = (isBulkStart) ? self.bundles[bundleIndex] : self.name;
-        // console.debug('bundle -> ', bundle);
+        // terminal.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);
+        // terminal.debug('env -> ', env);
         var protocol = self.bundlesByProject[self.projectName][bundle].def_protocol;
-        // console.debug('protocol -> ', protocol);
+        // terminal.debug('protocol -> ', protocol);
         var scheme = self.bundlesByProject[self.projectName][bundle].def_scheme;
-        // console.debug('scheme -> ', scheme);
+        // terminal.debug('scheme -> ', scheme);
         var bundlePort = self.portsReverseData[bundle + '@' + self.projectName][env][protocol][scheme];
-        // console.debug('port -> ', bundlePort);
+        // terminal.debug('port -> ', bundlePort);
 
         var msg = null;
         if ( !isBulkStart && !isDefined('bundle', bundle) ) {
             msg = 'Bundle [ '+ bundle +' ] is not registered inside `@'+ self.projectName +'`';
-            console.error(msg);
-            opt.client.write(msg);
-            // CMD exit
-            opt.client.emit('end');
-        } else {
+            terminal.error(msg);
+            // opt.client.write(msg);
+            // // CMD exit
+            // opt.client.emit('end');
+
+            opt.msg = msg;
+            return end(opt, cmd, isBulkStart, bundleIndex, true)
+        }
 
-            var isStarting  = false
-                , params    = null
-                , index     = null
-                , i         = null
-                , len       = null
-            ;
+        var isStarting  = false
+            , params    = null
+            , index     = null
+            , i         = null
+            , len       = null
+        ;
+
+        isRealApp(bundle, function(err, appPath){
+
+            if (err) {
+                terminal.error(err.stack||err.message)
+            } else {
+                if (isStarting)
+                    return;
+
+
+                var proceedToStart = function(nodeModulesErr) {
+                    if (nodeModulesErr) {
+                        opt.msg = nodeModulesErr.stack;
+                        return end(opt, cmd, isBulkStart, bundleIndex, true)
+                    }
 
-            isRealApp(bundle, function(err, appPath){
-                if (err) {
-                    console.error(err.stack||err.message)
-                } else {
-                    if (isStarting)
-                        return;
 
                     msg = 'Trying to start bundle [ ' + bundle + '@' + self.projectName + ' ]';
                     if (opt.debugPort) {
                         msg += ' (debug port: '+ opt.debugPort +')'
                     }
                     // To gina log
-                    console.info(msg);
+                    terminal.info(msg);
                     // to the terminal stdout
                     opt.client.write('\n\r'+msg);
 
+
+
                     process.list = (process.list == undefined) ? [] : process.list;
                     setContext('processList', process.list);
                     setContext('ginaProcess', process.pid);
@@ -165,18 +346,18 @@ function Start(opt, cmd) {
 
                     var checkCaseCount = 2
                         // The 2 flags we need to free the child.stdout if we do not want the command to wait for a timeout
-                        // NB.: you can place flag by using console.notice
-                        , checkCaseRe = new RegExp('('+bundle + '@' + self.projectName + ' mounted !|Bundle started !)', 'i')
+                        // NB.: you can place flag by using terminal.notice
+                        , checkCaseRe = new RegExp('('+bundle + '@' + self.projectName + ' mounted !|Bundle started !)', 'g')
                         , url = null
                         , debuggerOn = null
                     ;
                     var port = '', errorFound = false;
                     child.stdout.on('data', function(data) {
-                        // console.log(data);
+                        // terminal.log(data);
 
                         // handle errors
                         if ( /EADDRINUSE.*port/i.test(data) && !errorFound ) {
-                            console.log(data);
+                            terminal.log(data);
                             // kill the bundle starting process first
                             child.kill('SIGKILL');
 
@@ -200,7 +381,7 @@ function Start(opt, cmd) {
 
                         // catch fatal errors to exit
                         if ( /(\[|\[\s+)emerg/.test(data) ) {
-                            console.log(data);
+                            terminal.log(data);
 
                             // kill the bundle starting process first
                             child.kill('SIGKILL');
@@ -216,9 +397,13 @@ function Start(opt, cmd) {
                         }
 
                         // Expecting 2 flags (checkCaseCount) to free the child stdout !!
-                        if ( checkCaseRe.test(data) ) {
-                            --checkCaseCount;
+                        // terminal.debug('BO case count '+ checkCaseCount);
+                        var _matched =  data.match(checkCaseRe);
+                        if ( _matched ) {
+                            // terminal.warn('case count: '+ checkCaseCount +'\nMatched: '+ _matched.length + '\n'+ checkCaseRe +'\n-> '+ data + '<-\n');
+                            checkCaseCount -= _matched.length;
                         }
+                        // terminal.debug('EO case count: '+ checkCaseCount + ' -> '+ data);
 
                         // cache bundle state info given by the server while starting
                         if ( !debuggerOn && new RegExp('Debugger listening on','gmi').test(data)) {
@@ -238,6 +423,12 @@ function Start(opt, cmd) {
                             if (!debuggerOn) {
                                 debuggerOn = ''
                             }
+
+                            // resume logging
+                            process.emit('gina#bundle-logging', GINA_MQ_PORT, GINA_HOST_V4, bundle + '@' + self.projectName);
+                            terminal.debug('Sent:  gina#bundle-logging');
+
+
                             opt.client.write('  [ ' + bundle + '@' + self.projectName + ' ] started V(-.o)V'+ url + debuggerOn);
 
 
@@ -251,41 +442,57 @@ function Start(opt, cmd) {
 
                     //when an exception is thrown, it is sent to the client
                     child.stderr.setEncoding('utf8');
-                    var error = null;
+                    var error = null, onException = false;
                     child.stderr.on('data', function(err) {
                         error = err.toString();
 
+                        if (/Waiting for the debugger to disconnect.../.test(error) ) { // dual debug --inspect-gina && --inspect
+                            onException = true;
+                        }
+
                         if (/Debugger listening|Debugger attached|Warning|address already in use/i.test(error)) {
-                            console.warn(error);
 
                             if (!opt.client.destroyed) {
                                 opt.client.write(error);
                             }
-
-                        } else {
-                            console.error(error);
                         }
+
+                        terminal.error(error);
                     });
 
                     child.on('exit', function(code, signal) {
                         // handles only signals that cannot be cannot be caught or ignored
                         // ref.: `framework/<version>/lib/proc.js`
+                        if (onException) { // dual debug --inspect-gina && --inspect
+                            return end(opt, cmd, isBulkStart, bundleIndex);
+                        }
                         if (/(SIGKILL|SIGSTOP)/i.test(signal)) {
-                            console.emerg('[' + this.pid + '] exiting with signal: ', signal);
+                            terminal.emerg('[' + this.pid + '] `'+ self.name +'@'+ self.projectName +'` exiting with signal: ', signal);
                             cmd.proc.dismiss(this.pid, signal);
+                            return;
                         }
+
                     });
 
+                } // EO proceedToStart
 
-                }
+                checkArchAgainstNodeModules(opt, proceedToStart);
+
+            } // EO Else
+
+        });//EO isRealApp
+
+    } //EO start
 
-            });//EO isRealApp
 
-        }
-    }
 
 
-    var end = function (opt, cmd, isBulkStart, i) {
+    var end = function (opt, cmd, isBulkStart, i, error) {
+        if ( typeof(opt.msg) != 'undefined' ) {
+            opt.client.write('\n\r'+ opt.msg);
+        }
+
+        isBulkStart = ( typeof(isBulkStart) == 'undefined' ) ? false : isBulkStart;
         if (isBulkStart) {
             ++i;
             if ( typeof(self.bundles[i]) != 'undefined' ) {
@@ -294,12 +501,23 @@ function Start(opt, cmd) {
                 opt.client.write('\n\r[ Online ] '+ opt.onlineCount +'/'+ self.bundles.length);
                 var notStartedMsg = '\nCould not start: \n  - '+ opt.notStarted.join('\n');
                 opt.client.write(notStartedMsg);
+
+                // TODO - 2023-01-08 Remove this if not needed
+                // if ( typeof(error) != 'undefined' && !new RegExp('gina-v').test(process.title) ) { // will also stop the framework !!!
+                //     process.exit(1);
+                // }
+
                 if (!opt.client.destroyed)
                     opt.client.emit('end');
             }
             return;
         }
 
+        // TODO - 2023-01-08 Remove this if not needed
+        // if ( typeof(error) != 'undefined' && !new RegExp('gina-v').test(process.title) ) { // will also stop the framework !!!
+        //     process.exit(1);
+        // }
+
         if (!opt.client.destroyed)
             opt.client.emit('end');
         // Force exit in case process is stuck
@@ -359,7 +577,7 @@ function Start(opt, cmd) {
         } catch (err) {
             // default bundlesPath.
             // TODO - log warn ?
-            console.warn(err.stack||err.message);
+            terminal.warn(err.stack||err.message);
             bundleDir   = 'bundles';
             bundlesPath = _(root +'/'+ bundleDir);
             p = _(root +'/'+ bundleDir +'/'+ bundle);