gina 0.1.1-alpha.8 → 0.1.1-alpha.82

package/script/pre_install.js

@@ -18,6 +18,219 @@ var lib     = null;
 var isWin32 = function() {
     return (process.platform === 'win32') ? true : false;
 };
+var existsSync = function(path) {
+    if ( typeof(fs.accessSync) != 'undefined' ) {
+        try {
+            fs.accessSync(path, fs.constants.F_OK);
+            return true;
+        } catch (err) {
+            return false;
+        }
+    } else { // support for old version of nodejs
+        return fs.existsSync(path);
+    }
+}
+
+var isWritableSync = function(path) {
+    var canWrite = false;
+    if ( typeof(fs.accessSync) != 'undefined' ) {
+        try {
+            fs.accessSync(path, fs.constants.W_OK);
+            canWrite = true;
+        } catch (err) {
+            canWrite = false;
+        }
+    } else { // support for old version of nodejs
+
+        try {
+            canWrite = (fs.statSync(path).mode & (fs.constants.S_IRUSR | fs.constants.S_IRGRP | fs.constants.S_IROTH));
+        } catch (err) {
+            canWrite = false
+        }
+    }
+
+    return canWrite
+};
+
+/**
+ * Get run\lock path
+ * @returns {string} rundir
+ * */
+ var getRunDir = function(prefix) {
+    if ( !prefix || typeof(prefix) == 'undefined' || prefix == '' ) {
+        prefix = '/usr/local'
+    }
+    // Trying to retrieve original value if already defined
+    // Means `/usr/local/var/lock` or `/usr/local/var/run` by default.
+    var runDir = (isWin32()) ? getUserHome() + '\\.gina\\run' : prefix+'/var/lock';
+
+    if ( !isWin32() && new RegExp('^'+ prefix).test(runDir) && !isWritableSync(prefix) ) {
+        runDir = getUserHome() +'/.gina/run';
+        if ( !existsSync(runDir) ) {
+            fs.mkdirSync(runDir)
+        }
+
+        return runDir
+    }
+
+    if ( existsSync(runDir) ) {
+        if ( !isWritableSync(runDir) ) {
+            throw new Error('location `'+ runDir +'` found but not writable !' )
+        }
+
+        runDir += ( isWin32() ) ? '' : '/gina'
+        if ( !existsSync(runDir) ) {
+            fs.mkdirSync(runDir)
+        }
+
+        return runDir;
+    }
+
+    try {
+        //by default.
+        runDir = prefix+'/var';
+        if ( !existsSync(runDir) ) {
+            fs.mkdirSync(runDir)
+        }
+        runDir += '/run';
+        if ( !existsSync(runDir) ) {
+            fs.mkdirSync(runDir)
+        }
+    } catch (err) {
+        throw new Error('location error: `'+ runDir+'`\n'+ err.stack);
+    }
+
+    runDir += ( isWin32() ) ? '\\gina' : '/gina'
+    if ( !existsSync(runDir) ) {
+        fs.mkdirSync(runDir)
+    }
+
+    return runDir;
+};
+
+var getTmpDir = function(prefix) {
+    if ( !prefix || typeof(prefix) == 'undefined' || prefix == '' ) {
+        prefix = '/usr/local'
+    }
+    // support for node 0.10.x & 0.11.x
+    var tmp = (os.tmpdir) ? os.tmpdir : function() {
+        var tmpDir = null;
+        if ( isWin32() ) {
+            tmpDir = process.env.TEMP ||
+                process.env.TMP ||
+                (process.env.SystemRoot || process.env.windir) + '\\Temp'
+            ;
+        } else {
+            tmpDir = process.env.TMPDIR ||
+                process.env.TMP ||
+                process.env.TEMP ||
+                prefix+'/var/tmp'
+            ;
+
+            if ( new RegExp('^'+ prefix).test(tmpDir) && !isWritableSync(prefix) ) {
+                tmpDir = getUserHome() +'/.gina/tmp';
+                if ( !existsSync(tmpDir) ) {
+                    fs.mkdirSync(tmpDir)
+                }
+            }
+
+            if ( new RegExp('^'+ prefix +'/var').test(tmpDir) && !existsSync(prefix+'/var') ) {
+                fs.mkdirSync(prefix+'/var');
+            }
+        }
+
+        if ( !existsSync(tmpDir) ) {
+            fs.mkdirSync(tmpDir);
+        }
+
+        return tmpDir
+    };
+
+    return tmp()
+};
+
+/**
+ * Get log path - %SystemRoot%\system32\winevt\logs or /
+ *
+ * @returns {string} logPath
+ * */
+var getLogDir = function(prefix) {
+    if ( !prefix || typeof(prefix) == 'undefined' || prefix == '' ) {
+        prefix = '/usr/local'
+    }
+    // Trying to retrieve original value if already defined
+    var logDir = null;
+
+    if ( isWin32() ) {
+        logDir = process.env.LOG ||
+            process.env.LOGS ||
+            (process.env.SystemRoot || process.env.windir) + '\\System32\\Winevt\\Logs'
+        ;
+
+        if ( !logDir || logDir == '' ) {
+            throw new Error('Log directory not defined or not found !');
+        }
+
+        if ( !isWritableSync(logDir) ) {
+            throw new Error('Log directory found but not writable: need permissions for `'+ logDir +'`');
+        }
+
+        if ( !/gina$/.test(logDir) ) {
+            logDir += '\\gina'
+        }
+    } else {
+        logDir = process.env.LOGDIR ||
+            process.env.LOG ||
+            process.env.LOGS ||
+            prefix+'/var/log'
+        ;
+
+        if ( new RegExp('^'+ prefix).test(logDir) && !isWritableSync(prefix) ) {
+            logDir = getUserHome() +'/.gina/log';
+            if ( !existsSync(logDir) ) {
+                fs.mkdirSync(logDir)
+            }
+
+            return logDir
+        }
+
+        if ( new RegExp('^'+ prefix +'/var').test(logDir) && !existsSync(prefix+'/var') ) {
+            fs.mkdirSync(prefix+'/var');
+        }
+
+        if ( !existsSync(logDir) ) {
+            fs.mkdirSync(logDir);
+        }
+
+        if ( !/gina$/.test(logDir) ) {
+            logDir += '/gina'
+        }
+    }
+
+    if ( !existsSync(logDir) ) {
+        fs.mkdirSync(logDir)
+    }
+
+    return logDir;
+};
+
+var getUserHome = function() {
+    var home = os.homedir ? os.homedir : function() {
+        var homeDir = process.env[(isWin32()) ? 'USERPROFILE' : 'HOME'];
+
+        if ( !homeDir || homeDir == '' ) {
+            throw new Error('Home directory not defined or not found !');
+        }
+
+        if ( !isWritableSync(homeDir) ) {
+            throw new Error('Home directory found but not writable: need permissions for `'+ homeDir +'`');
+        }
+
+        return homeDir;
+    };
+
+    return home()
+};
 
 var helpers = null;
 
