ssh-client-wrapper 1.2.1 → 1.4.2

package/.github/workflows/run_test.yml

@@ -3,6 +3,8 @@ on:
   push:
     tags-ignore:
       - 'v*'
+    branches:
+      - '*'
   workflow_call:
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -18,6 +20,7 @@ jobs:
       TEST_USER: testuser
       TEST_PW: passw0rd
       TEST_PORT: 10022
+      DEBUG: 'ssh*'
     runs-on: ubuntu-latest
     strategy:
       matrix:

package/lib/fork.js

@@ -6,47 +6,75 @@ const { spawn } = require("node-pty");
 
 const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String } = require("./util.js");
 
-const defaultOpt = {
-
+const nodePtyOpt = {
   shell: process.platform === "win32" ? process.env.ComSpec : process.env.SHELL,
   windowsHide: true
 };
-async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
-  return new Promise((resolve, reject)=>{
-    const opt = argOpt || defaultOpt;
 
+function sshLoginCallback(output, ptyProcess, pw, ph) {
+  if (reNewHostPrompt.test(output)) {
+    debugSendPty("yes");
+    ptyProcess.write("yes\n");
+    return;
+  }
+  if (rePwPrompt.test(output)) {
+    if (typeof pw === "string") {
+      debug("use given password");
+      debugSendPty(pw);
+      ptyProcess.write(`${pw}\n`);
+      return;
+    }
+    if (typeof pw === "function") {
+      debug("call password callback function");
+      pw()
+        .then((v)=>{
+          ptyProcess.write(`${v}\n`);
+        });
+      return;
+    }
+  }
+  if (rePhPrompt.test(output)) {
+    if (typeof ph === "string") {
+      debug("use given passphrase");
+      debugSendPty(ph);
+      ptyProcess.write(`${ph}\n`);
+      return;
+    }
+    if (typeof ph === "function") {
+      debug("call passphrase callback function");
+      ph()
+        .then((v)=>{
+          ptyProcess.write(`${v}\n`);
+        });
+    }
+  }
+}
+
+function getMasterPty(hostInfo) {
+  debug("fork pty for master connection");
+  const ptyProcess = spawn(nodePtyOpt.shell, [], nodePtyOpt);
+  ptyProcess.onData(buff2String.bind(null, debugVerbose));
+  ptyProcess.onData((data)=>{
+    const output = data.toString();
+    sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase);
+  });
+  return ptyProcess;
+}
+
+async function fork(hostInfo, cmd, args, outputCallback) {
+  return new Promise((resolve, reject)=>{
     debug(`cmd=${cmd}: args=${args}`);
-    const ptyProcess = spawn(cmd, args, opt);
+    const ptyProcess = spawn(cmd, args, nodePtyOpt);
     ptyProcess.onData(buff2String.bind(null, debugVerbose));
-
     ptyProcess.onData((data)=>{
       const output = data.toString();
+      sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase);
 
-      if (reNewHostPrompt.test(output)) {
-        debugSendPty("yes");
-        ptyProcess.write("yes\n");
-      }
-      if (rePwPrompt.test(output)) {
-        if (typeof hostInfo.password === "string") {
-          debugSendPty(hostInfo.password);
-          ptyProcess.write(`${hostInfo.password}\n`);
-        } else if (typeof hostInfo.password === "function") {
-          hostInfo.password()
-            .then((pw)=>{
-              ptyProcess.write(`${pw}\n`);
-            });
-        }
-      }
-      if (rePhPrompt.test(output)) {
-        if (typeof hostInfo.passphrase === "string") {
-          debugSendPty(hostInfo.passphrase);
-          ptyProcess.write(`${hostInfo.passphrase}\n`);
-        } else if (typeof hostInfo.passphrase === "function") {
-          hostInfo.passphrase()
-            .then((pw)=>{
-              ptyProcess.write(`${pw}\n`);
-            });
-        }
+      if (/kex_exchange_identification: Connection closed by remote host/.test(output)) {
+        ptyProcess.kill();
+        const err = new Error("kex_exchange_identification");
+        err.retryable = true;
+        reject(err);
       }
     });
 
@@ -66,4 +94,7 @@ async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
     });
   });
 }
