ssh-client-wrapper 2.0.1 → 2.1.1

package/.dockerignore

@@ -0,0 +1 @@
+node_modules

package/.github/workflows/coverage_report.yml

@@ -4,6 +4,8 @@ on:
     tags:
       - 'v*'
 jobs:
+  test:
+    uses: ./.github/workflows/run_test.yml
   coverage:
     needs:
       - test

package/Dockerfile

@@ -0,0 +1,10 @@
+# syntax=docker/dockerfile:1
+#build WHEEL client code
+FROM --platform=linux/amd64 node:hydrogen-bookworm-slim
+#FROM --platform=linux/amd64 node:hydrogen-bullseye-slim
+#FROM --platform=linux/amd64 node:hydrogen-buster-slim
+
+WORKDIR /work
+RUN apt-get update && apt -y install ssh rsync bzip2 python3 g++ build-essential
+COPY ./ ssh-client-wrapper
+RUN cd  ssh-client-wrapper && npm install

package/docker-compose.yml

@@ -0,0 +1,17 @@
+version: "3.8"
+services:
+  test-bed:
+    image: naoso5/test-sshd
+    ports:
+      - 4000:22
+    container_name: testbed
+  tester:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    environment:
+      TEST_USER: testuser
+      TEST_PW: passw0rd
+      TEST_HOST: testbed
+    working_dir: /work/ssh-client-wrapper
+    command: bash -c "mkdir /root/.ssh 2>/dev/null; npm run test"

package/lib/fork.js