@@ -27,33 +240,62 @@ var helpers = null;
  * if you need to test, go to gina main folder
  * $ node --inspect-brk=5858 ./script/pre_install.js -g
  *
+ * NB.: At this stage, Gina is not yet installed and no lib or helper cannot be used here
+ *      excepted if Gina has been previously installed
+ *
  * @constructor
  * */
 function PreInstall() {
-    var self = {}, _this = this;
+    var self = {};
 
     var init = function() {
 
         self.isGlobalInstall = false;
-        self.prefix = execSync('npm config get prefix');
+        self.isResetNeeded = process.env.npm_config_reset || false;
         self.isGinaInstall = false;
+        self.prefix = process.env.npm_config_prefix || execSync('npm config get prefix').toString().replace(/\n/g, '');
+        self.isCustomPrefix = false;
 
         var args = process.argv, i = 0, len = args.length;
         for (; i < len; ++i) {
-            if (args[i] == '-g' ) {
+            if ( /^(\-g|\-\-global)$/.test(args[i]) ) {
                 self.isGlobalInstall = true;
-                break;
+                continue;
+            }
+
+            if ( /^\-\-reset$/.test(args[i]) ) {
+                self.isResetNeeded = true;
+                continue;
+            }
+
+            if ( /^\-\-prefix\=/.test(args[i] ) ) {
+                self.isCustomPrefix = true;
+                self.prefix = args[i].split(/\=/)[1];
+                continue;
             }
         }
 
-        if ( !self.isGlobalInstall ) { //global install
-            self.root = process.cwd(); // project path
-            self.tmpDir = os.tmpdir(); // default tmp path
-            console.error('local installation is not supported for this version at the moment.');
-            console.info('please use `npm install -g gina`');
-            process.exit(1);
+        process.env.npm_config_prefix = self.prefix;
+        console.debug('process.env.npm_config_prefix => '+ process.env.npm_config_prefix);
+        if (
+            // process.env.npm_config_prefix
+            // &&
+            self.prefix != process.env.npm_config_prefix
+        ) {
+            // self.prefix = process.env.npm_config_prefix.toString();
+            self.isCustomPrefix = true;
         }
 
+        if ( !self.isGlobalInstall ) { // none global install
+            self.prefix = process.env.npm_config_prefix = process.cwd();
+            // self.root = process.cwd(); // project path
+            // self.tmpDir = os.tmpdir(); // default tmp path
+            // console.error('local installation is not supported for this version at the moment.');
+            // console.info('please use `npm install -g gina`\n    or\nif you are trying to link gina to your project, use `npm link gina` if Gina has already been installed');
+            // process.exit(1);
+        }
+        console.debug('self.prefix => '+ self.prefix);
+
 
         begin(0);
         // TODO check old framework version to be archived
@@ -87,45 +329,86 @@ function PreInstall() {
         }
     }
 
+
+
     self.checkRequirements = async function(done) {
         // TODO - handle windows case
-        if ( /true/i.test(self.isWin32) ) {
+        if ( /^true$/i.test(isWin32()) ) {
             return done( new Error('Windows in not yet fully supported. Thank you for your patience'));
         }
 
+        var ginaHome = getUserHome() + ( isWin32() ? '\\.gina' : '/.gina' );
+        if ( self.isResetNeeded && existsSync(ginaHome) ) {
+            console.debug('`.gina` reset requested ...');
+            fs.rmSync(ginaHome, { recursive: true, force: true });
+        }
+
         // Let's temporarily install `colors` into `GINA_DIR` it will be removed by the `post_install.js` script
         var initialDir = process.cwd();
         var frameworkPath   = __dirname +'/..';
         if ( !fs.existsSync(frameworkPath +'/node_modules/colors') ) {
             process.chdir(frameworkPath);
+            var oldConfigGlobal = process.env.npm_config_global;
+            process.env.npm_config_global=false;
             var cmd = ( isWin32() ) ? 'npm.cmd install colors@1.4.0' : 'npm install colors@1.4.0';
             execSync(cmd);
             process.chdir(initialDir);
+            process.env.npm_config_global=oldConfigGlobal;
         }
 
+
         if ( !fs.existsSync(frameworkPath +'/node_modules/gina') ) {
             return done();
         }
-        self.isGinaInstall = true;
 
-        helpers = require(frameworkPath+ '/utils/helpers');
+        self.isWin32 = isWin32();
 
-        lib = require('./lib');
-        console = lib.logger;
-
-        self.isWin32 = isWin32();//getEnvVar('GINA_IS_WIN32');
-        self.path = getEnvVar('GINA_FRAMEWORK');
-        self.gina = getEnvVar('GINA_DIR');
-        self.root = self.gina; // by default
 
         console.debug('framework path: ' + self.gina);
         console.debug('framework version path: ' + self.path);
         console.debug('cwd path: ' + self.root );
-        console.debug('this is a global install ...');
+        console.debug('Is this a global install: '+ self.isGlobalInstall);
 
         done();
     }
 
+    self.checkRequiredFolders = function(done) {
+
+        var ginaHomeDir = getUserHome() + ((isWin32()) ? '\\.gina': '/.gina');
+        if (!existsSync(ginaHomeDir) ) {
+            fs.mkdirSync(ginaHomeDir)
+        }
+
+        // check for `/usr/local/tmp` or `/tmp`
+        var tmpDir = getTmpDir(self.prefix);
+        console.info('`tmp` dir -> '+ tmpDir);
+        if ( !existsSync(tmpDir) ) {
+            fs.mkdirSync(tmpDir)
+        }
+
+
+        // check for `/usr/local/run`
+        var runDir = getRunDir(self.prefix);
+        console.info('`run` dir -> '+ runDir);
+
+        // check for `/usr/local/log`
+        var logDir = getLogDir(self.prefix);
+        console.info('`log` dir -> '+ logDir);
+
+        // var settingsBackupPath = tmpDir +  ((isWin32()) ? '\\': '/') + 'gina-install-settings.json';
+        // console.info('tmp folder backup -> '+ settingsBackupPath);
+        // var data =  JSON.stringify({
+        //     prefix: self.prefix,
+        //     rundir: runDir,
+        //     logdir: logDir,
+        //     tmpdir: tmpDir
+        // }, null, 4);
+        // fs.writeFileSync(settingsBackupPath, data);
+        // fs.chmodSync(settingsBackupPath, 0755);
+
+        done()
+    }
+
 
     /**
      * Setup global installation path
@@ -199,20 +482,30 @@ function PreInstall() {
 
     self.checkIfGinaIsAlreadyInstalled = async function(done) {
 
-        console.debug('Checking if Gina is already installed');
+        console.debug('Checking if Gina is already installed: '+ self.isGinaInstall);
         if (!self.isGinaInstall) {
             return done();
         }
 
+
         // Backup current version
 
         // check for ~/.gina
-        var ginaHomeDir = _(getUserHome() + '/.gina', true);
+        var ginaHomeDir = getUserHome() + ((isWin32()) ? '\\.gina': '/.gina');
         // if not found -> skip because it means that gina might not be installed or configured yet
-        if ( !new _(ginaHomeDir).existsSync() ) {
+        if (!existsSync(ginaHomeDir) ) {
             return done();
         }
 
+        var frameworkPath   = __dirname +'/..';
+        helpers = require(frameworkPath+ '/utils/helpers');
+        lib = require('./lib');
+
+        console = lib.logger;
+        self.path = getEnvVar('GINA_FRAMEWORK');
+        self.gina = getEnvVar('GINA_DIR');
+        self.root = self.gina; // by default
+
         // check if framework version folder is found
         var versionsFolders = null, frameworkPath = null;
         try {
@@ -277,37 +570,6 @@ function PreInstall() {
             }
         }
         // It is not required to update `~/.gina/main.json` &&  `~/.gina/{shortVersion}/settings.json`
-
-        self.checkRequiredFolders = function(done) {
-
-            // check for `/usr/local/tmp`
-            var tmpDir = getTmpDir()
-            console.info('`tmp` dir -> '+ tmpDir);
-            var tmpDirObj = new _(tmpDir, true);
-            if ( !tmpDirObj.existsSync() ) {
-                tmpDirObj.mkdirSync()
-            }
-
-            // check for `/usr/local/run`
-            var runDir = getRunDir();
-            console.info('`run` dir -> '+ runDir);
-            var runDirObj = new _(runDir, true);
-            if ( !runDirObj.existsSync() ) {
-                runDirObj.mkdirSync()
-            }
-
-            // check for `/usr/local/log`
-            var logDir = getLogDir();
-            console.info('`log` dir -> '+ logDir);
-            var logDirObj = new _(logDir, true);
-            if ( !logDirObj.existsSync() ) {
-                logDirObj.mkdirSync()
-            }
-
-            done()
-        }
-
-
         done()
     }
 

package/script/prepare_version.js

@@ -296,107 +296,111 @@ function PrepareVersion() {
         done();
     }
 
-    self.pushChangesToGit = function(done) {
 
-        var cmd = null;
-        var version = self.selectedVersion.replace(/^[a-z]+/ig, '');
+    // self.pushChangesToGit = function(done) {
+
+    //     var cmd = null;
+    //     var version = self.selectedVersion.replace(/^[a-z]+/ig, '');
+
+    //     // getting current branch
+    //     // git rev-parse --abbrev-ref HEAD
+    //     // => 010
+    //     var currentBranch = null;
+    //     try {
+    //         currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+    //                         .toString()
+    //                         .replace(/(\n|\r|\t)/g, '');
+    //     } catch (err) {
+    //         // nothing to do
+    //         return done( new Error('[GIT] No branch selected') )
+    //     }
 
-        // getting current branch
-        // git rev-parse --abbrev-ref HEAD
-        // => 010
-        var currentBranch = null;
-        try {
-            currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
-                            .toString()
-                            .replace(/(\n|\r|\t)/g, '');
-        } catch (err) {
-            // nothing to do
-            return done( new Error('[GIT] No branch selected') )
-        }
 
+    //     // create new branch if needed
+    //     // e.g: 0.1.0-alpha.1 -> 010-alpha1
+    //     var targetedBranch = version.replace(/\./g, '');
+    //     self.targetedBranch = targetedBranch;
 
-        // create new branch if needed
-        // e.g: 0.1.0-alpha.1 -> 010-alpha1
-        var targetedBranch = version.replace(/\./g, '');
-        self.targetedBranch = targetedBranch;
+    //     console.debug('[GIT] Current branch: '+ currentBranch);
+    //     console.debug('[GIT] Targeted branch: '+ targetedBranch);
 
-        console.debug('[GIT] Current branch: '+ currentBranch);
-        console.debug('[GIT] Targeted branch: '+ targetedBranch);
 
+    //     // check if targeted branch exists
+    //     // git rev-parse --verify 011
+    //     var branchExists = null;
+    //     try {
+    //         branchExists = execSync("git rev-parse --verify "+ targetedBranch)
+    //                         .toString()
+    //                         .replace(/(\n|\r|\t)/g, '');
+    //     } catch (err) {
+    //         // nothing to do
+    //     }
 
-        // check if targeted branch exists
-        // git rev-parse --verify 011
-        var branchExists = null;
-        try {
-            branchExists = execSync("git rev-parse --verify "+ targetedBranch)
-                            .toString()
-                            .replace(/(\n|\r|\t)/g, '');
-        } catch (err) {
-            // nothing to do
-        }
+    //     if (!branchExists) {
+    //         console.debug('No existing branch found, creating a new one !');
+    //         try {
+    //             execSync("git checkout -b "+ targetedBranch);
+    //             // pushing to new branch
+    //             console.debug('setting up remote branch `'+ targetedBranch +'` to git ...');
+    //             execSync("git push --set-upstream origin "+ targetedBranch);
+    //         } catch (err) {
+    //             console.error(err.stack||err.message||err);
+    //             return done(err);
+    //         }
+    //     }
+    //     // use existing to push updates
+    //     else {
+
+    //         if (currentBranch != targetedBranch) {
+    //             console.debug('Switching from branch `'+ currentBranch +'` to branch `'+ targetedBranch +'`');
+    //             // git checkout 010
+    //             try {
+    //                 cmd = execSync("git checkout "+ targetedBranch);
+    //             } catch (err) {
+    //                 console.error(err.stack||err.message||err);
+    //                 return done(err);
+    //             }
+    //         } else {
+    //             console.debug('Reusing branch `'+ targetedBranch +'`');
+    //         }
+    //     }
 
-        if (!branchExists) {
-            console.debug('No existing branch found, creating a new one !');
-            try {
-                execSync("git checkout -b "+ targetedBranch);
-                // pushing to new branch
-                console.debug('setting up remote branch `'+ targetedBranch +'` to git ...');
-                execSync("git push --set-upstream origin "+ targetedBranch);
-            } catch (err) {
-                console.error(err.stack||err.message||err);
-                return done(err);
-            }
-        }
-        // use existing to push updates
-        else {
-
-            if (currentBranch != targetedBranch) {
-                console.debug('Switching from branch `'+ currentBranch +'` to branch `'+ targetedBranch +'`');
-                // git checkout 010
-                try {
-                    cmd = execSync("git checkout "+ targetedBranch);
-                } catch (err) {
-                    console.error(err.stack||err.message||err);
-                    return done(err);
-                }
-            } else {
-                console.debug('Reusing branch `'+ targetedBranch +'`');
-            }
-        }
 
+    //     // git add --all
+    //     try {
+    //         cmd = execSync("git add --all ");
+    //     } catch (err) {
+    //         //console.debug('`git add --all`failed ');
+    //         console.error(err.stack||err.message||err);
+    //         return done(err);
+    //     }
+    //     // git commit -m'Packaging version v'+ version
+    //     try {
+    //         var msg = (!branchExists) ? 'New version' : 'Prerelease update - '+ new Date().format("isoDateTime");
+    //         cmd = execSync("git commit -am'"+ msg +"'");
+    //     } catch (err) {
+    //         if (!/Your branch is up to date/i.test( err.output.toString() )) {
+    //             console.error(err.stack||err.message||err);
+    //             return done(err);
+    //         }
+    //     }
+
+    //     console.debug('Pushing changes made on branch `'+ targetedBranch +'` to git `origin/'+ targetedBranch +'`');
+    //     // git push origin 010
+    //     try {
+    //         cmd = execSync("git push origin "+ targetedBranch );
+    //     } catch (err) {
+    //         if (!/Everything up-to-date/i.test( err.output.toString() )) {
+    //             console.error(err.stack||err.message||err);
+    //             return done(err);
+    //         }
+    //     }
+
+    //     done()
+    // }
 
-        // git add --all
-        try {
-            cmd = execSync("git add --all ");
-        } catch (err) {
-            //console.debug('`git add --all`failed ');
-            console.error(err.stack||err.message||err);
-            return done(err);
-        }
-        // git commit -m'Packaging version v'+ version
-        try {
-            var msg = (!branchExists) ? 'New version' : 'Prerelease update - '+ new Date().format("isoDateTime");
-            cmd = execSync("git commit -am'"+ msg +"'");
-        } catch (err) {
-            if (!/Your branch is up to date/i.test( err.output.toString() )) {
-                console.error(err.stack||err.message||err);
-                return done(err);
-            }
-        }
 
-        console.debug('Pushing changes made on branch `'+ targetedBranch +'` to git `origin/'+ targetedBranch +'`');
-        // git push origin 010
-        try {
-            cmd = execSync("git push origin "+ targetedBranch );
-        } catch (err) {
-            if (!/Everything up-to-date/i.test( err.output.toString() )) {
-                console.error(err.stack||err.message||err);
-                return done(err);
-            }
-        }
 
-        done()
-    }
 
     // self.tagVersionIfNeeded = function(done) {
     //     // check if script is on Dry Run !!!