ssh-client-wrapper 1.3.0 → 1.5.0

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,52 +6,70 @@ 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") {
-          debug("use given password");
-          debugSendPty(hostInfo.password);
-          ptyProcess.write(`${hostInfo.password}\n`);
-        } else if (typeof hostInfo.password === "function") {
-          debug("call password callback function");
-          hostInfo.password()
-            .then((pw)=>{
-              ptyProcess.write(`${pw}\n`);
-            });
-        }
-      }
-      if (rePhPrompt.test(output)) {
-        if (typeof hostInfo.passphrase === "string") {
-          debug("use given passphrase");
-          debugSendPty(hostInfo.passphrase);
-          ptyProcess.write(`${hostInfo.passphrase}\n`);
-        } else if (typeof hostInfo.passphrase === "function") {
-          debug("call passphrase callback 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");
@@ -76,4 +94,7 @@ async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
     });
   });
 }
-module.exports = fork;
+module.exports = {
+  fork,
+  getMasterPty
+};

package/lib/index.js

@@ -12,25 +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.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;
   }
 
   /**
@@ -79,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) {
@@ -107,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,8 +4,8 @@ const debug = require("debug")("sshClientWrapper:rsyncExec");
 const debugVerbose = require("debug")("sshClientWrapper:rsyncExec_verbose");
 const { glob } = require("glob");
 
-const { retryWrapper, 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");
 
@@ -20,15 +20,31 @@ 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);
   }));
-  const src = promises.flatMap((e)=>{
-    if (e.status !== "fulfilled") {
-      return [];
-    }
-    return e.value;
-  });
+  const src = promises
+    .map((e, i)=>{
+      if (e.status !== "fulfilled") {
+        return null;
+      }
+      if (argSrc[i].endsWith("/")) {
+        return `${e.value}/`;
+      }
+      return e.value;
+    })
+    .filter((e)=>{
+      return e !== null;
+    })
+    .flatMap((e)=>{
+      return e;
+    });
+
+  if (src.length === 0) {
+    debug("src file not found");
+    return false;
+  }
 
   const sshArgs = getSshOption(hostInfo, true);
   const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
@@ -56,6 +72,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(" ")}`];

package/lib/sshExec.js

@@ -5,7 +5,7 @@ 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.
@@ -13,13 +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 retryWrapper(fork.bind(null, hostInfo, sshCmd, args, opt, outputCallback), hostInfo);
+  return retryWrapper(fork.bind(null, hostInfo, sshCmd, args, outputCallback), hostInfo);
 }
 
 /**
@@ -27,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) {
+async function canConnect(hostInfo, timeout = 60) {
+  await connect(hostInfo);
   debug("check connectibity");
   const words = crypto.randomUUID();
   const args = getSshOption(hostInfo);
@@ -35,7 +37,6 @@ async function canConnect(hostInfo, timeout) {
     args.push(`-oConnectTimeout=${timeout}`);
   }
   args.push(`echo ${words}`);
-
   let output = "";
   const cb = (e)=>{
     output += e;
@@ -59,7 +60,7 @@ async function canConnect(hostInfo, timeout) {
     });
 
   debugVerbose(`canConnect: ${sshCmd} ${args.join(" ")}`);
-  const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, null, cb), hostInfo);
+  const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, cb), hostInfo);
   ac.abort();
 
   if (rt !== 0) {
@@ -74,6 +75,68 @@ async function canConnect(hostInfo, timeout) {
   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
@@ -88,12 +151,18 @@ async function disconnect(hostInfo) {
   };
   try {
     debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
-    await fork(hostInfo, sshCmd, args, null, cb);
+    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}`);
 }
 
@@ -102,7 +171,10 @@ async function disconnect(hostInfo) {
  * @param {Function}  func - function to be wrapped
  */
 async function retryWrapper(func, hostInfo) {
-  return promiseRetry({ retries: 3, minTimeout: 5000, maxTimeout: 5000 }, (retry, number)=>{
+  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) {
@@ -118,6 +190,7 @@ async function retryWrapper(func, hostInfo) {
 module.exports = {
   sshExec,
   canConnect,
+  connect,
   disconnect,
   retryWrapper
 };

package/lib/util.js

@@ -52,25 +52,17 @@ const getSshOption = (hostInfo, withoutDestination)=>{
   args.push("-oControlPath=~/.ssh/ssh-client-wrapper-%r@%h:%p");
   args.push(`-oControlPersist=${ControlPersist}`);
 
-  if (Number.isInteger(hostInfo.Timeout) && hostInfo.Timeout > 0) {
-    args.push(`-oConnectTimeout=${hostInfo.Timeout}`);
+  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,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",

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, 2)).to.be.true;
     });
     it("should be rejected if user does not exist", async ()=>{
-      hostInfo2.user = "xxxx";
-      return expect(canConnect(hostInfo2, 2)).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, 2)).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, 2)).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, 2)).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, 2)).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, 2)).to.be.rejectedWith(255);
+      hostInfo.port = 65536;
+      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
     });
   });
 });