ssh-client-wrapper 1.0.9 → 1.2.1

package/lib/fork.js

@@ -15,8 +15,8 @@ async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
   return new Promise((resolve, reject)=>{
     const opt = argOpt || defaultOpt;
 
-    const ptyProcess = spawn(cmd, args, opt);
     debug(`cmd=${cmd}: args=${args}`);
+    const ptyProcess = spawn(cmd, args, opt);
     ptyProcess.onData(buff2String.bind(null, debugVerbose));
 
     ptyProcess.onData((data)=>{
@@ -31,7 +31,10 @@ async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
           debugSendPty(hostInfo.password);
           ptyProcess.write(`${hostInfo.password}\n`);
         } else if (typeof hostInfo.password === "function") {
-          hostInfo.password(ptyProcess.write);
+          hostInfo.password()
+            .then((pw)=>{
+              ptyProcess.write(`${pw}\n`);
+            });
         }
       }
       if (rePhPrompt.test(output)) {
@@ -39,7 +42,10 @@ async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
           debugSendPty(hostInfo.passphrase);
           ptyProcess.write(`${hostInfo.passphrase}\n`);
         } else if (typeof hostInfo.passphrase === "function") {
-          hostInfo.passphrase(ptyProcess.write);
+          hostInfo.passphrase()
+            .then((pw)=>{
+              ptyProcess.write(`${pw}\n`);
+            });
         }
       }
     });

package/lib/index.js

