ssh-client-wrapper 1.8.2 → 2.0.1

package/.github/workflows/coverage_report.yml

@@ -0,0 +1,22 @@
+name: report coverage data to code climate
+on:
+  push:
+    tags:
+      - 'v*'
+jobs:
+  coverage:
+    needs:
+      - test
+    name: coverage report
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: code-coverage-report
+      - uses: paambaati/codeclimate-action@v5.0.0
+        env:
+          CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        with:
+          coverageLocations: "coverage-report.lcov:lcov"
+          debug: true

package/.github/workflows/{npm-publish.yml → npm_publish.yml}

@@ -14,9 +14,9 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 18
+          node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm publish
         env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+          NODE_AUTH_TOKEN: ${{ secrets.npm_token }}

package/.github/workflows/run_test.yml

@@ -34,3 +34,9 @@ jobs:
           node-version: ${{ matrix.node-version }}
       - run: npm ci
       - run: npm run test
+      - run: npm run coverage
+      - uses: actions/upload-artifact@v3
+        with:
+          name: code-coverage-report
+          path: coverage-report.lcov
+          retention-days: 1

package/lib/fork.js

@@ -1,35 +1,33 @@
 "use strict";
-const debug = require("debug")("sshClientWrapper:fork");
-const debugVerbose = require("debug")("sshClientWrapper:fork_verbose");
-const debugMasterVerbose = require("debug")("sshClientWrapper:fork_masterPty_verbose");
-const debugSendPty = require("debug")("sshClientWrapper:fork_sendpty");
+const debug = require("debug")("sshClientWrapper:debug:fork");
+const debugVerbose = require("debug")("sshClientWrapper:verbose:fork");
+const debugMasterVerbose = require("debug")("sshClientWrapper:insecure:fork_masterPty");
+const debugSendPty = require("debug")("sshClientWrapper:insecure:fork_sendpty");
 const { spawn } = require("node-pty");
 
-const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String } = require("./util.js");
+const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String, sendPty, watchDogTimer } = require("./util.js");
 
 const nodePtyOpt = {
   shell: process.platform === "win32" ? process.env.ComSpec : process.env.SHELL,
   windowsHide: true
 };
 