-module.exports = fork;
+module.exports = {
+  fork,
+  getMasterPty
+};

package/lib/index.js

@@ -12,24 +12,35 @@ const { isArrayOfString } = require("./util.js");
  */
 
 /**
- * Facade class.
- * @constructor
+ * host info object which contain all settings for 1 remote host
+ * it will be (shallow) copied in constructor.
  * @param {Object} hostInfo - option object
  * @param {string} hostInfo.host - destination
  * @param {string} hostInfo.user - login name
  * @param {number} hostInfo.port - port number
- * @param {string | Function} hostInfo.password - password
- * @param {string | Function} hostInfo.passphrase - passphrase
+ * @param {string | Function} hostInfo.password - password or function which return password
+ * @param {string | Function} hostInfo.passphrase - passphrase or function which return passphrase of private key
  * @param {string} hostInfo.keyFile - private key filename
  * @param {boolean} hostInfo.noStrictHostkeyChecking - bypass host key checking if true
- * @param {Integer} hostInfo.renewInterval=0 - Connection renewal interval (sec).
+ * @param {Integer} hostInfo.ControlPersist=180 - how long keep master connection after last client connection has been closed (sec).
+ * @param {Integer} hostInfo.ConnectTimeout=60 - timeout used when connectiong to ths SSH server
+ * @param {Integer} hostInfo.maxRetry=3 - max number of retry
+ * @param {Integer} hostInfo.retryMinTimeout=60 - minimum duration before first retry
+ * @param {Integer} hostInfo.retryMaxTimeout=300 - maximum duration between each retry
+ * @param {string[]} hostInfo.sshOpt - additional options for ssh
+ */
+
+/**
+ * Facade class.
+ * @constructor
  */
 class SshClientWrapper {
   constructor(hostInfo) {
     if (typeof hostInfo.host !== "string") {
       return new Error("hostname must be specified!");
     }
-    this.hostInfo = hostInfo;
+    this.hostInfo = { ...hostInfo };
+    this.hostInfo.masterPty = null;
   }
 
   /**
@@ -78,9 +89,9 @@ class SshClientWrapper {
 
   /**
    * Send file or directory and its child to server.
-   * @param {[string]} src - File or directory name which to be recieve.
+   * @param {string[]} src - File or directory name which to be recieve.
    * @param {string} dst - Destination path.
-   * @param {[string]} opt - option for rsync
+   * @param {string[]} opt - option for rsync
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
   async send(src, dst, opt) {
@@ -106,9 +117,9 @@ class SshClientWrapper {
 
   /**
    * Get file or directory and its child from server.
-   * @param {[string]} src - File or directory name which to be recieve.
+   * @param {string[]} src - File or directory name which to be recieve.
    * @param {string} dst - Destination path.
-   * @param {[string]} opt - option for rsync
+   * @param {string[]} opt - option for rsync
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
   async recv(src, dst, opt) {

package/lib/rsyncExec.js

@@ -4,11 +4,12 @@ const debug = require("debug")("sshClientWrapper:rsyncExec");
 const debugVerbose = require("debug")("sshClientWrapper:rsyncExec_verbose");
 const { glob } = require("glob");
 
-const { sshExec } = require("./sshExec.js");
-const fork = require("./fork.js");
+const { connect, retryWrapper, sshExec } = require("./sshExec.js");
+const { fork } = require("./fork.js");
 
 const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
 
+
 /**
  * Send file or directory and its child to server.
  * @param {Object} hostInfo - hostinfo object
@@ -19,6 +20,7 @@ const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
  * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
 async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
+  await connect(hostInfo);
   const promises = await Promise.allSettled(argSrc.map((e)=>{
     return glob(e);
   }));
@@ -41,8 +43,8 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
     sshExec(hostInfo, `mkdir -p ${remoteDir}`, debugVerbose);
   }
   debug(`send ${src} to ${hostInfo.host}:${dst}`);
-  debugVerbose(`rsyncCmd=${rsyncCmd}: args=${args}`);
-  return fork(hostInfo, rsyncCmd, args);
+  debugVerbose(`send: ${rsyncCmd} ${args.join(" ")}`);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args), hostInfo);
 }
 
 /**
@@ -55,6 +57,7 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
  * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
  */
 async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
+  await connect(hostInfo);
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
   const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
@@ -62,8 +65,8 @@ async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
   const args = ["-avv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, src, dst];
 
   debug(`recv ${src} to ${dst}`);
-  debugVerbose(`rsyncCmd=${rsyncCmd}: args=${args}`);
-  return fork(hostInfo, rsyncCmd, args);
+  debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args), hostInfo);
 }
 module.exports = {
   send,

package/lib/sshExec.js

@@ -1,9 +1,11 @@
 "use strict";
 const { setTimeout: setTimeoutPromise } = require("timers/promises");
 const crypto = require("crypto");
+const promiseRetry = require("promise-retry");
 const debug = require("debug")("sshClientWrapper:sshExec");
+const debugVerbose = require("debug")("sshClientWrapper:sshExec_verbose");
 const { sshCmd, getSshOption } = require("./util.js");
-const fork = require("./fork.js");
+const { fork, getMasterPty } = require("./fork.js");
 
 /**
  * Execute command on remote host.
@@ -11,12 +13,14 @@ const fork = require("./fork.js");
  * @param {string} cmd - Cmdline which will be executed on remote host.
  * @param {Function} outputCallback - Callback routine for stdout and stderr.
  */
-async function sshExec(hostInfo, cmd, outputCallback, opt = null) {
+async function sshExec(hostInfo, cmd, outputCallback) {
+  await connect(hostInfo);
   debug("exec", cmd, "on remote server");
-  const args = getSshOption(hostInfo);
+  const args = getSshOption(hostInfo, false);
   args.push(cmd);
+  debugVerbose(`exec: ${sshCmd} ${args.join(" ")}`);
 
-  return fork(hostInfo, sshCmd, args, opt, outputCallback);
+  return retryWrapper(fork.bind(null, hostInfo, sshCmd, args, outputCallback), hostInfo);
 }
 
 /**
@@ -24,7 +28,8 @@ async function sshExec(hostInfo, cmd, outputCallback, opt = null) {
  * @param {Object} hostInfo - hostinfo object
  * @param {Integer} timeout - timeout in secconds
  */
-async function canConnect(hostInfo, timeout = 5) {
+async function canConnect(hostInfo, timeout = 60) {
+  await connect(hostInfo);
   debug("check connectibity");
   const words = crypto.randomUUID();
   const args = getSshOption(hostInfo);
@@ -32,7 +37,6 @@ async function canConnect(hostInfo, timeout = 5) {
     args.push(`-oConnectTimeout=${timeout}`);
   }
   args.push(`echo ${words}`);
-
   let output = "";
   const cb = (e)=>{
     output += e;
@@ -41,7 +45,7 @@ async function canConnect(hostInfo, timeout = 5) {
   const ac = new AbortController();
   const signal = ac.signal;
 
-  setTimeoutPromise(timeout * 1000, "foobar", { signal })
+  setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
     .then(()=>{
       const err = new Error(`can not connect within ${timeout} sec`);
       err.host = hostInfo.host;
@@ -55,7 +59,8 @@ async function canConnect(hostInfo, timeout = 5) {
       }
     });
 
-  const rt = await fork(hostInfo, sshCmd, args, null, cb);
+  debugVerbose(`canConnect: ${sshCmd} ${args.join(" ")}`);
+  const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, cb), hostInfo);
   ac.abort();
 
   if (rt !== 0) {
@@ -70,6 +75,68 @@ async function canConnect(hostInfo, timeout = 5) {
   return re.test(output);
 }
 
+async function existsMaster(hostInfo) {
+  const args = getSshOption(hostInfo);
+  args.push("-Ocheck");
+
+  let output = "";
+  const cb = (e)=>{
+    output += e;
+  };
+  try {
+    debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
+    await fork(hostInfo, sshCmd, args, cb);
+  } catch (err) {
+    if (err !== 255 || !/Control socket connect.*: No such file or directory/.test(output)) {
+      throw err;
+    }
+  }
+  return !/Control socket connect.*: No such file or directory/.test(output);
+}
+
+/**
+ * create master ssh connection
+ */
+async function connect(hostInfo) {
+  if (await existsMaster(hostInfo)) {
+    debugVerbose("master connection exists");
+    return;
+  }
+
+  debug(`create master ssh session to ${hostInfo.host}`);
+  const pty = hostInfo.masterPty || getMasterPty(hostInfo);
+  hostInfo.masterPty = pty;
+
+  const words = crypto.randomUUID();
+  const re = new RegExp(`^${words}`);
+
+  const args = getSshOption(hostInfo);
+  args.push(`echo ${words}`);
+  const cmd = `${sshCmd} ${args.join(" ")}\n`;
+  pty.write(cmd);
+  const p = new Promise((resolve, reject)=>{
+    pty.onData((data)=>{
+      const output = data.toString();
+      if (re.test(output)) {
+        debug("call exit on remotehost");
+        pty.write("exit\n");
+        resolve();
+      } else if (/Permission denied \(/.test(output)) {
+        reject(new Error("Permission denied"));
+      } else if (/Could not resolve hostname/.test(output)) {
+        reject(new Error("Could not resolve hostname"));
+      } else if (/Bad port/.test(output)) {
+        reject(new Error("Bad port"));
+      } else if (/Operation|Connection timed out/.test(output)) {
+        reject(new Error("Operation timed out"));
+      }
+    });
+    pty.onExit(reject);
+  });
+  await p;
+  debug(`connected to ${hostInfo.host}`);
+}
+
 /**
  * remove master session
  * @param {Object} hostInfo - hostinfo object
@@ -83,16 +150,47 @@ async function disconnect(hostInfo) {
     output += e;
   };
   try {
-    await fork(hostInfo, sshCmd, args, null, cb);
+    debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
+    await fork(hostInfo, sshCmd, args, cb);
   } catch (err) {
     if (err !== 255 || !/Control socket connect.*: No such file or directory/.test(output)) {
       throw err;
     }
   }
+
+  if (hostInfo.masterPty) {
+    debug("exit masterPty");
+    hostInfo.masterPty.write("exit \n");
+    hostInfo.masterPty = null;
+  }
+  debug(`disconnected from ${hostInfo.host}`);
 }
 
+/**
+ * retry fork() if it throw retryable error
+ * @param {Function}  func - function to be wrapped
+ */
+async function retryWrapper(func, hostInfo) {
+  const minTimeout = hostInfo.retryMinTimeout * 1000 || 60000;
+  const maxTimeout = hostInfo.retryMaxTimeout * 1000 || 300000;
+  const retries = hostInfo.maxRetry || 3;
+  return promiseRetry({ retries, minTimeout, maxTimeout }, (retry, number)=>{
+    return func()
+      .catch((e)=>{
+        if (e.retryable) {
+          debug(`retrying: ${number} times`);
+          disconnect(hostInfo).then(retry);
+        }
+        throw e;
+      });
+  });
+}
+
+
 module.exports = {
   sshExec,
   canConnect,
-  disconnect
+  connect,
+  disconnect,
+  retryWrapper
 };

package/lib/util.js

@@ -1,6 +1,5 @@
 "use strict";
 const { EOL } = require("os");
-
 const sshCmd = "ssh";
 const rsyncCmd = "rsync";
 
@@ -48,26 +47,22 @@ const getSshOption = (hostInfo, withoutDestination)=>{
   if (hostInfo.noStrictHostkeyChecking) {
     args.push("-oStrictHostKeyChecking=no");
   }
-  const renewInterval = Number.isInteger(hostInfo.renewInterval) && hostInfo.renewInterval > 0 ? hostInfo.renewInterval : 180;
+  const ControlPersist = Number.isInteger(hostInfo.ControlPersist) && hostInfo.ControlPersist >= 0 ? hostInfo.ControlPersist : "180";
   args.push("-oControlMaster=auto");
   args.push("-oControlPath=~/.ssh/ssh-client-wrapper-%r@%h:%p");
-  args.push(`-oControlPersist=${renewInterval}`);
+  args.push(`-oControlPersist=${ControlPersist}`);
+
+  if (Number.isInteger(hostInfo.ConnectTimeout) && hostInfo.ConnectTimeout > 0) {
+    args.push(`-oConnectTimeout=${hostInfo.ConnectTimeout}`);
+  }
+  if (Array.isArray(hostInfo.sshOpt)) {
+    args.push(...hostInfo.sshOpt.filter((e)=>{
+      return typeof e === "string";
+    }));
+  }
   return args;
 };
 
-/**
- * sleep given time
- * @param {number} time - duration in msec
- */
-async function sleep(time) {
-  return new Promise((resolve)=>{
-    setTimeout(()=>{
-      resolve();
-    }, time);
-  });
-}
-
-
 const isArrayOfString = (target)=>{
   if (!Array.isArray(target)) {
     return false;

package/package.json

@@ -1,7 +1,16 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "1.2.1",
+  "version": "1.4.2",
   "description": "wrapper library for open ssh client and rsync",
+  "keywords": [
+    "ssh",
+    "ssh2",
+    "secure",
+    "shell",
+    "client",
+    "wrapper",
+    "rsync"
+  ],
   "main": "lib/index.js",
   "scripts": {
     "test": "mocha --recursive test",
@@ -29,7 +38,8 @@
   "dependencies": {
     "debug": "^4.3.4",
     "glob": "^10.2.2",
-    "node-pty": "^0.10.1"
+    "node-pty": "^0.10.1",
+    "promise-retry": "^2.0.1"
   },
   "devDependencies": {
     "chai": "^4.3.7",

package/test/sshExec.js

@@ -16,12 +16,12 @@ const sshout = sinon.stub();
 const { sshExec, canConnect, disconnect } = require("../lib/sshExec.js");
 
 //test helpers
-const hostInfo = require("./util/hostInfo.js");
+let hostInfo = require("./util/hostInfo.js");
 const { nonExisting } = require("./util/testFiles.js");
 
 
 describe("test for ssh execution", function() {
-  this.timeout(10000);//eslint-disable-line no-invalid-this
+  this.timeout(20000);//eslint-disable-line no-invalid-this
   beforeEach(()=>{
     sshout.reset();
   });
@@ -58,37 +58,44 @@ describe("test for ssh execution", function() {
     });
   });
   describe("#canConnect", ()=>{
-    let hostInfo2;
+    let hostInfoBak;
     beforeEach(async ()=>{
-      hostInfo2 = { ...hostInfo };
       await disconnect(hostInfo);
+      hostInfo.masterPty = null;
+      hostInfoBak = { ...hostInfo };
+    });
+    afterEach(()=>{
+      const masterPty = hostInfo.masterPty;
+      hostInfo = { ...hostInfoBak };
+      hostInfo.masterPty = masterPty;
     });
     it("should be resolved with true", async ()=>{
-      expect(await canConnect(hostInfo)).to.be.true;
+      expect(await canConnect(hostInfo, 2)).to.be.true;
     });
     it("should be rejected if user does not exist", async ()=>{
-      hostInfo2.user = "xxxx";
-      return expect(canConnect(hostInfo2)).to.be.rejected;
+      hostInfo.user = "xxxx";
+      return expect(canConnect(hostInfo, 2)).to.be.rejected;
     });
     it("should be rejected if password is wrong", async ()=>{
-      hostInfo2.password = "xxxx";
-      return expect(canConnect(hostInfo2)).to.be.rejected;
+      hostInfo.password = "xxxx";
+      return expect(canConnect(hostInfo, 2)).to.be.rejected;
     });
     it("should be rejected if host does not exist", async ()=>{
-      hostInfo2.host = "foo.bar.example.com";
-      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+      hostInfo.host = "foo.bar.example.com";
+      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
     });
     it("should be rejected if host(ip address) does not exist", async ()=>{
-      hostInfo2.host = "192.0.2.1";
-      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+      hostInfo.host = "192.0.2.1";
+      hostInfo.ConnectTimeout = 8; //please note each test will be timed out in 20 seconds
+      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
     });
     it("should be rejected if port number is out of range(-1)", async ()=>{
-      hostInfo2.port = -1;
-      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+      hostInfo.port = -1;
+      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
     });
     it("should be rejected if port number is out of range(65536)", async ()=>{
-      hostInfo2.port = 65536;
-      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+      hostInfo.port = 65536;
+      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
     });
   });
 });