ssh-client-wrapper 1.5.2 → 1.5.4

package/lib/fork.js

@@ -85,12 +85,16 @@ async function fork(hostInfo, cmd, args, outputCallback) {
       debug("onExit", exitCode, signal);
 
       if (signal > 0) {
-        return reject(signal);
+        const err = new Error("signal caught");
+        err.signal = signal;
+        return reject(err);
       }
-      if ([0, 126, 127].includes(exitCode)) {
+      if (exitCode === 0) {
         return resolve(exitCode);
       }
-      return reject(exitCode);
+      const err = new Error("exit with non-zero");
+      err.rt = exitCode;
+      return reject(err);
     });
   });
 }

package/lib/index.js

@@ -1,7 +1,7 @@
 "use strict";
 const debugLib = require("debug");
 const debug = debugLib("sshClientWrapper:interface");
-const { sshExec, canConnect, disconnect } = require("./sshExec.js");
+const { sshExec, canConnect, disconnect, ls } = require("./sshExec.js");
 const { send, recv } = require("./rsyncExec.js");
 const { isArrayOfString } = require("./util.js");
 
@@ -60,6 +60,17 @@ class SshClientWrapper {
     return sshExec(this.hostInfo, cmd, outputCallback);
   }
 
+
+  /**
+   * execute ls command and return output
+   * @param {string} target - file or directory path to watch
+   * @param {string[]} lsOpt - optional arguments for ls
+   * @returns {string[]} - output from ls
+   */
+  async ls(target, lsOpt = []) {
+    return ls(this.hostInfo, target, lsOpt);
+  }
+
   /**
    * Execute command repeatedly until specified keyword is found in stdout and/or stderr.
    * @param {string} cmd - Cmdline which will be executed.

package/lib/rsyncExec.js

@@ -50,7 +50,13 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
   const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
 
   const args = ["-avv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, ...src, `${hostInfo.host}:${dst}`];
-  const { dir: remoteDir } = path.parse(dst);
+  let remoteDir;
+  if (dst.endsWith("/")) {
+    remoteDir = dst;
+  } else {
+    const { dir } = path.parse(dst);
+    remoteDir = dir;
+  }
   debug("remoteDir=", remoteDir);
 
   if (remoteDir !== "" && remoteDir !== "/") {

package/lib/sshExec.js

@@ -20,7 +20,23 @@ async function sshExec(hostInfo, cmd, outputCallback) {
   args.push(cmd);
   debugVerbose(`exec: ${sshCmd} ${args.join(" ")}`);
 
-  return retryWrapper(fork.bind(null, hostInfo, sshCmd, args, outputCallback), hostInfo);
+  try {
+    const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, outputCallback), hostInfo);
+    return rt;
+  } catch (e) {
+    if (typeof e.rt === "undefined") {
+      throw e;
+    }
+    if (e.rt === 126) {
+      debug(`${cmd} got Permission deny error but ignored`);
+      return e.rt;
+    }
+    if (e.rt === 127) {
+      debug(`${cmd} not found but ignored`);
+      return e.rt;
+    }
+    throw e;
+  }
 }
 
 /**
@@ -29,19 +45,7 @@ async function sshExec(hostInfo, cmd, outputCallback) {
  * @param {Integer} timeout - timeout in secconds
  */
 async function canConnect(hostInfo, timeout = 60) {
-  await connect(hostInfo);
   debug("check connectibity");
-  const words = crypto.randomUUID();
-  const args = getSshOption(hostInfo);
-  if (Number.isInteger(timeout) && timeout > 0) {
-    args.push(`-oConnectTimeout=${timeout}`);
-  }
-  args.push(`echo ${words}`);
-  let output = "";
-  const cb = (e)=>{
-    output += e;
-  };
-
   const ac = new AbortController();
   const signal = ac.signal;
 
@@ -59,22 +63,51 @@ async function canConnect(hostInfo, timeout = 60) {
       }
     });
 
-  debugVerbose(`canConnect: ${sshCmd} ${args.join(" ")}`);
-  const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, cb), hostInfo);
-  ac.abort();
-
-  if (rt !== 0) {
-    const err = new Error(`can not connect to ${hostInfo.host}. return code=${rt}`);
-    err.rt = rt;
-    err.host = hostInfo.host;
-    err.user = hostInfo.user;
-    err.port = hostInfo.port;
-    return err;
+  if (await existsMaster(hostInfo)) {
+    const words = crypto.randomUUID();
+    const args = getSshOption(hostInfo);
+    if (Number.isInteger(timeout) && timeout > 0) {
+      args.push(`-oConnectTimeout=${timeout}`);
+    }
+    args.push(`echo ${words}`);
+    let output = "";
+    const cb = (e)=>{
+      output += e;
+    };
+
+    debugVerbose(`canConnect: ${sshCmd} ${args.join(" ")}`);
+    const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, cb), hostInfo);
+    ac.abort();
+
+    if (rt !== 0) {
+      const err = new Error(`can not connect to ${hostInfo.host}. return code=${rt}`);
+      err.rt = rt;
+      err.host = hostInfo.host;
+      err.user = hostInfo.user;
+      err.port = hostInfo.port;
+      return err;
+    }
+    const re = new RegExp(words);
+    if (!re.test(output)) {
+      throw new Error("can not get echo result correctly");
+    }
+    return true;
   }