@@ -75,21 +75,26 @@ async function fork(hostInfo, cmd, args, timeout, outputCallback) {
     if (timeout > 0) {
       ac = watchDogTimer(timeout, cmd, ()=>{
         ptyProcess.kill();
-        reject(new Error(`watchdog timer expired ${timeout}`));
+        const err = new Error(`watchdog timer expired ${timeout}`);
+        err.code = "TIMEEXPIRE";
+        reject(err);
       });
     }
     ptyProcess.onData(buff2String.bind(null, debugVerbose));
-    ptyProcess.onData((data)=>{
-      const output = data.toString();
-      sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase);
 
-      if (/kex_exchange_identification: Connection closed by remote host/.test(output)) {
-        ptyProcess.kill();
-        const err = new Error("kex_exchange_identification");
-        err.retryable = true;
-        reject(err);
-      }
-    });
+    if (hostInfo !== null) {
+      ptyProcess.onData((data)=>{
+        const output = data.toString();
+        sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase);
+
+        if (/kex_exchange_identification: Connection closed by remote host/.test(output)) {
+          ptyProcess.kill();
+          const err = new Error("kex_exchange_identification");
+          err.retryable = true;
+          reject(err);
+        }
+      });
+    }
 
     if (typeof outputCallback === "function") {
       ptyProcess.onData(buff2String.bind(null, outputCallback));

package/lib/index.js

@@ -1,4 +1,6 @@
 "use strict";
+const fs = require("fs");
+const path = require("path");
 const debug = require("debug")("sshClientWrapper:interface");
 const debugVerbose = require("debug")("sshClientWrapper:verbose:interface");
 const { sshExec, canConnect, disconnect, ls } = require("./sshExec.js");
@@ -46,6 +48,17 @@ class SshClientWrapper {
     sanityCheck(hostInfo);
     this.hostInfo = { ...hostInfo };
     this.hostInfo.masterPty = null;
+    this.hostInfo.rsyncVersion = null;
+
+    if (process.env.HOME) {
+      try {
+        fs.mkdirSync(path.resolve(process.env.HOME, ".ssh"));
+      } catch (e) {
+        if (e.code !== "EEXIST") {
+          throw e;
+        }
+      }
+    }
   }
 
   /**

package/lib/rsyncExec.js

@@ -9,6 +9,19 @@ const { fork } = require("./fork.js");
 
 const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
 
+async function checkRsyncVersion(timeout) {
+  const rt = {};
+  await fork(null, rsyncCmd, ["--version"], timeout, (output)=>{
+    const result = /^rsync *version *(\d+)\.(\d+)\.(\d+).*$/m.exec(output);
+
+    if (result) {
+      rt.major = Number(result[1]);
+      rt.minor = Number(result[2]);
+      rt.patch = Number(result[3]);
+    }
+  });
+  return rt;
+}
 
 /**
  * Send file or directory and its child to server.
@@ -69,6 +82,21 @@ async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout), hostInfo);
 }
 
+/**
+ * format src array to src string for recv
+ * @param {Object} hostInfo - hostinfo object
+ * @returns {boolean} - rsync command version is higher than 3.2.4 or not
+ */
+async function isNewRsync(hostInfo) {
+  if (!hostInfo.rsyncVersion ||
+    !Number.isInteger(hostInfo.rsyncVersion.major) ||
+    !Number.isInteger(hostInfo.rsyncVersion.minor) ||
+    !Number.isInteger(hostInfo.rsyncVersion.patch)) {
+    hostInfo.rsyncVersion = await checkRsyncVersion(3);
+  }
+  return hostInfo.rsyncVersion.major >= 3 && hostInfo.rsyncVersion.minor >= 2 && hostInfo.rsyncVersion.patch >= 4;
+}
+
 /**
  * Send file or directory and its child to server.
  * @param {Object} hostInfo - hostinfo object
@@ -84,14 +112,17 @@ async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
   const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
-
   const args = ["-avv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, src, dst];
+  if (await isNewRsync(hostInfo)) {
+    args.unshift("--old-args");
+  }
 
   debug(`recv ${src} to ${dst}`);
   debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
   return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout), hostInfo);
 }
 module.exports = {
+  checkRsyncVersion,
   send,
   recv
 };

package/lib/sshExec.js

@@ -64,7 +64,7 @@ async function canConnect(hostInfo, timeout = 60) {
  * @param {Object} hostInfo - hostinfo object
  * @returns {boolean} - true if master session exists
  */
-async function existsMaster(hostInfo) {
+async function existsMaster(hostInfo, argTimeout) {
   debugVerbose("existsMaster called");
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
@@ -74,20 +74,22 @@ async function existsMaster(hostInfo) {
     output += e;
   };
 
-  const rt = true; //if timeout occurred during ssh -Ocheck, it will turn to false
-  const timeout = hostInfo.ConnectTimeout || 60;
+  const timeout = argTimeout || hostInfo.ConnectTimeout || 60;
   debug(`check master session: ${sshCmd} ${args.join(" ")}`);
 
   try {
     await fork(hostInfo, sshCmd, args, timeout, cb);
   } catch (err) {
+    if (err.code === "TIMEEXPIRE") {
+      return false;
+    }
     if (err.rt !== 255) {
       debug("check master session failed", err);
       throw err;
     }
   }
 
-  return rt && !/Control socket connect.*: No such file or directory/.test(output);
+  return !/Control socket connect.*: No such file or directory/.test(output);
 }
 
 /**
@@ -95,7 +97,7 @@ async function existsMaster(hostInfo) {
  * @param {Object} hostInfo - hostinfo object
  */
 async function connect(hostInfo, timeout = 60) {
-  if (await existsMaster(hostInfo)) {
+  if (await existsMaster(hostInfo, timeout)) {
     debugVerbose("master connection exists");
     return;
   }
@@ -105,20 +107,22 @@ async function connect(hostInfo, timeout = 60) {
 
   debug(`create master ssh session to ${hostInfo.host}`);
 
-  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;
-  });
-
   const words = crypto.randomUUID();
   const re = new RegExp(`^${words}`);
+
+  let ac = null;
   const p = new Promise((resolve, reject)=>{
+    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;
+      reject(err);
+    });
+
     let done = false;
     hostInfo.masterPty.onData((data)=>{
       if (done) {
@@ -157,7 +161,9 @@ async function connect(hostInfo, timeout = 60) {
     await p;
     debug(`connected to ${hostInfo.host}`);
   } finally {
-    ac.abort();
+    if (ac !== null) {
+      ac.abort();
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "debug": "^4.3.4",
-    "glob": "^10.3.3",
+    "glob": "^10.3.4",
     "node-pty": "^0.10.1",
     "nyc": "^15.1.0",
     "promise-retry": "^2.0.1",

package/test/interface.js

@@ -56,7 +56,7 @@ describe("test for interface", ()=>{
   describe("test for public method", ()=>{
     let ssh;
     const hostInfoOrg = { host: "hoge" };
-    const hostInfo = { ...hostInfoOrg, masterPty: null };
+    const hostInfo = { ...hostInfoOrg, masterPty: null, rsyncVersion: null };
     beforeEach(()=>{
       ssh = new SshClientWrapper(hostInfoOrg);
       sshExec.reset();

package/test/rsyncExec.js

@@ -1,6 +1,18 @@
 "use strict";
 const fs = require("fs-extra");
 const path = require("path");
+const util = require("util");
+const exec = util.promisify(require("node:child_process").exec);
+
+/**
+ * to enable debug log dynamically
+ * (1) enable folloing line
+ *          const debug = require("debug");
+ * (2) insert this line into the beginning of it()
+ *         debug.enable("ssh*");
+ * (3) insert this line into the end of it()
+ *         debug.disable();
+ **/
 
 process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
 Error.traceLimit = 100000;
@@ -12,7 +24,7 @@ chai.use(require("chai-fs"));
 chai.use(require("chai-as-promised"));
 
 //testee
-const { send, recv } = require("../lib/rsyncExec.js");
+const { checkRsyncVersion, send, recv } = require("../lib/rsyncExec.js");
 
 //test helpers
 const { sshExec, disconnect } = require("../lib/sshExec.js");
@@ -42,6 +54,14 @@ const formatLsOutput = (array)=>{
 
 
 //actual test start from here
+describe("test checkRsyncVersion", async ()=>{
+  const { major, minor, patch } = await checkRsyncVersion(1);
+  const versionString = `${major}.${minor}.${patch}`;
+  console.log(`==== test with rsync version ${versionString} ====`); //eslint-disable-line no-console
+  const { stdout } = await exec("rsync --version |grep 'version'");
+  expect(stdout).to.match(new RegExp(versionString));
+});
+
 describe("test rsync exec", function() {
   this.timeout(10000);//eslint-disable-line no-invalid-this
   const rt = [];
@@ -370,6 +390,14 @@ describe("test rsync exec", function() {
         expect(rt2).to.have.members(["puyo", "poyo"]);
       });
     });
+    describe("degradation check", ()=>{
+      it("should recieve multiple files from remote machine", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteRoot, "foo"),
+          path.posix.join(remoteRoot, "bar"), path.posix.join(remoteRoot, "baz")], localEmptyDir, [], 0);
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["foo", "bar", "baz"]);
+      });
+    });
     describe("error case", ()=>{
       it("should not send directory to existing file path", ()=>{
         return expect(recv(hostInfo, [remoteRoot], localFiles[0], [], 0)).to.be.rejected;

package/test/sshExec.js

@@ -76,7 +76,7 @@ describe("test for ssh execution", function() {
       await disconnect(hostInfo2);
     });
     it("should be resolved with true", async ()=>{
-      return expect(await canConnect(hostInfo2, 2)).to.be.true;
+      return expect(await canConnect(hostInfo2, 5)).to.be.true;
     });
     it("should be rejected if user does not exist", async ()=>{
       hostInfo2.user = "xxxx";