cob-cli 2.53.0-beta-1 → 2.53.0-beta-3

package/bin/handleAutoComplete.js

@@ -1,12 +1,13 @@
 const path = require('path');
+const fs = require('fs');
 
 /* Autocomplete Component*/
 var omelette = require('omelette');
 const commandStructure = {
-    'init' : [], 
-    'customize' : [], 
-    'test' : [], 
-    'deploy' : [], 
+    'init' : [],
+    'customize' : [],
+    'test' : [],
+    'deploy' : [],
     'updateFromServer' : [],
     'upgradeRepo' : []
 }
@@ -19,9 +20,23 @@ if (~process.argv.indexOf('--setup')) {
         // we exit cleanly so that postinstall completes successfuly
         process.exit(0)
     }
+    if (isAutocompleteAlreadyInstalled()) {
+        console.log("Autocomplete already set up, skipping.")
+        process.exit(0)
+    }
     console.log("Setting up...")
     completion.setupShellInitFile()
 }
+
+function isAutocompleteAlreadyInstalled() {
+    try {
+        const initFile = completion.getDefaultShellInitFile()
+        if (!initFile || !fs.existsSync(initFile)) return false
+        return fs.readFileSync(initFile, 'utf8').includes('# begin cob-cli completion')
+    } catch (e) {
+        return false
+    }
+}
 // remove from system profiles
 if (~process.argv.indexOf('--cleanup')) {
     if (process.platform === 'win32') {

package/lib/commands/cleanup.js

@@ -11,6 +11,7 @@ const { SERVER_COB_CLI_DIRECTORY } = require("../task_lists/common_helpers");
 const { restoreServerFilesToLastDeployed } = require("../task_lists/test_otherFilesContiousReload");
 const { loadOperationState, clearOperationState } = require("../task_lists/common_operationState");
 const { checkRepoVersion } = require("../commands/upgradeRepo");
+const { getSshArgs } = require("../task_lists/common_helpers");
 
 const LOCAL_TEST_LOCK_FILE = ".test.in.execution";
 const SERVER_TEST_LOCK_FILE = SERVER_COB_CLI_DIRECTORY + "test.in.execution";
@@ -20,6 +21,10 @@ async function cleanup(args) {
         checkRepoVersion()
 
         const savedState = loadOperationState();
+        if (!savedState && !args.environment) {
+            console.log("No saved state and no explicit environment, aborting".bold);
+            return;
+        }
         if (savedState) {
             if (!args.environment) args.environment = savedState.environment;
             if (!args.servername)  args.servername  = savedState.servername;
@@ -50,11 +55,16 @@ async function cleanup(args) {
                 task: async () => {
                     let changedFiles = [];
                     try {
-                        const result = await execa('ssh', [cmdEnv.server, "cat " + SERVER_TEST_LOCK_FILE]);
+                        const result = await execa('ssh', [...getSshArgs(cmdEnv.server), "cat " + SERVER_TEST_LOCK_FILE]);
                         changedFiles = result.stdout.split("\n")
                             .map(l => l.split(" ")[0].trim())
                             .filter(f => f);
-                    } catch { /* no test.in.execution on server = nothing to restore */ }
+                    } catch (error) {
+                        if (error.exitCode === 255) {
+                            throw new Error(`SSH connection to '${cmdEnv.server}' failed: ${error.shortMessage}`);
+                        }
+                        /* no test.in.execution on server = nothing to restore */
+                    }
 
                     if (changedFiles.length === 0) return;
 
@@ -77,7 +87,7 @@ async function cleanup(args) {
             {
                 title: "Remove server test lock file".bold,
                 skip: () => args.localOnly ? "Skipping server cleanup (--localOnly)" : false,
-                task: () => execa('ssh', [cmdEnv.server, "rm -f " + SERVER_TEST_LOCK_FILE])
+                task: () => execa('ssh', [...getSshArgs(cmdEnv.server), "rm -f " + SERVER_TEST_LOCK_FILE])
                     .catch(() => {}) // non-critical if server unreachable
             },
         ], {

package/lib/commands/deploy.js

@@ -7,46 +7,45 @@ const { checkRepoVersion } = require("../commands/upgradeRepo");
 const { saveOperationState, clearOperationState, checkNoInterruptedRun } = require("../task_lists/common_operationState");
 
 async function deploy(args) {
-    let stateSaved = false
-    try {
-        checkRepoVersion()
-        const cmdEnv = await getCurrentCommandEnviroment(args)
-        await checkNoInterruptedRun()
-        saveOperationState(cmdEnv.name, cmdEnv.servername)
-        stateSaved = true
-        if(args.resync) args.force = true;
+    checkRepoVersion()
+    const cmdEnv = await getCurrentCommandEnviroment(args)
+    await checkNoInterruptedRun()
+    saveOperationState(cmdEnv.name, cmdEnv.servername)
+    if(args.resync) args.force = true;
 
-        console.log(`Checking conditions to deploy ${cmdEnv.branchStr} to ${cmdEnv.serverStr}...` );
+    console.log(`Checking conditions to deploy ${cmdEnv.branchStr} to ${cmdEnv.serverStr}...` );
 
+    try {
         await validateDeployConditions(cmdEnv,args).run()
+    } catch (err) {
+        // we should clear the operation state
+        clearOperationState();
+        throw err
+    }
 
-        await cmdEnv.applyCurrentCommandEnvironmentChanges()
-        let changes = [];
-        try {
-            changes = await confirmExecutionOfChanges(cmdEnv)
-        } catch (err) {
-            await cmdEnv.unApplyCurrentCommandEnvironmentChanges()
-            if (stateSaved) clearOperationState()
-            throw err
-        }
+    await cmdEnv.applyCurrentCommandEnvironmentChanges()
+    let changes = [];
+    try {
+        changes = await confirmExecutionOfChanges(cmdEnv)
+    } catch (err) {
+        await cmdEnv.unApplyCurrentCommandEnvironmentChanges()
+        clearOperationState()
+        throw err
+    }
 
-        if(changes.length == 0) {
-            if(!args.force) {
-                await cmdEnv.unApplyCurrentCommandEnvironmentChanges()
-                if (stateSaved) clearOperationState()
-                throw new Error("Canceled:".yellow + " nothing todo\n")
-            }
-            console.log(" Just updating deploy information.")
+    if(changes.length == 0) {
+        if(!args.force) {
+            await cmdEnv.unApplyCurrentCommandEnvironmentChanges()
+            clearOperationState()
+            console.log("\nCanceled!".yellow + " nothing todo\n")
+            return
         }
+        console.log(" Just updating deploy information.")
+    }
 
-        await executeTasks(cmdEnv, args).run();
-
-        if (stateSaved) clearOperationState()
-        console.log("\nDone!".green, "\nEnjoy!")
+    await executeTasks(cmdEnv, args).run();
 
-    } catch(err) {
-        if (stateSaved) clearOperationState()
-        console.error("\n",err.message);
-    }
+    clearOperationState()
+    console.log("\nDone!".green, "\nEnjoy!")
 }
-module.exports = deploy;
+module.exports = deploy;

package/lib/commands/test.js

@@ -13,6 +13,7 @@ async function test (args) {
     let cmdEnv
     let spawned
     let stateSaved = false
+    let envChangesApplied = false
 
     let rejectOnSignal;
     const signalPromise = new Promise((_, reject) => { rejectOnSignal = reject; });
@@ -31,9 +32,11 @@ async function test (args) {
         if(!args.localOnly) {
             await validateTestingConditions(cmdEnv, args)
             await cmdEnv.applyCurrentCommandEnvironmentChanges()
+            envChangesApplied = true
             restoreChanges = await otherFilesContiousReload(cmdEnv)
         } else {
             await cmdEnv.applyCurrentCommandEnvironmentChanges()
+            envChangesApplied = true
         }
         spawned = await customUIsContinuosReload(cmdEnv, args.dashboard)
 
@@ -52,8 +55,8 @@ async function test (args) {
         process.off('SIGTERM', handleSignal);
         process.off('SIGHUP', handleSignal);
         try { process.stdin.setRawMode(false); } catch {}
-        cmdEnv && await cmdEnv.unApplyCurrentCommandEnvironmentChanges() // Repõe as configurações
         restoreChanges && await restoreChanges()
+        envChangesApplied && cmdEnv && await cmdEnv.unApplyCurrentCommandEnvironmentChanges() // Repõe as configurações
         if (stateSaved) clearOperationState()
         spawned && await spawned.stop();
         // Dá tempo aos subprocessos para morrer (acho que já não é preciso)

package/lib/task_lists/common_enviromentHandler.js

@@ -5,6 +5,7 @@ const git = require('simple-git');
 const fs = require('fs-extra');
 const { getCurrentBranch } = require("./common_releaseManager");
 const { SERVER_COB_CLI_DIRECTORY } = require("./common_helpers")
+const { getSshArgs } = require("./common_helpers")
 
 const SERVER_LAST_ENV_FILE = SERVER_COB_CLI_DIRECTORY + "lastDeployEnv";
 
@@ -66,7 +67,7 @@ exports.getCurrentCommandEnviroment = getCurrentCommandEnviroment;
 
 /* ************************************ */
 async function _applySpecific(environmentName) {
-    const envSpecificFiles = await fg(['**/*.ENV__'+ environmentName +'__.*'], { onlyFiles: false, dot: true });    
+    const envSpecificFiles = await fg(['**/*.ENV__'+ environmentName +'__.*'], { onlyFiles: false, dot: true });
 
     for( let envSpecificFile of envSpecificFiles ) {
         let prodFile   = envSpecificFile.replace(/\.ENV__.*__/,"")
@@ -120,6 +121,8 @@ function _getDefaultServerForEnvironment(environmentName) {
 
 /* ************************************ */
 function _getServerSSHFQDN(servername) {
+    // return IPs as-is
+    if (servername.includes(".")) return servername;
     return servername + ".cultofbits.pt";
 }
 
@@ -131,16 +134,19 @@ function _getServerHTTPsFQDN(servername) {
 /* ************************************ */
 async function _getLastEnvironmentDeployed(server) {
     try {
-        let result = await execa('ssh', [server, "cat " + SERVER_LAST_ENV_FILE ]);
+        let result = await execa('ssh', [...getSshArgs(server), "cat " + SERVER_LAST_ENV_FILE ]);
         return result.stdout;
     } catch (error) {
+        if (error.exitCode === 255) {
+            throw new Error(`SSH connection to '${server}' failed: ${error.shortMessage}`);
+        }
         return "prod"
     }
 }
 
 /* ************************************ */
 async function _setLastEnvironmentDeployed(server, environmentName) {
-    await execa('ssh', [server, "echo '" + environmentName + "' > " + SERVER_LAST_ENV_FILE ]);
+    await execa('ssh', [...getSshArgs(server), "echo '" + environmentName + "' > " + SERVER_LAST_ENV_FILE ]);
 }
 
 /* ************************************ */

package/lib/task_lists/common_helpers.js

@@ -5,6 +5,38 @@ const fs = require("fs/promises");
 
 const SERVER_COB_CLI_DIRECTORY = "/opt/cob-cli/";
 
+/* ************************************ */
+function getSshArgs(server) {
+    const args = [
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "PreferredAuthentications=publickey",
+        "-o", "BatchMode=yes",
+    ];
+
+    if (process.env.COB_SSH_PORT)     args.push("-p", process.env.COB_SSH_PORT);
+    if (process.env.COB_SSH_IDENTITY) args.push("-i", process.env.COB_SSH_IDENTITY);
+
+    const target = process.env.COB_SSH_USER ? `${process.env.COB_SSH_USER}@${server}` : server;
+    args.push(target);
+
+    return args;
+}
+
+/* ************************************ */
+function getServerAddress(server) {
+    return process.env.COB_SSH_USER ? `${process.env.COB_SSH_USER}@${server}` : server;
+}
+
+/* ************************************ */
+function getRsyncSsh() {
+    let cmd = "ssh -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=30 -o StrictHostKeyChecking=no";
+
+    if (process.env.COB_SSH_IDENTITY) cmd += ` -i '${process.env.COB_SSH_IDENTITY}'`;
+    if (process.env.COB_SSH_PORT)     cmd += ` -p ${process.env.COB_SSH_PORT}`;
+
+    return cmd;
+}
+
 /* **************************************************************************************** */
 async function checkWorkingCopyCleanliness(testNotDetached=true) {
     const git = require('simple-git');
@@ -37,11 +69,8 @@ async function checkWorkingCopyCleanliness(testNotDetached=true) {
 function checkConnectivity(server) {
     const execa = require('execa');
     return execa('ssh', [
-        "-o", "StrictHostKeyChecking=no",
-        "-o", "PreferredAuthentications=publickey",
-        "-o", "BatchMode=yes",
         "-o", "ConnectTimeout=15",
-        server,
+        ...getSshArgs(server),
         "test -w /etc/recordm/services/com.cultofbits.web.integration.properties && exit || exit 1"
     ])
 }
@@ -109,6 +138,9 @@ async function readYamlFile(filename) {
 /* ************************************ */
 module.exports = {
     SERVER_COB_CLI_DIRECTORY : SERVER_COB_CLI_DIRECTORY,
+    getSshArgs: getSshArgs,
+    getServerAddress: getServerAddress,
+    getRsyncSsh: getRsyncSsh,
     checkConnectivity: checkConnectivity,
     checkWorkingCopyCleanliness: checkWorkingCopyCleanliness,
     getKeypress: getKeypress,

package/lib/task_lists/common_releaseManager.js

@@ -1,10 +1,9 @@
 const execa = require('execa');
-const fs = require('fs-extra');
 const git = require('simple-git');
 
 const SERVER_CHANGELOG = "/opt/cob-cli/DEPLOYLOG.md";
 const LAST_SHA_FILE = "lastDeploySha"
-const { SERVER_COB_CLI_DIRECTORY } = require("./common_helpers");
+const { SERVER_COB_CLI_DIRECTORY, getSshArgs } = require("./common_helpers");
 const SERVER_LAST_SHA_FILE = SERVER_COB_CLI_DIRECTORY + LAST_SHA_FILE;
 
 /* ************************************ */
@@ -44,18 +43,18 @@ async function registerRelease(cmdEnv) {
     const dateTimeStr = date.toISOString().slice(0,16).replace(/T/," ")
     const deploySignature = cmdEnv.servername + "_" + dateStr
     const newDeployText = `${dateTimeStr} ${user} [${currentSha}/${cmdEnv.currentBranch}]`
-    await execa('ssh', [cmdEnv.server, "echo $'" + newDeployText + "\n" + diffs.replace(/'/g,"\\'") + "' >> " + SERVER_CHANGELOG])
+    await execa('ssh', [...getSshArgs(cmdEnv.server), "echo $'" + newDeployText + "\n" + diffs.replace(/'/g,"\\'") + "' >> " + SERVER_CHANGELOG])
 
     if (diffs) {
         // Add deploy tags to repo
-        git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
+        await git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
         try {
             await git().silent(true).tag([deploySignature, "-d"])
         } catch {}
 
         await git().addAnnotatedTag(deploySignature, newDeployText )
         await git().push(["-f", "origin", deploySignature])
-        git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
+        await git().fetch(["--tags","-f"]) // Apenas para ter certeza que temos todas as tags
     }
     _setLastDeployedSha(cmdEnv.server, currentSha);
 }
@@ -65,9 +64,12 @@ exports.registerRelease = registerRelease;
 async function getLastDeployedSha(server) {
     let result
     try {
-        result = await execa('ssh', [server, "cat " + SERVER_LAST_SHA_FILE ]);
+        result = await execa('ssh', [...getSshArgs(server), "cat " + SERVER_LAST_SHA_FILE ]);
     } catch (error) {
-        await execa('ssh', [server, "mkdir -p " + SERVER_COB_CLI_DIRECTORY ]);
+        if (error.exitCode === 255) {
+            throw new Error(`SSH connection to '${server}' failed: ${error.shortMessage}`);
+        }
+        await execa('ssh', [...getSshArgs(server), "mkdir -p " + SERVER_COB_CLI_DIRECTORY ]);
         return null
     }
     return result.stdout;
@@ -76,7 +78,7 @@ exports.getLastDeployedSha = getLastDeployedSha;
 
 /* ************************************ */
 function _setLastDeployedSha(server, lastSha) {
-    execa('ssh', [server, "echo '" + lastSha + "' > " + SERVER_LAST_SHA_FILE ]);
+    execa('ssh', [...getSshArgs(server), "echo '" + lastSha + "' > " + SERVER_LAST_SHA_FILE ]);
 }
 
 /* ************************************ */

package/lib/task_lists/common_syncFiles.js

@@ -2,6 +2,7 @@ const execa = require('execa');
 const path = require('path');
 const fs = require('fs-extra');
 const { getKeypress } = require("../task_lists/common_helpers");
+const { getRsyncSsh, getServerAddress } = require("./common_helpers");
 
 /* ************************************ */
 const COB_PRODUCTS = ["recordm", "integrationm", "recordm-importer", "reportm", "userm", "confm", "others", "authm", "public"];
@@ -32,7 +33,6 @@ async function _syncFiles(executionType, cmdEnv, from, to, extraOptions = [], ar
         return new Promise(async (resolve, reject) => {
             let fromPath = resolveCobPath(cmdEnv.server, from, product);
             let toPath = resolveCobPath(cmdEnv.server, to, product);
-            if (toPath.startsWith('.') && !fs.existsSync(toPath)) fs.mkdirSync(toPath)
             let productExtraOptions = extraOptions.map( option => option.replace(/=.*\|/,"="))
             productExtraOptions = productExtraOptions.filter( option => option.indexOf("|") < 0 )
 
@@ -65,7 +65,7 @@ async function _syncFiles(executionType, cmdEnv, from, to, extraOptions = [], ar
                 }
                 await execa('rsync', rsyncArgs, {
                     shell: true,
-                    env: { "RSYNC_RSH": "ssh -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=30" }
+                    env: { "RSYNC_RSH": getRsyncSsh() }
                 })
                     .then((value) => {
                         if (args.verbose > 3)
@@ -170,7 +170,7 @@ function resolveCobPath(server, type, product) {
             return "./" + product + "/";
 
         case "serverInitial":
-            return server + ":/opt/" + product + "/etc.default/";
+            return getServerAddress(server) + ":/opt/" + product + "/etc.default/";
 
         case "serverLive":
             switch (product) {
@@ -178,9 +178,9 @@ function resolveCobPath(server, type, product) {
                     return server + ":/usr/share/cob/"
                 case "recordm-importer":
                 case "others":
-                    return server + ':' + "/opt/" + product + "/";
+                    return getServerAddress(server) + ':' + "/opt/" + product + "/";
                 default:
-                    return server + ':' + "/etc/" + product + "/";
+                    return getServerAddress(server) + ':' + "/etc/" + product + "/";
             }
 
         case "staging":

package/lib/task_lists/test_otherFilesContiousReload.js

@@ -7,6 +7,7 @@ const { SERVER_COB_CLI_DIRECTORY } = require("./common_helpers");
 const { confirmExecutionOfChanges, resolveCobPath } = require("./common_syncFiles");
 const { syncFile } = require("./test_syncFile");
 const { getLastDeployedSha } = require("./common_releaseManager");
+const { getSshArgs } = require("./common_helpers");
 
 const IN_PROGRESS_TEST_FILE = "test.in.execution"
 const SERVER_IN_PROGRESS_TEST_FILE = SERVER_COB_CLI_DIRECTORY + IN_PROGRESS_TEST_FILE
@@ -18,7 +19,7 @@ async function otherFilesContiousReload(cmdEnv) {
     let changedFiles = new Set()
 
     let currentTestsFilesList = []
-    await execa('ssh', [cmdEnv.server, "cat " + SERVER_IN_PROGRESS_TEST_FILE])
+    await execa('ssh', [...getSshArgs(cmdEnv.server), "cat " + SERVER_IN_PROGRESS_TEST_FILE])
     .then( value => currentTestsFilesList = value.stdout.split("\n").map(l => l.substring(0,l.indexOf(" "))) )
     .catch( () => { } ) /* grep returns error if no match and execa throws an excepcions when return is error */
     
@@ -56,7 +57,7 @@ async function otherFilesContiousReload(cmdEnv) {
         let productDir = resolveCobPath(cmdEnv.server, "serverLive", product).split(":")[1];
         let productScopeFilePath = changedFile.substring(changedFile.indexOf("/") + 1); // remove o directorio inicial do producto
 
-        let isRemoteFile = () => execa('ssh', [cmdEnv.server, "[[ -f " + productDir + productScopeFilePath + " ]] && echo 'file' || echo '' " ])
+        let isRemoteFile = () => execa('ssh', [...getSshArgs(cmdEnv.server), "[[ -f " + productDir + productScopeFilePath + " ]] && echo 'file' || echo '' " ])
             .then( r => {
                 return r.stdout == "file"
             }).catch( () => {
@@ -126,7 +127,7 @@ async function restoreServerFilesToLastDeployed(cmdEnv, changedFiles) {
 
     await cmdEnv.unApplyLastEnvironmentDeployedToServerChanges();
 
-    await execa('ssh', [cmdEnv.server, "find " + SERVER_IN_PROGRESS_TEST_FILE + " -size 0 -delete"])
+    await execa('ssh', [...getSshArgs(cmdEnv.server), "find " + SERVER_IN_PROGRESS_TEST_FILE + " -size 0 -delete"])
         .catch(() => {});
 
     await git().checkout("-");
@@ -137,7 +138,7 @@ exports.restoreServerFilesToLastDeployed = restoreServerFilesToLastDeployed
 /* ************************************ */
 async function addFileToCurrentTest(server, changedFile, changedFiles, changeType, restoreChanges) {
     let inUse = "";
-    await execa('ssh', [server, "grep -F '" + changedFile + " ' " + SERVER_IN_PROGRESS_TEST_FILE ])
+    await execa('ssh', [...getSshArgs(server), "grep -F '" + changedFile + " ' " + SERVER_IN_PROGRESS_TEST_FILE ])
         .then( value => inUse = value.stdout )
         .catch( () => { } ) /* grep returns error if no match and execa throws an excepcions when return is error */
         .finally( async () => {
@@ -153,7 +154,7 @@ async function addFileToCurrentTest(server, changedFile, changedFiles, changeTyp
 
             if(!changedFiles.has(changedFile)) {
                 const user = require("os").userInfo().username;
-                execa('ssh', [server, "echo '" + changedFile + " by " + user + "' >> " + SERVER_IN_PROGRESS_TEST_FILE]);
+                execa('ssh', [...getSshArgs(server), "echo '" + changedFile + " by " + user + "' >> " + SERVER_IN_PROGRESS_TEST_FILE]);
                 changedFiles.add(changedFile);
             }
             console.log(" " + changeType.replace(/(e)([^e]*)$/, "ed$2 ") + changedFile);
@@ -163,14 +164,14 @@ async function addFileToCurrentTest(server, changedFile, changedFiles, changeTyp
 /* ************************************ */
 async function removeFileFromCurrentTest(server, changedFile) {
     await syncFile(server, changedFile);
-    await execa('ssh', [server, "sed -i '/" + changedFile.split("/").join("\\/") + "/d'  " + SERVER_IN_PROGRESS_TEST_FILE]).catch( () => {/* ignore files removed by user */} );
+    await execa('ssh', [...getSshArgs(server), "sed -i '/" + changedFile.split("/").join("\\/") + "/d'  " + SERVER_IN_PROGRESS_TEST_FILE]).catch( () => {/* ignore files removed by user */} );
     console.log(" reset ".brightGreen + changedFile);
 }
 exports.removeFileFromCurrentTest = removeFileFromCurrentTest
 
 /* ************************************ */
 function checkNoTestsRunningOnServer(server) {
-    return execa('ssh', [server, "cat " + SERVER_IN_PROGRESS_TEST_FILE])
+    return execa('ssh', [...getSshArgs(server), "cat " + SERVER_IN_PROGRESS_TEST_FILE])
             .then(value => {
                 throw new Error(
                         "Aborted:".red + " there are tests running with files changed on the server:\n  "

package/lib/task_lists/test_syncFile.js

@@ -2,6 +2,7 @@ const execa = require('execa');
 const fs = require('fs-extra');
 const path = require('path');
 const { resolveCobPath } = require("./common_syncFiles");
+const { getSshArgs, getRsyncSsh } = require("./common_helpers");
 
 const DEBUG = false;
 const RSYNC_RETRIES = 10;
@@ -18,7 +19,7 @@ async function syncFile(server, localFile) {
 
     let count = 0;
     while (count < RSYNC_RETRIES) {
-        await execa('ssh', [server, "mkdir -p " + remoteFileDir]).catch({});
+        await execa('ssh', [...getSshArgs(server), "mkdir -p " + remoteFileDir]).catch({});
         await execa('rsync', [localFile, remoteProductPath + productScopeFilePath,
             "-acz",
             "--prune-empty-dirs",
@@ -28,17 +29,17 @@ async function syncFile(server, localFile) {
             "--no-t",
             "--filter='merge " + path.resolve(__dirname,"rsyncFilter-pre.txt") + "'",
             "--filter='merge " + path.resolve(__dirname,"rsyncFilter-post.txt") + "'"],
-           { shell: true, env: { "RSYNC_RSH": "ssh -o ConnectTimeout=30 -o ServerAliveInterval=30 -o ServerAliveCountMax=30" } })
+           { shell: true, env: { "RSYNC_RSH": getRsyncSsh() } })
             .then(count = RSYNC_RETRIES)
             .catch(async (err) => {
                 // exitCode 23 indicam que o ficheiro não existe na origem. Temod de apagar no destino.
                 if (err.exitCode == 23) {
-                    await execa('ssh', [server, "rm -fd " + remoteProductPath.split(":")[1] + productScopeFilePath]).catch({});
+                    await execa('ssh', [...getSshArgs(server), "rm -fd " + remoteProductPath.split(":")[1] + productScopeFilePath]).catch({});
 
                     let localFileDir = localFile.substring(0, localFile.lastIndexOf("/"));
                     if (!fs.existsSync(localFileDir)) {
                         if (DEBUG) console.log(remoteFileDir + " needs to be removed");
-                        await execa('ssh', [server, "rm -rf " + remoteFileDir]).catch({});
+                        await execa('ssh', [...getSshArgs(server), "rm -rf " + remoteFileDir]).catch({});
                     }
                     count = RSYNC_RETRIES;
                 } else if ((count + 1)> RSYNC_RETRIES) {

package/lib/task_lists/test_validate.js

@@ -9,6 +9,7 @@ const { checkConnectivity } = require("./common_helpers");
 const { getCurrentBranch, getLastDeployedSha } = require("./common_releaseManager");
 const { testEquality } = require("./common_syncFiles");
 const { SERVER_IN_PROGRESS_TEST_FILE } = require("../task_lists/test_otherFilesContiousReload");
+const { getSshArgs } = require("./common_helpers");
 
 
 async function validateTestingConditions(cmdEnv, args) {
@@ -79,7 +80,7 @@ async function _handleTestEquality(ctx, changes, server) {
         let offendingFiles = changes.map(f => f.substring(17)) //17 é a posição onde começa o nome dos ficheiros em cada linha
         let problemFiles = [];
         for(let changedFile of offendingFiles) {
-            await execa('ssh', [server, "grep -F " + changedFile + " " + SERVER_IN_PROGRESS_TEST_FILE ])
+            await execa('ssh', [...getSshArgs(server), "grep -F " + changedFile + " " + SERVER_IN_PROGRESS_TEST_FILE ])
             .catch( () => { 
                 try {
                     if (fs.lstatSync(changedFile.trim()).isFile()) {
@@ -94,7 +95,7 @@ async function _handleTestEquality(ctx, changes, server) {
         if(problemFiles.length > 0)  throw new Error("Aborted:".red + " server was changed since last deploy:\n   " + problemFiles.join("\n   ") +  "\n" );
 
         let inTest = "";
-        await execa('ssh', [server, "cat " + SERVER_IN_PROGRESS_TEST_FILE])
+        await execa('ssh', [...getSshArgs(server), "cat " + SERVER_IN_PROGRESS_TEST_FILE])
         .then( value => inTest = value.stdout )
         .catch( () => { } ) /* grep returns error if no match and execa throws an excepcions when return is error */
         .finally( async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cob-cli",
-  "version": "2.53.0-beta-1",
+  "version": "2.53.0-beta-3",
   "description": "A command line utility to help Cult of Bits partners develop with higher speed and reusing common code and best practices.",
   "preferGlobal": true,
   "repository": {