-  const re = new RegExp(words);
-  return re.test(output);
+  //do NOT catch following try
+  //if connect throw error, canConnect must be throw error
+  try {
+    await connect(hostInfo);
+  } finally {
+    ac.abort();
+  }
+  return true;
 }
 
+/**
+ * check if master session exists or not
+ * @param {Object} hostInfo - hostinfo object
+ * @returns {boolean} - true if master session exists
+ */
 async function existsMaster(hostInfo) {
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
@@ -84,10 +117,10 @@ async function existsMaster(hostInfo) {
     output += e;
   };
   try {
-    debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
+    debug(`check master session: ${sshCmd} ${args.join(" ")}`);
     await fork(hostInfo, sshCmd, args, cb);
   } catch (err) {
-    if (err !== 255 || !/Control socket connect.*: No such file or directory/.test(output)) {
+    if (err.rt !== 255) {
       throw err;
     }
   }
@@ -96,6 +129,7 @@ async function existsMaster(hostInfo) {
 
 /**
  * create master ssh connection
+ * @param {Object} hostInfo - hostinfo object
  */
 async function connect(hostInfo) {
   if (await existsMaster(hostInfo)) {
@@ -110,13 +144,11 @@ async function connect(hostInfo) {
   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();
+      debugVerbose(output);
+
       if (re.test(output)) {
         debug("call exit on remotehost");
         pty.write("exit\n");
@@ -131,8 +163,17 @@ async function connect(hostInfo) {
         reject(new Error("Operation timed out"));
       }
     });
-    pty.onExit(reject);
+    pty.onExit((e)=>{
+      debug("master pty exit", e);
+      resolve(e);
+    });
   });
+
+  const args = getSshOption(hostInfo);
+  args.push(`echo ${words}`);
+  const cmd = `${sshCmd} ${args.join(" ")}\n`;
+  debugVerbose(cmd);
+  pty.write(cmd);
   await p;
   debug(`connected to ${hostInfo.host}`);
 }
@@ -142,20 +183,29 @@ async function connect(hostInfo) {
  * @param {Object} hostInfo - hostinfo object
  */
 async function disconnect(hostInfo) {
-  const args = getSshOption(hostInfo);
-  args.push("-Oexit");
+  if (await existsMaster(hostInfo)) {
+    const args = getSshOption(hostInfo);
+    args.push("-Oexit");
 
-  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)) {
+    let output = "";
+    const cb = (e)=>{
+      output += e;
+    };
+    try {
+      debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
+      await fork(hostInfo, sshCmd, args, cb);
+    } catch (err) {
+      if (err.rt === 255) {
+        return;
+      }
+      if (/Control socket connect.*: No such file or directory/.test(output)) {
+        return;
+      }
       throw err;
     }
+    debug(`disconnected from ${hostInfo.host}`);
+  } else {
+    debug(`disconnect: master session to ${hostInfo.host} does not exist`);
   }
 
   if (hostInfo.masterPty) {
@@ -163,7 +213,33 @@ async function disconnect(hostInfo) {
     hostInfo.masterPty.write("exit \n");
     hostInfo.masterPty = null;
   }
-  debug(`disconnected from ${hostInfo.host}`);
+}
+
+/**
+ * execute ls command and return output
+ * @param {Object} hostInfo - hostinfo object
+ * @param {string} target - file or directory path to watch
+ * @param {string[]} lsOpt - optional arguments for ls
+ * @returns {string[]} - output from ls
+ */
+async function ls(hostInfo, target, lsOpt = []) {
+  const outputArray = [];
+  try {
+    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, (data)=>{
+      outputArray.push(data);
+    });
+  } catch (e) {
+    //non-zero retrun should be allowed
+    if (typeof e.rt === "undefined" || e.rt < 0) {
+      throw e;
+    }
+  }
+
+  return outputArray
+    .join("\n")
+    .replace(/\n+/g, "\n")
+    .replace(/\n$/, "")
+    .split("\n");
 }
 
 /**
@@ -192,5 +268,6 @@ module.exports = {
   canConnect,
   connect,
   disconnect,
+  ls,
   retryWrapper
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",

package/test/rsyncExec.js

@@ -63,9 +63,7 @@ describe("test rsync exec", function() {
       await clearRemoteTestFiles(hostInfo);
       await clearLocalTestFiles();
     }
-    after(async ()=>{
-      await disconnect(hostInfo);
-    });
+    await disconnect(hostInfo);
   });
   describe("#send", async ()=>{
     describe("send single file", ()=>{

package/test/sshExec.js

@@ -1,4 +1,5 @@
 "use strict";
+const path = require("path");
 
 process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
 Error.traceLimit = 100000;
@@ -13,19 +14,23 @@ chai.use(require("chai-as-promised"));
 const sshout = sinon.stub();
 
 //testee
-const { sshExec, canConnect, disconnect } = require("../lib/sshExec.js");
+const { sshExec, canConnect, disconnect, ls } = require("../lib/sshExec.js");
 
 //test helpers
-let hostInfo = require("./util/hostInfo.js");
-const { nonExisting } = require("./util/testFiles.js");
+const hostInfo = require("./util/hostInfo.js");
+const { clearRemoteTestFiles, createRemoteFiles, nonExisting, remoteRoot } = require("./util/testFiles.js");
 
 
 describe("test for ssh execution", function() {
   this.timeout(20000);//eslint-disable-line no-invalid-this
-  beforeEach(()=>{
+  beforeEach(async ()=>{
     sshout.reset();
+    await clearRemoteTestFiles(hostInfo);
   });
   after(async ()=>{
+    if (!process.env.TEST_KEEP_FILES) {
+      await clearRemoteTestFiles(hostInfo);
+    }
     await disconnect(hostInfo);
   });
   describe("#exec", ()=>{
@@ -58,44 +63,71 @@ describe("test for ssh execution", function() {
     });
   });
   describe("#canConnect", ()=>{
-    let hostInfoBak;
+    let hostInfo2;
     beforeEach(async ()=>{
       await disconnect(hostInfo);
-      hostInfo.masterPty = null;
-      hostInfoBak = { ...hostInfo };
+      hostInfo2 = { ...hostInfo };
+      hostInfo2.masterPty = null;
     });
-    afterEach(()=>{
-      const masterPty = hostInfo.masterPty;
-      hostInfo = { ...hostInfoBak };
-      hostInfo.masterPty = masterPty;
+    afterEach(async ()=>{
+      await disconnect(hostInfo2);
     });
     it("should be resolved with true", async ()=>{
-      expect(await canConnect(hostInfo, 2)).to.be.true;
+      expect(await canConnect(hostInfo2, 2)).to.be.true;
     });
     it("should be rejected if user does not exist", async ()=>{
-      hostInfo.user = "xxxx";
-      return expect(canConnect(hostInfo, 2)).to.be.rejected;
+      hostInfo2.user = "xxxx";
+      return expect(canConnect(hostInfo2, 2)).to.be.rejected;
     });
     it("should be rejected if password is wrong", async ()=>{
-      hostInfo.password = "xxxx";
-      return expect(canConnect(hostInfo, 2)).to.be.rejected;
+      hostInfo2.password = "xxxx";
+      return expect(canConnect(hostInfo2, 2)).to.be.rejected;
     });
     it("should be rejected if host does not exist", async ()=>{
-      hostInfo.host = "foo.bar.example.com";
-      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
+      hostInfo2.host = "foo.bar.example.com";
+      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
     });
     it("should be rejected if host(ip address) does not exist", async ()=>{
-      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);
+      hostInfo2.host = "192.0.2.1";
+      hostInfo2.ConnectTimeout = 8; //please note each test will be timed out in 20 seconds
+      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
     });
     it("should be rejected if port number is out of range(-1)", async ()=>{
-      hostInfo.port = -1;
-      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
+      hostInfo2.port = -1;
+      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
     });
     it("should be rejected if port number is out of range(65536)", async ()=>{
-      hostInfo.port = 65536;
-      return expect(canConnect(hostInfo, 2)).to.be.rejectedWith(255);
+      hostInfo2.port = 65536;
+      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
+    });
+  });
+  describe("#ls", ()=>{
+    beforeEach(async ()=>{
+      await createRemoteFiles(hostInfo);
+    });
+    it("should return array of file and directory names in the specified directory", async ()=>{
+      expect(await ls(hostInfo, remoteRoot)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
+    });
+    it("should return array which has only specified file", async ()=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "foo"))).to.eql([path.posix.join(remoteRoot, "foo")]);
+    });
+    it("should return 'No such file or directory' if non-existing path is specified", async ()=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, nonExisting))).to.match(/No such file or directory/);
+    });
+    it("should return only matched filenames, if glob is specified", async ()=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "b*"))).to.have.members(["bar", "baz"].map((e)=>{
+        return path.posix.join(remoteRoot, e);
+      }));
+    });
+    it("should return only matched filenames src contains multipl glob pattern", async ()=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "h*", "p[iu]yo"))).to.have.members(["piyo", "puyo"].map((e)=>{
+        return path.posix.join(remoteRoot, "hoge", e);
+      }));
+    });
+    it("should return only matched filenames, if specified glob contains /", async ()=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "hoge/*yo"))).to.have.members(["piyo", "puyo", "poyo"].map((e)=>{
+        return path.posix.join(remoteRoot, "hoge", e);
+      }));
     });
   });
 });