-function sshLoginCallback(output, ptyProcess, pw, ph) {
+function sshLoginCallback(output, ptyProcess, pw, ph, logger = debugSendPty) {
   if (reNewHostPrompt.test(output)) {
-    debugSendPty("yes");
-    ptyProcess.write("yes\n");
+    sendPty(ptyProcess, "yes\n", logger, 17);
     return;
   }
   if (rePwPrompt.test(output)) {
     if (typeof pw === "string") {
       debug("use given password");
-      debugSendPty(pw);
-      ptyProcess.write(`${pw}\n`);
+      sendPty(ptyProcess, `${pw}\n`, logger, 23);
       return;
     }
     if (typeof pw === "function") {
       debug("call password callback function");
       pw()
         .then((v)=>{
-          ptyProcess.write(`${v}\n`);
+          sendPty(ptyProcess, `${v}\n`, logger, 30);
         });
       return;
     }
@@ -37,36 +35,49 @@ function sshLoginCallback(output, ptyProcess, pw, ph) {
   if (rePhPrompt.test(output)) {
     if (typeof ph === "string") {
       debug("use given passphrase");
-      debugSendPty(ph);
-      ptyProcess.write(`${ph}\n`);
+      sendPty(ptyProcess, `${ph}\n`, logger, 38);
       return;
     }
     if (typeof ph === "function") {
       debug("call passphrase callback function");
       ph()
         .then((v)=>{
-          ptyProcess.write(`${v}\n`);
+          sendPty(ptyProcess, `${v}\n`, logger, 45);
         });
     }
   }
 }
 
-function getMasterPty(hostInfo) {
+/**
+ * create pty for master ssh session and store to hostInfo.masterPty
+ */
+function getMasterPty(hostInfo, logger) {
   debug("fork pty for master connection");
+
+  if (hostInfo.masterPty) {
+    debug(`kill existing master pty for ${hostInfo.host}`);
+    hostInfo.masterPty.kill();
+  }
   const ptyProcess = spawn(nodePtyOpt.shell, [], nodePtyOpt);
   ptyProcess.onData(buff2String.bind(null, debugMasterVerbose));
   ptyProcess.onData((data)=>{
     const output = data.toString();
-    sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase);
+    sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase, logger);
   });
-  return ptyProcess;
+  hostInfo.masterPty = ptyProcess;
 }
 
-async function fork(hostInfo, cmd, args, outputCallback) {
-  let ptyProcess = null;
-  const p = new Promise((resolve, reject)=>{
+async function fork(hostInfo, cmd, args, timeout, outputCallback) {
+  return new Promise((resolve, reject)=>{
     debug(`cmd=${cmd}: args=${args}`);
-    ptyProcess = spawn(cmd, args, nodePtyOpt);
+    const ptyProcess = spawn(cmd, args, nodePtyOpt);
+    let ac = null;
+    if (timeout > 0) {
+      ac = watchDogTimer(timeout, cmd, ()=>{
+        ptyProcess.kill();
+        reject(new Error(`watchdog timer expired ${timeout}`));
+      });
+    }
     ptyProcess.onData(buff2String.bind(null, debugVerbose));
     ptyProcess.onData((data)=>{
       const output = data.toString();
@@ -86,6 +97,10 @@ async function fork(hostInfo, cmd, args, outputCallback) {
     ptyProcess.onExit(({ exitCode, signal })=>{
       debug("onExit", exitCode, signal);
 
+      if (ac !== null) {
+        ac.abort();
+      }
+
       if (signal > 0) {
         const err = new Error("signal caught");
         err.signal = signal;
@@ -99,8 +114,6 @@ async function fork(hostInfo, cmd, args, outputCallback) {
       return reject(err);
     });
   });
-  p.pty = ptyProcess;
-  return p;
 }
 module.exports = {
   fork,

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
-const debugLib = require("debug");
-const debug = debugLib("sshClientWrapper:interface");
+const debug = require("debug")("sshClientWrapper:interface");
+const debugVerbose = require("debug")("sshClientWrapper:verbose:interface");
 const { sshExec, canConnect, disconnect, ls } = require("./sshExec.js");
 const { send, recv } = require("./rsyncExec.js");
 const { isArrayOfString, sanityCheck } = require("./util.js");
@@ -30,12 +30,19 @@ const { isArrayOfString, sanityCheck } = require("./util.js");
  * @param {string[]} hostInfo.sshOpt - additional options for ssh
  */
 
+const logAndReject = (message)=>{
+  debug(message);
+  return Promise.reject(new Error(message));
+};
+
 /**
  * Facade class.
  * @constructor
  */
 class SshClientWrapper {
   constructor(hostInfo) {
+    debug("constructor called for", hostInfo.host);
+    debugVerbose("hostInfo=", hostInfo);
     sanityCheck(hostInfo);
     this.hostInfo = { ...hostInfo };
     this.hostInfo.masterPty = null;
@@ -44,18 +51,19 @@ class SshClientWrapper {
   /**
    * Execute command on remote host.
    * @param {string} cmd - Cmdline which will be executed.
+   * @param {Integer} timeout - timeout in secconds
    * @param { Function } outputCallback - call back routine for output
    * @returns {Integer} - Return code of cmd.
    *
    * If stdout and stderr is array, last 5 line of stdout and stderr is stored in them.
    */
-  async exec(cmd, outputCallback) {
+  async exec(cmd, timeout = 0, outputCallback = null) {
     debug("exec called", cmd);
 
-    if (typeof cmd !== "string") {
-      return Promise.reject(new Error("cmd must be string"));
+    if (typeof cmd !== "string" || cmd === "") {
+      return logAndReject("cmd must be string");
     }
-    return sshExec(this.hostInfo, cmd, outputCallback);
+    return sshExec(this.hostInfo, cmd, timeout, outputCallback);
   }
 
 
@@ -63,10 +71,12 @@ class SshClientWrapper {
    * execute ls command and return output
    * @param {string} target - file or directory path to watch
    * @param {string[]} lsOpt - optional arguments for ls
+   * @param {Integer} timeout - timeout in secconds
    * @returns {string[]} - output from ls
    */
-  async ls(target, lsOpt = []) {
-    return ls(this.hostInfo, target, lsOpt);
+  async ls(target, lsOpt = [], timeout = 0) {
+    debug("ls called", target, lsOpt);
+    return ls(this.hostInfo, target, lsOpt, timeout);
   }
 
   /**
@@ -81,7 +91,7 @@ class SshClientWrapper {
     debug("watch called", cmd, regexp, retryDelay, maxRetry);
 
     if (typeof cmd !== "string") {
-      return Promise.reject(new Error("cmd must be string"));
+      return logAndReject("cmd must be string");
     }
     if (!(regexp instanceof RegExp)) {
       const err = new Error("illegal regexp specified");
@@ -89,7 +99,7 @@ class SshClientWrapper {
       err.cmd = cmd;
       err.retryDelay = retryDelay;
       err.maxRetry = maxRetry;
-      return Promise.reject(err);
+      return Promise.reject(new Error("err"));
     }
     //not implemented yet !!!
     return this.exec(cmd, ()=>{
@@ -101,27 +111,30 @@ class SshClientWrapper {
    * @param {string[]} src - File or directory name which to be recieve.
    * @param {string} dst - Destination path.
    * @param {string[]} opt - option for rsync
+   * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async send(src, dst, opt) {
+  async send(src, dst, opt = [], timeout = 0) {
     debug("send called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
-      const err = "src must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("src must be array of string");
+    }
+    if (!src.some((e)=>{
+      return e !== "";
+    })) {
+      return logAndReject("src must contain non-empty string");
     }
     if (typeof dst !== "string") {
-      const err = "dst must be string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("dst must be string");
+    }
+    if (dst === "") {
+      return logAndReject("dst must be non-empty string");
     }
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
-      const err = "opt must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("opt must be array of string");
     }
-    return send(this.hostInfo, src, dst, opt);
+    return send(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -129,27 +142,30 @@ class SshClientWrapper {
    * @param {string[]} src - File or directory name which to be recieve.
    * @param {string} dst - Destination path.
    * @param {string[]} opt - option for rsync
+   * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async recv(src, dst, opt) {
+  async recv(src, dst, opt = [], timeout = 0) {
     debug("recv called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
-      const err = "src must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("src must be array of string");
+    }
+    if (!src.some((e)=>{
+      return e !== "";
+    })) {
+      return logAndReject("src must contain non-empty string");
     }
     if (typeof dst !== "string") {
-      const err = "dst must be string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("dst must be string");
+    }
+    if (dst === "") {
+      return logAndReject("dst must be non-empty string");
     }
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
-      const err = "opt must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("opt must be array of string");
     }
-    return recv(this.hostInfo, src, dst, opt);
+    return recv(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -158,10 +174,11 @@ class SshClientWrapper {
    * @returns {Promise} - Resolved with true on success, otherwise rejected with Error.
    */
   async canConnect(timeout = 60) {
-    debug("canConnect called timeout=", timeout);
+    debug("canConnect called with timeout=", timeout);
+    debugVerbose("hostInfo=", this.hostInfo);
 
     if (!Number.isInteger(timeout) || timeout <= 0) {
-      return new Error("timeout must be positive integer");
+      return logAndReject("timeout must be positive integer");
     }
     return canConnect(this.hostInfo, timeout);
   }
@@ -170,7 +187,7 @@ class SshClientWrapper {
    * Disconnect master session
    */
   async disconnect() {
-    debug("disconnect called");
+    debug(`disconnect from ${this.hostInfo.host} called`);
     disconnect(this.hostInfo);
   }
 }

package/lib/rsyncExec.js

@@ -1,7 +1,7 @@
 "use strict";
 const path = require("path");
-const debug = require("debug")("sshClientWrapper:rsyncExec");
-const debugVerbose = require("debug")("sshClientWrapper:rsyncExec_verbose");
+const debug = require("debug")("sshClientWrapper:debug:rsyncExec");
+const debugVerbose = require("debug")("sshClientWrapper:verbose:rsyncExec");
 const { glob } = require("glob");
 
 const { connect, retryWrapper, sshExec } = require("./sshExec.js");
@@ -16,10 +16,11 @@ const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
  * @param {[string]} argSrc - File or directory name which to be send.
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
+ * @param {Integer} timeout - timeout in secconds
  *
  * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
-async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
+async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const promises = await Promise.allSettled(argSrc.map((e)=>{
     return glob(e);
@@ -65,7 +66,7 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
   }
   debug(`send ${src} to ${hostInfo.host}:${dst}`);
   debugVerbose(`send: ${rsyncCmd} ${args.join(" ")}`);
-  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args), hostInfo);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout), hostInfo);
 }
 
 /**
@@ -74,10 +75,11 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
  * @param {[string]} argSrc - File or directory name which to be send.
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
+ * @param {Integer} timeout - timeout in secconds
  *
  * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
  */
-async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
+async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
@@ -87,7 +89,7 @@ async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
 
   debug(`recv ${src} to ${dst}`);
   debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
-  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args), hostInfo);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout), hostInfo);
 }
 module.exports = {
   send,

package/lib/sshExec.js

@@ -1,19 +1,20 @@
 "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, sanityCheck } = require("./util.js");
+const debug = require("debug")("sshClientWrapper:debug:sshExec");
+const debugVerbose = require("debug")("sshClientWrapper:verbose:sshExec");
+const debugSendMasterPty = require("debug")("sshClientWrapper:insecure:sshExec_masterPty");
+const { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } = require("./util.js");
 const { fork, getMasterPty } = require("./fork.js");
 
 /**
  * Execute command on remote host.
  * @param {Object} hostInfo - hostinfo object
  * @param {string} cmd - Cmdline which will be executed on remote host.
+ * @param {number} timeout - timeout (in sec.)
  * @param {Function} outputCallback - Callback routine for stdout and stderr.
  */
-async function sshExec(hostInfo, cmd, outputCallback) {
+async function sshExec(hostInfo, cmd, timeout, outputCallback) {
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
   const args = getSshOption(hostInfo, false);
@@ -21,7 +22,7 @@ async function sshExec(hostInfo, cmd, outputCallback) {
   debugVerbose(`exec: ${sshCmd} ${args.join(" ")}`);
 
   try {
-    const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, outputCallback), hostInfo);
+    const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, timeout, outputCallback), hostInfo);
     return rt;
   } catch (e) {
     if (typeof e.rt === "undefined") {
@@ -64,9 +65,7 @@ async function canConnect(hostInfo, timeout = 60) {
  * @returns {boolean} - true if master session exists
  */
 async function existsMaster(hostInfo) {
-  const ac = new AbortController();
-  const signal = ac.signal;
-
+  debugVerbose("existsMaster called");
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
 
@@ -75,31 +74,12 @@ async function existsMaster(hostInfo) {
     output += e;
   };
 
-  let rt = true; //if timeout occurred during ssh -Ocheck, it will turn to false
-  let p;
+  const rt = true; //if timeout occurred during ssh -Ocheck, it will turn to false
   const timeout = hostInfo.ConnectTimeout || 60;
-  setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(()=>{
-      debug(`can not finish master session check within ${timeout} sec`);
-
-      if (p.pty) {
-        p.pty.kill();
-      }
-      rt = false;
-    })
-    .catch((err)=>{
-      if (err.name === "AbortError") {
-        debug("timeout was aborted because master session check has done");
-      } else {
-        throw err;
-      }
-    });
+  debug(`check master session: ${sshCmd} ${args.join(" ")}`);
 
   try {
-    debug(`check master session: ${sshCmd} ${args.join(" ")}`);
-    p = fork(hostInfo, sshCmd, args, cb);
-    await p;
-    ac.abort();
+    await fork(hostInfo, sshCmd, args, timeout, cb);
   } catch (err) {
     if (err.rt !== 255) {
       debug("check master session failed", err);
@@ -119,36 +99,22 @@ async function connect(hostInfo, timeout = 60) {
     debugVerbose("master connection exists");
     return;
   }
-  debug(`create master ssh session to ${hostInfo.host}`);
 
-  if (!hostInfo.masterPty) {
-    debug(`create master pty for ${hostInfo.host}`);
-    hostInfo.masterPty = getMasterPty(hostInfo);
-  } else {
-    debug(`master pty for ${hostInfo.host} exists`);
-  }
+  debug(`create master pty for ${hostInfo.host}`);
+  getMasterPty(hostInfo, debugSendMasterPty);
+
+  debug(`create master ssh session to ${hostInfo.host}`);
 
-  const ac = new AbortController();
-  const signal = ac.signal;
-  setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(()=>{
-      debug(`can not connect within ${timeout} sec`);
-      hostInfo.masterPty.write("\n");
-      hostInfo.masterPty.write("exit\n");
+  const ac = watchDogTimer(timeout, "make connection", ()=>{
+    sendPty(hostInfo.masterPty, "\n", debugSendMasterPty, 137);
+    sendPty(hostInfo.masterPty, "exit\n", debugSendMasterPty, 138);
 
-      const err = new Error(`can not connect within ${timeout} sec`);
-      err.host = hostInfo.host;
-      err.user = hostInfo.user;
-      err.port = hostInfo.port;
-      throw err;
-    })
-    .catch((err)=>{
-      if (err.name === "AbortError") {
-        debug("timeout was aborted because connection check has done");
-      } else {
-        throw err;
-      }
-    });
+    const err = new Error(`can not connect within ${timeout} sec`);
+    err.host = hostInfo.host;
+    err.user = hostInfo.user;
+    err.port = hostInfo.port;
+    throw err;
+  });
 
   const words = crypto.randomUUID();
   const re = new RegExp(`^${words}`);
@@ -164,7 +130,6 @@ async function connect(hostInfo, timeout = 60) {
 
       if (re.test(output)) {
         debug("test done. call exit on remotehost");
-        hostInfo.masterPty.write("exit\n");
         done = true;
         resolve();
       } else if (/Permission denied \(/.test(output)) {
@@ -186,11 +151,14 @@ async function connect(hostInfo, timeout = 60) {
   const args = getSshOption(hostInfo);
   args.push(`echo ${words}`);
   const cmd = `${sshCmd} ${args.join(" ")}\n`;
-  debugVerbose(cmd);
-  hostInfo.masterPty.write(cmd);
-  await p;
-  ac.abort();
-  debug(`connected to ${hostInfo.host}`);
+  sendPty(hostInfo.masterPty, cmd, debugSendMasterPty, 190);
+
+  try {
+    await p;
+    debug(`connected to ${hostInfo.host}`);
+  } finally {
+    ac.abort();
+  }
 }
 
 /**
@@ -208,7 +176,7 @@ async function disconnect(hostInfo) {
     };
     try {
       debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
-      await fork(hostInfo, sshCmd, args, cb);
+      await fork(hostInfo, sshCmd, args, 0, cb);
     } catch (err) {
       if (err.rt === 255) {
         return;
@@ -225,7 +193,7 @@ async function disconnect(hostInfo) {
 
   if (hostInfo.masterPty) {
     debug("exit masterPty");
-    hostInfo.masterPty.write("exit \n");
+    sendPty(hostInfo.masterPty, "exit \n", debugSendMasterPty, 228);
     hostInfo.masterPty = null;
   }
 }
@@ -235,12 +203,13 @@ async function disconnect(hostInfo) {
  * @param {Object} hostInfo - hostinfo object
  * @param {string} target - file or directory path to watch
  * @param {string[]} lsOpt - optional arguments for ls
+ * @param {number} timeout - timeout (in sec.)
  * @returns {string[]} - output from ls
  */
-async function ls(hostInfo, target, lsOpt = []) {
+async function ls(hostInfo, target, lsOpt, timeout) {
   const outputArray = [];
   try {
-    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, (data)=>{
+    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data)=>{
       outputArray.push(data);
     });
   } catch (e) {