@@ -83,17 +83,23 @@ class SshClientWrapper {
    * @param {[string]} opt - option for rsync
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async send(src, dst, opt = {}) {
-    debug("send called", src, dst);
+  async send(src, dst, opt) {
+    debug("send called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
-      return new Error("src must be array of string");
+      const err = "src must be array of string";
+      debug(err);
+      return new Error(err);
     }
     if (typeof dst !== "string") {
-      return new Error("dst must be string");
+      const err = "dst must be string";
+      debug(err);
+      return new Error(err);
     }
-    if (!isArrayOfString(opt)) {
-      return new Error("opt must be array of string");
+    if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
+      const err = "opt must be array of string";
+      debug(err);
+      return new Error(err);
     }
     return send(this.hostInfo, src, dst, opt);
   }
@@ -105,19 +111,24 @@ class SshClientWrapper {
    * @param {[string]} opt - option for rsync
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async recv(src, dst, opt = {}) {
-    debug("recv called", src, dst);
+  async recv(src, dst, opt) {
+    debug("recv called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
-      return new Error("src must be array of string");
+      const err = "src must be array of string";
+      debug(err);
+      return new Error(err);
     }
     if (typeof dst !== "string") {
-      return new Error("dst must be string");
+      const err = "dst must be string";
+      debug(err);
+      return new Error(err);
     }
-    if (!isArrayOfString(opt)) {
-      return new Error("opt must be array of string");
+    if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
+      const err = "opt must be array of string";
+      debug(err);
+      return new Error(err);
     }
-
     return recv(this.hostInfo, src, dst, opt);
   }
 

package/lib/rsyncExec.js

@@ -16,7 +16,7 @@ const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
  *
- * this function execute rsync -avvm --copy-unsafe-links  src rsync://[user@]host[:port]/dst
+ * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
 async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
   const promises = await Promise.allSettled(argSrc.map((e)=>{
@@ -32,8 +32,10 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
   const sshArgs = getSshOption(hostInfo, true);
   const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
 
-  const args = ["-amvv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, ...src, `${hostInfo.host}:${dst}`];
+  const args = ["-avv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, ...src, `${hostInfo.host}:${dst}`];
   const { dir: remoteDir } = path.parse(dst);
+  debug("remoteDir=", remoteDir);
+
   if (remoteDir !== "" && remoteDir !== "/") {
     debug(`mkdir ${remoteDir}`);
     sshExec(hostInfo, `mkdir -p ${remoteDir}`, debugVerbose);
@@ -57,7 +59,7 @@ async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
   const sshArgs = getSshOption(hostInfo, true);
   const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
 
-  const args = ["-amvv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, src, dst];
+  const args = ["-avv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, src, dst];
 
   debug(`recv ${src} to ${dst}`);
   debugVerbose(`rsyncCmd=${rsyncCmd}: args=${args}`);

package/lib/sshExec.js

@@ -1,4 +1,5 @@
 "use strict";
+const { setTimeout: setTimeoutPromise } = require("timers/promises");
 const crypto = require("crypto");
 const debug = require("debug")("sshClientWrapper:sshExec");
 const { sshCmd, getSshOption } = require("./util.js");
@@ -23,12 +24,12 @@ 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 = 5) {
   debug("check connectibity");
   const words = crypto.randomUUID();
   const args = getSshOption(hostInfo);
   if (Number.isInteger(timeout) && timeout > 0) {
-    args.push(`-OConnectTimeout=${timeout}`);
+    args.push(`-oConnectTimeout=${timeout}`);
   }
   args.push(`echo ${words}`);
 
@@ -36,7 +37,35 @@ async function canConnect(hostInfo, timeout) {
   const cb = (e)=>{
     output += e;
   };
-  await fork(hostInfo, sshCmd, args, null, cb);
+
+  const ac = new AbortController();
+  const signal = ac.signal;
+
+  setTimeoutPromise(timeout * 1000, "foobar", { signal })
+    .then(()=>{
+      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");
+      }
+    });
+
+  const rt = await fork(hostInfo, sshCmd, args, null, cb);
+  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);
   return re.test(output);
 }

package/lib/util.js

@@ -50,7 +50,7 @@ const getSshOption = (hostInfo, withoutDestination)=>{
   }
   const renewInterval = Number.isInteger(hostInfo.renewInterval) && hostInfo.renewInterval > 0 ? hostInfo.renewInterval : 180;
   args.push("-oControlMaster=auto");
-  args.push("-oControlPath=~/.ssh/wheel-%r@%h:%p");
+  args.push("-oControlPath=~/.ssh/ssh-client-wrapper-%r@%h:%p");
   args.push(`-oControlPersist=${renewInterval}`);
   return args;
 };
@@ -72,7 +72,8 @@ const isArrayOfString = (target)=>{
   if (!Array.isArray(target)) {
     return false;
   }
-  return target.some((e)=>{
+  return !target.some((e)=>{
+    //target has non string member
     return typeof e !== "string";
   });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "1.0.9",
+  "version": "1.2.1",
   "description": "wrapper library for open ssh client and rsync",
   "main": "lib/index.js",
   "scripts": {

package/test/rsyncExec.js

@@ -154,7 +154,7 @@ describe("test rsync exec", function() {
         await send(hostInfo, [localRoot], remoteEmptyDir);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
@@ -164,7 +164,7 @@ describe("test rsync exec", function() {
         await send(hostInfo, [path.resolve(localRoot)], remoteEmptyDir);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
@@ -174,7 +174,7 @@ describe("test rsync exec", function() {
         await send(hostInfo, [localRoot], path.posix.join(remoteHome, remoteEmptyDir));
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
@@ -184,7 +184,7 @@ describe("test rsync exec", function() {
         await send(hostInfo, [path.resolve(localRoot)], path.posix.join(remoteHome, remoteEmptyDir));
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
@@ -205,7 +205,7 @@ describe("test rsync exec", function() {
         await send(hostInfo, [localRoot], remoteEmptyDir, ["--exclude=ba*", "--exclude=hoge*}"]);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "hoge"]);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "hoge", "huga"]);
       });
       it.skip("[not implemented] should send directory tree if only filter matched but exclude filter not matched", async ()=>{
         await send(hostInfo, [localRoot], remoteEmptyDir, "*/{ba*,hoge/*}", "**/poyo");
@@ -217,8 +217,8 @@ describe("test rsync exec", function() {
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
         expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo"]);
       });
-      it("shoud not send empty directory", async ()=>{
-        await send(hostInfo, [localEmptyDir], remoteEmptyDir);
+      it("shoud not send empty directory with -m option", async ()=>{
+        await send(hostInfo, [localEmptyDir], remoteEmptyDir, ["-m"]);
 
         await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
         expect(rt).to.have.lengthOf(0);
@@ -318,7 +318,7 @@ describe("test rsync exec", function() {
         await recv(hostInfo, [remoteRoot], localEmptyDir);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
         rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
         expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
       });
@@ -326,7 +326,7 @@ describe("test rsync exec", function() {
         await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], localEmptyDir);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
         rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
         expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
       });
@@ -334,7 +334,7 @@ describe("test rsync exec", function() {
         await recv(hostInfo, [remoteRoot], path.resolve(localEmptyDir));
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
         rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
         expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
       });
@@ -342,7 +342,7 @@ describe("test rsync exec", function() {
         await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], path.resolve(localEmptyDir));
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
         rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
         expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
       });
@@ -358,7 +358,7 @@ describe("test rsync exec", function() {
         await recv(hostInfo, [remoteRoot], localEmptyDir, ["--exclude=*/ba*", "--exclude=hoge"]);
 
         const rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo"]);
+        expect(rt2).to.have.members(["foo", "huga"]);
       });
       it.skip("[not implemented] should recv files which matches only filter but should not recv which matches exclude filter", async ()=>{
         await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", "**/piyo");

package/test/sshExec.js

@@ -68,11 +68,11 @@ describe("test for ssh execution", function() {
     });
     it("should be rejected if user does not exist", async ()=>{
       hostInfo2.user = "xxxx";
-      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+      return expect(canConnect(hostInfo2)).to.be.rejected;
     });
     it("should be rejected if password is wrong", async ()=>{
       hostInfo2.password = "xxxx";
-      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+      return expect(canConnect(hostInfo2)).to.be.rejected;
     });
     it("should be rejected if host does not exist", async ()=>{
       hostInfo2.host = "foo.bar.example.com";
@@ -80,7 +80,7 @@ describe("test for ssh execution", function() {
     });
     it("should be rejected if host(ip address) does not exist", async ()=>{
       hostInfo2.host = "192.0.2.1";
-      return expect(canConnect(hostInfo2, 5)).to.be.rejectedWith(255);
+      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
     });
     it("should be rejected if port number is out of range(-1)", async ()=>{
       hostInfo2.port = -1;