gina 0.7.0 → 0.7.1

package/framework/{v0.7.0 → v0.7.1}/helpers/context.js

@@ -9,7 +9,12 @@ var fs              = require('fs');
 var os              = require('os');
 const {execSync}    = require('child_process');
 var crypto          = require('crypto');
-//var merge   = require('./../lib/merge');
+// lib/merge is bound once, here. It is a plain-required leaf of lib/index.js (never
+// evicted by the dev-mode refresh, #B32-residual) with no dependency back on the
+// helpers, so this module-level binding is the same exports object that the former
+// per-call resolution inside setContext() and the global getConfig() returned — minus
+// a full module resolution on every call (measured 3 µs each, two per routed request).
+var merge   = require('./../lib/merge');
 //var console = require('./../lib/logger');
 
 /**
@@ -53,7 +58,6 @@ var _mintErrorRef = function(supplied) {
  */
 function ContextHelper(contexts) {
 
-    var merge   = require('./../lib/merge');
     var console = require('./../lib/logger');
 
     var self = {};
@@ -143,8 +147,6 @@ function ContextHelper(contexts) {
     }
 
     setContext = function(name, obj, force) {
-        // redefinition needed for none-dev env: cache issue
-        var merge = require('./../lib/merge');
 
         if (arguments.length > 1) {
             //console.log("Globla setter active ", name, obj);
@@ -401,6 +403,44 @@ function ContextHelper(contexts) {
         throw err
     }
 
+    /**
+     * callerFileSegments
+     *
+     * Path segments of the first stack frame outside `node_modules`, without its
+     * `.js` extension — how `getConfig(<falsy>, confName)` and `getLib(lib)` tell
+     * which bundle the calling file belongs to: `ctx.bundles` is matched against
+     * these segments, last first.
+     *
+     * #B695 — the resolvers used to read `__stack` inside the loop, one full stack
+     * capture per frame examined (up to nine), and when no frame outside
+     * `node_modules` existed they called `.replace` on `null`. Under an npm install
+     * every framework file sits under `node_modules`, so a call made from framework
+     * code threw. The resolver now captures the stack ONCE and passes it here, and
+     * a stack without such a frame yields `[]`: no bundle segment matches, and the
+     * resolver takes its ordinary no-match path.
+     *
+     * @inner
+     * @private
+     * @param {Array<object>} stack - The resolver's own `__stack` (V8 CallSite
+     *   objects), evaluated in the resolver so that index 0 is the resolver's frame
+     * @returns {Array<string>} The file's path segments, or `[]` when every
+     *   examined frame (indices 1 to 9) is under `node_modules` or missing
+     *
+     * @example
+     * // inside a resolver — `__stack` is evaluated there, so stack[0] is the resolver
+     * var a = callerFileSegments(__stack);
+     * // e.g. [ '', 'srv', 'shop', 'src', 'api', 'controllers', 'controller' ], or []
+     * */
+    var callerFileSegments = function(stack) {
+        for (let i = 1, len = 10; i < len; ++i) {
+            var stackFileName = ( stack && stack[i] ) ? stack[i].getFileName() : null;
+            if ( stackFileName && !/node_modules/.test(stackFileName) ) {
+                return stackFileName.replace('.js', '').split('/');
+            }
+        }
+        return [];
+    };
+
     /**
      * resolveBundlesConf
      *
@@ -429,12 +469,33 @@ function ContextHelper(contexts) {
     /**
      * getConfig
      *
-     * Get bundle JSON configuration
+     * Get bundle JSON configuration.
      *
+     * Three call shapes resolve the bundle differently:
+     * - `getConfig()` and `getConfig(confName)` — no bundle named: the running
+     *   bundle (`ctx.bundle`). No stack is read.
+     * - `getConfig(bundle, confName)` — the named bundle.
+     * - `getConfig(<falsy>, confName)` — the bundle whose files make the call: the
+     *   first stack frame outside `node_modules` is matched against the project's
+     *   bundles (one stack capture, #B695). When no frame qualifies, or none
+     *   matches, no bundle resolves and the call fails clean (emerg-log +
+     *   `undefined`).
+     *
+     * #B695 — until 0.7.1 the stack walk ran for every shape and threw under an
+     * npm install (every framework frame sits under `node_modules`), so a
+     * no-argument call from framework code failed there.
      *
      * @param {string} [ bundle ] - Bundle name
-     * @param {string} confName  - Config name (bundle/config/filename without extension)
+     * @param {string} [ confName ] - Config name (bundle/config/filename without extension)
+     * @returns {object|undefined} The config content named by `confName`, or the
+     *   whole `[bundle][env]` container (plus `bundle`, `env`, `scope`,
+     *   `projectName`, `bundles`) when `confName` is omitted; `undefined` when no
+     *   configuration can be resolved in the calling context
      *
+     * @example
+     * var conf    = getConfig();               // the running bundle's container
+     * var app     = getConfig('app');          // its config/app.json
+     * var routing = getConfig('api', 'routing');
      * */
     getConfig = function(bundle, confName) {
         // R2: test mock override — set via setContext('__mock__', { config: fn })
@@ -444,7 +505,6 @@ function ContextHelper(contexts) {
             return _mock.config(bundle, confName);
         }
 
-        var merge = require('./../lib/merge');
         var ctx             = null
             , ctxFilename   = getContext('argvFilename') // for workers ctx
             , confPath      = null
@@ -475,24 +535,26 @@ function ContextHelper(contexts) {
         if (arguments.length == 1 || !bundle) {
 
             confName = (arguments.length == 1) ? bundle : confName;
-            var file = null
-                , stackFileName = null;
-
-            for (let i = 1, len = 10; i < len; ++i) {
-                stackFileName = __stack[i].getFileName();
-                if (stackFileName && !/node_modules/.test(stackFileName)) {
-                    file = stackFileName;
-                    break;
-                }
-            }
-            var a = file.replace('.js', '').split('/')
-                , i = a.length - 1;
+            // #B695 — was: the caller-file walk ran here for every shape, reading
+            // `__stack` once per frame examined, and threw under an npm install:
+            // var file = null, stackFileName = null;
+            // for (let i = 1, len = 10; i < len; ++i) {
+            //     stackFileName = __stack[i].getFileName();
+            //     if (stackFileName && !/node_modules/.test(stackFileName)) { file = stackFileName; break; }
+            // }
+            // var a = file.replace('.js', '').split('/'), i = a.length - 1;
 
             if (bundle == confName) {
+                // No bundle named — `getConfig()` / `getConfig(confName)`: the running
+                // bundle. The walk's result was never used for this shape.
                 bundle = ctx.bundle
             } else {
 
                 if (ctx.bundles) {
+                    // Only a falsy bundle WITH a confName reads the caller's file:
+                    // one stack capture (#B695).
+                    var a = callerFileSegments(__stack)
+                        , i = a.length - 1;
                     for (; i >= 0; --i) {
                         index = ctx.bundles.indexOf(a[i]);
                         if (index > -1) {
@@ -614,25 +676,24 @@ function ContextHelper(contexts) {
             //);
              lib    = (arguments.length == 1) ? bundle : lib;
              bundle = null;
-             var file          = null
-                , stackFileName = null
-                //, file        = ( !/node_modules/.test(__stack[1].getFileName()) ) ?  __stack[1].getFileName() : __stack[2].getFileName()
-            ;
-            for (let i = 1, len = 10; i<len; ++i) {
-                stackFileName = __stack[i].getFileName();
-                if ( stackFileName && !/node_modules/.test(stackFileName) ) {
-                    file = stackFileName;
-                    break;
-                }
-            }
-            var a           = file.replace('.js', '').split('/')
-                , i         = a.length-1;
+            // #B695 — was: the same caller-file walk as getConfig's, run before the
+            // `bundle == lib` branch, reading `__stack` once per frame examined and
+            // throwing under an npm install:
+            // var file = null, stackFileName = null;
+            // for (let i = 1, len = 10; i<len; ++i) {
+            //     stackFileName = __stack[i].getFileName();
+            //     if ( stackFileName && !/node_modules/.test(stackFileName) ) { file = stackFileName; break; }
+            // }
+            // var a = file.replace('.js', '').split('/'), i = a.length-1;
 
             if (bundle == lib) {
                 bundle = ctx.bundle
             } else {
 
                 if (ctx.bundles) {
+                    // `getLib(lib)`: the bundle of the calling file — one stack capture (#B695).
+                    var a           = callerFileSegments(__stack)
+                        , i         = a.length-1;
                     for (; i >= 0; --i) {
                         index = ctx.bundles.indexOf(a[i]);
                         if ( index > -1 ) {

package/framework/{v0.7.0 → v0.7.1}/helpers/path.js

@@ -39,7 +39,13 @@ var ContextHelper = require('./context');
 
 function PathHelper() {
 
-    this.paths = [];
+    // No path registry is kept (#B703). helpers/index.js calls PathHelper() without `new`,
+    // so `this` here is the global object: the former `this.paths = []` was `global.paths`,
+    // into which every `_()` pushed each distinct normalized path for the process lifetime
+    // (two per distinct URL through the output cache's file paths) and which every `_()`
+    // and every toString() scanned with indexOf — memory and per-call CPU growing with the
+    // number of distinct paths ever seen. Nothing read it: each lookup returned the entry
+    // equal to the value it searched for.
     var _this = this;
 
     /**
@@ -91,7 +97,7 @@ function PathHelper() {
         }
         // Attention : _('/my/path/../folder/file.ext') will output -> /my/folder/file.ext
         path = Path.normalize(path);
-        var isConstructor = false, p = null;
+        var isConstructor = false;
         if (
             this instanceof _ // <- You could use arguments.callee instead of _ here,
             // except in in EcmaScript 5 strict mode.
@@ -108,24 +114,13 @@ function PathHelper() {
                 if (process.platform == "win32") {
                     //In case of mixed slashes.
                     this.value = path.replace(/\\/g, "/");// Make it unix like.
-
-                    p = this.value;
-
                     this.isWindowsStyle = true;
                     this.key = path;
-                    if (_this.paths.indexOf(path) < 0 ) {
-                        _this.paths.push(p)
-                    }
                 } else {
                     //console.debug("linux style");
                     //we don't want empty spaces
                     this.value = path.replace(/\\/g, "/");
-                    p = this.value;
-                    //console.debug("path ", p);
                     this.key = path;
-                    if (_this.paths.indexOf(path) < 0 ) {
-                        _this.paths.push(p)
-                    }
                 }
                 return this
 
@@ -137,18 +132,8 @@ function PathHelper() {
                         path = path.replace(/\//g, "\\");//Keep it or convert to Win32
                     else
                         path = path.replace(/\\/g, "/");// Make it unix like.
-
-
-                    if ( _this.paths.indexOf(path) < 0) {
-                        _this.paths.push(path)
-                    }
-
-
                 } else {
                     path = path.replace(/\\/g, "/");
-                    if (_this.paths.indexOf(path) < 0) {
-                        _this.paths.push(path)
-                    }
                 }
 
                 return path
@@ -163,20 +148,18 @@ function PathHelper() {
 
     /**
      * _.toString() Convert path object to string
-     * @returns {String} path
      *
-     * Usage:
-     * var myPathObj = new _("my/path/string");
+     * The unix-style value everywhere but win32, where the back-slash form is
+     * returned. Derived from the object's own value alone — no process-wide path
+     * registry is consulted (#B703).
      *
-     * Then
-     * myPathObj.toString()
+     * @returns {String} path
+     *
+     * @example
+     * var myPathObj = new _("/my/path/string");
+     * myPathObj.toString(); // '/my/path/string' ('\\my\\path\\string' on win32)
      * */
     _.prototype.toString = function() {
-        // var self = this;
-        // var path = self.value;
-        // var i = _this.paths.indexOf(path);
-        // return ( i > -1 ) ? _this.paths[i] : path
-
         return (process.platform != "win32") ? toUnixStyle(this) : toWin32Style(this)
     }
 
@@ -1800,25 +1783,60 @@ function PathHelper() {
         })
     }
 
+    /**
+     * Returns a PathObject's value in unix style.
+     *
+     * The constructor stores the value with forward slashes, so it is returned as
+     * is. A value holding back-slashes (only `cleanSlashes()` on win32, which joins
+     * with `Path.sep`, or code writing `.value` directly) is returned untouched, as
+     * before: on unix the retired path registry (#B703) never held a back-slash, so
+     * it never converted one.
+     *
+     * @inner
+     * @private
+     * @param {object} self - The PathObject
+     * @returns {string} `self.value`
+     */
     var toUnixStyle = function(self) {
-        var i = _this.paths.indexOf(self.value);
-        return ( i > -1 ) ? _this.paths[i].replace(/\\/g, "/") : self.value;
+        return self.value;
     }
+    /**
+     * Returns the path in unix style (forward slashes).
+     *
+     * @returns {string} The path
+     *
+     * @example
+     * new _('C:\\data\\folder\\file').toUnixStyle(); // 'C:/data/folder/file'
+     */
     _.prototype.toUnixStyle = function() {
-        // var self = this;
-        // var i = _this.paths.indexOf(self.value);
-        // return ( i > -1 ) ? _this.paths[i].replace(/\\/g, "/") : self.value;
         return toUnixStyle(this)
     }
 
+    /**
+     * Returns a PathObject's value in win32 style: every forward slash becomes a
+     * back-slash, on every call. The retired path registry (#B703) converted only a
+     * value it had recorded — every value as constructed — and returned one it had
+     * not recorded unconverted: a value `cleanSlashes()` had rewritten (a trailing
+     * separator stripped) came back with forward slashes.
+     *
+     * @inner
+     * @private
+     * @param {object} self - The PathObject
+     * @returns {string|*} The value with `/` replaced by `\`; a non-string value is
+     *                     returned as is
+     */
     var toWin32Style = function(self) {
-        var i = _this.paths.indexOf(self.value);
-        return ( i > -1 ) ? _this.paths[i].replace(/\//g, "\\") : self.value;
+        return ( typeof(self.value) == 'string' ) ? self.value.replace(/\//g, "\\") : self.value;
     }
+    /**
+     * Returns the path in win32 style (back-slashes).
+     *
+     * @returns {string} The path
+     *
+     * @example
+     * new _('/srv/app/public').toWin32Style(); // '\\srv\\app\\public'
+     */
     _.prototype.toWin32Style = function() {
-        // var self = this;
-        // var i = _this.paths.indexOf(self.value);
-        // return ( i > -1 ) ? _this.paths[i].replace(/\//g, "\\") : self.value;
         return toWin32Style(this)
     }
 

package/framework/{v0.7.0 → v0.7.1}/helpers/task.js

@@ -1,5 +1,6 @@
 var fs              = require('fs');
 var os              = require("os");
+var path            = require('path');
 var EventEmitter    = require('events').EventEmitter;
 var spawn           = require('child_process').spawn;
 
@@ -20,8 +21,13 @@ module.exports = function () {
      * resulting `callback is not a function` was caught by the close handler's
      * try/catch and only logged — the caller never heard back.
      *
+     * The child's stdout and stderr are captured in `out.log` / `err.log` inside a
+     * private per-run directory created under `opt.tmp` (the system tmp dir by
+     * default), read back on exit and removed with it; a failure while reading
+     * them back is delivered as the run's error (#B664).
+     *
      * @param {array|string} cmdline - Command and arguments (a string is split on spaces)
-     * @param {object} [opt] - `cwd` (the process chdirs to it), `tmp` (log-file dir), `verbose`
+     * @param {object} [opt] - `cwd` (the process chdirs to it), `tmp` (base of the private per-run log dir — see below), `verbose`
      * @param {function} [cb] - Positional completion callback `(err, output)`; `null`/`undefined` = use `.onComplete()`
      * @returns {EventEmitter} The run emitter — `.onData(cb)`, `.onComplete(cb)`, both chainable
      * @throws {TypeError} When `cb` is neither a function nor `null`/`undefined`
@@ -53,11 +59,16 @@ module.exports = function () {
         var tmp = opt.tmp || os.tmpdir() || process.cwd();
 
         if ( !fs.existsSync(tmp) ) {
-            fs.mkdirSync(tmp)
+            fs.mkdirSync(tmp, { recursive: true })
         }
 
-		var outFile = _(tmp + '/out.log');
-        var errFile = _(tmp + '/err.log');
+        // #B664 / #B702 — a PRIVATE per-run directory under `tmp` for the two log
+        // files (unpredictable name, mode 0700, removed with them at close): the
+        // fixed `<tmp>/out.log` + `err.log` pair was shared by every concurrent
+        // run, and in a shared /tmp another local user could create it first.
+        var runDir  = fs.mkdtempSync(path.join(tmp, 'gina-run-'));
+        var outFile = _(runDir + '/out.log');
+        var errFile = _(runDir + '/err.log');
         var out = fs.openSync(outFile, 'a');
         var err = fs.openSync(errFile, 'a');
 
@@ -128,49 +139,50 @@ module.exports = function () {
 
         cmd.on('close', function (code) {
 
+            // #B664 — read both logs, then ALWAYS release the descriptors and the
+            // private directory, and ALWAYS deliver the completion: a throw in here
+            // used to be caught below and only logged, so the caller waited forever.
+            var error = false, data;
             try {
-                var error = ( fs.existsSync(errFile) ) ? fs.readFileSync(errFile).toString() : false;
-                //closing
-                fs.closeSync(err);
-                if ( fs.existsSync(errFile) ) fs.unlinkSync(errFile);
+                error = ( fs.existsSync(errFile) ) ? fs.readFileSync(errFile).toString() : false;
+                data  = ( fs.existsSync(outFile) ) ? fs.readFileSync(outFile).toString() : undefined;
+            } catch (readErr) {
+                error = readErr.stack || String(readErr);
+            } finally {
+                try { fs.closeSync(err) } catch (closeErr) { /* already closed */ }
+                try { fs.closeSync(out) } catch (closeErr) { /* already closed */ }
+                try {
+                    fs.rmSync(runDir, { recursive: true, force: true });
+                } catch (rmErr) {
+                    console.error(rmErr.stack)
+                }
+            }
 
+            try {
                 if (error) {
                     cmd.emit('stderr', Buffer.from(error))
                 }
-
-
-                var data = ( fs.existsSync(outFile) ) ? fs.readFileSync(outFile).toString() : undefined;
-                //closing
-                fs.closeSync(out);
-                if (fs.existsSync(outFile) ) fs.unlinkSync(outFile);
-
                 if ( data ) {
                     cmd.emit('stdout', Buffer.from(data))
                 }
+            } catch (listenerErr) {
+                // a throwing `onData` listener is logged, and the completion below still runs
+                console.error(listenerErr.stack)
+            }
 
+            if (error == '') {
+                error = false
+            }
 
-                if (error == '') {
-                    error = false
+            try {
+                if (code != 0 && error) {
+                    console.debug('task::run encountered an error: ' + error);
                 }
-
-                if (code == 0 ) {
-                    if (cb) {
-                        cb(error, result);
-                        return;
-                    }
-                    e.emit('run#complete', error, result)
-                } else {
-                    if (error) {
-                        console.debug('task::run encountered an error: ' + error);
-                    }
-                    if (cb) {
-                        cb(error, result);
-                        return;
-                    }
-                    e.emit('run#complete', error, result)
+                if (cb) {
+                    cb(error, result);
+                    return;
                 }
-
-
+                e.emit('run#complete', error, result)
             } catch (err) {
                 console.error(err.stack)
             }