ssh-client-wrapper 1.1.0 → 1.2.1

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,7 +32,7 @@ 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);
 
@@ -59,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,7 +24,7 @@ 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);
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "1.1.0",
+  "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;