ssh-client-wrapper 2.0.2 → 2.2.0

package/.dockerignore

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

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

@@ -1,7 +1,6 @@
 "use strict";
 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");
 
@@ -13,45 +12,53 @@ const nodePtyOpt = {
 };
 
 function sshLoginCallback(output, ptyProcess, pw, ph, logger = debugSendPty) {
-  if (reNewHostPrompt.test(output)) {
-    sendPty(ptyProcess, "yes\n", logger, 17);
-    return;
-  }
-  if (rePwPrompt.test(output)) {
-    if (typeof pw === "string") {
-      debug("use given password");
-      sendPty(ptyProcess, `${pw}\n`, logger, 23);
-      return;
-    }
-    if (typeof pw === "function") {
-      debug("call password callback function");
-      pw()
-        .then((v)=>{
-          sendPty(ptyProcess, `${v}\n`, logger, 30);
-        });
-      return;
+  return new Promise((resolve, reject)=>{
+    if (reNewHostPrompt.test(output)) {
+      sendPty(ptyProcess, "yes\n", logger, 17);
+      resolve();
     }
-  }
-  if (rePhPrompt.test(output)) {
-    if (typeof ph === "string") {
-      debug("use given passphrase");
-      sendPty(ptyProcess, `${ph}\n`, logger, 38);
-      return;
+    if (rePwPrompt.test(output)) {
+      if (typeof pw === "string") {
+        debug("use given password");
+        sendPty(ptyProcess, `${pw}\n`, logger, 23);
+        resolve();
+      }
+      if (typeof pw === "function") {
+        debug("call password callback function");
+        pw()
+          .then((v)=>{
+            sendPty(ptyProcess, `${v}\n`, logger, 30);
+          })
+          .catch((e)=>{
+            reject(e);
+          });
+        resolve();
+      }
     }
-    if (typeof ph === "function") {
-      debug("call passphrase callback function");
-      ph()
-        .then((v)=>{
-          sendPty(ptyProcess, `${v}\n`, logger, 45);
-        });
+    if (rePhPrompt.test(output)) {
+      if (typeof ph === "string") {
+        debug("use given passphrase");
+        sendPty(ptyProcess, `${ph}\n`, logger, 38);
+        resolve();
+      }
+      if (typeof ph === "function") {
+        debug("call passphrase callback function");
+        ph()
+          .then((v)=>{
+            sendPty(ptyProcess, `${v}\n`, logger, 45);
+          })
+          .catch((e)=>{
+            reject(e);
+          });
+      }
     }
-  }
+  });
 }
 
 /**
  * create pty for master ssh session and store to hostInfo.masterPty
  */
-function getMasterPty(hostInfo, logger) {
+function createMastePty(hostInfo) {
   debug("fork pty for master connection");
 
   if (hostInfo.masterPty) {
@@ -59,11 +66,6 @@ function getMasterPty(hostInfo, logger) {
     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, logger);
-  });
   hostInfo.masterPty = ptyProcess;
 }
 
@@ -81,17 +83,21 @@ async function fork(hostInfo, cmd, args, timeout, outputCallback) {
       });
     }
     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(async (data)=>{
+        const output = data.toString();
+        sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase)
+          .catch(reject);
+
+        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));
@@ -119,5 +125,6 @@ async function fork(hostInfo, cmd, args, timeout, outputCallback) {
 }
 module.exports = {
   fork,
-  getMasterPty
+  createMastePty,
+  sshLoginCallback
 };

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

@@ -5,7 +5,7 @@ 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");
+const { fork, createMastePty, sshLoginCallback } = require("./fork.js");
 
 /**
  * Execute command on remote host.
@@ -103,7 +103,7 @@ async function connect(hostInfo, timeout = 60) {
   }
 
   debug(`create master pty for ${hostInfo.host}`);
-  getMasterPty(hostInfo, debugSendMasterPty);
+  createMastePty(hostInfo, debugSendMasterPty);
 
   debug(`create master ssh session to ${hostInfo.host}`);
 
@@ -146,6 +146,11 @@ async function connect(hostInfo, timeout = 60) {
         reject(new Error("Operation timed out"));
       }
     });
+    hostInfo.masterPty.onData((data)=>{
+      const output = data.toString();
+      sshLoginCallback(output, hostInfo.masterPty, hostInfo.password, hostInfo.passphrase, debugSendMasterPty)
+        .catch(reject);
+    });
     hostInfo.masterPty.onExit((e)=>{
       debug("master pty exit", e);
       resolve(e);

package/package.json

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