ssh-client-wrapper 2.2.3 → 2.2.6

package/lib/sshExec.js

@@ -14,7 +14,7 @@ const { fork, createMasterPty, sshLoginCallback } = require("./fork.js");
  * @param {number} timeout - timeout (in sec.)
  * @param {Function} outputCallback - Callback routine for stdout and stderr.
  */
-async function sshExec(hostInfo, cmd, timeout, outputCallback) {
+async function sshExec (hostInfo, cmd, timeout, outputCallback) {
   debug("sshExec called");
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
@@ -46,14 +46,14 @@ async function sshExec(hostInfo, cmd, timeout, outputCallback) {
  * @param {Object} hostInfo - hostinfo object
  * @param {Integer} timeout - timeout in secconds
  */
-async function canConnect(hostInfo, timeout = 60) {
+async function canConnect (hostInfo, timeout = 60) {
   debug("canConnect called");
   sanityCheck(hostInfo);
 
   await connect(hostInfo, timeout);
   await disconnect(hostInfo);
-  //if connection fail, Error is throwed.
-  //so, if we reach here, connection must be succeeded
+  // if connection fail, Error is throwed.
+  // so, if we reach here, connection must be succeeded
   return true;
 }
 
@@ -62,13 +62,13 @@ async function canConnect(hostInfo, timeout = 60) {
  * @param {Object} hostInfo - hostinfo object
  * @returns {boolean} - true if master session exists
  */
-async function existsMaster(hostInfo, argTimeout) {
+async function existsMaster (hostInfo, argTimeout) {
   debugVerbose("existsMaster called");
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
 
   let output = "";
-  const cb = (e)=>{
+  const cb = (e) => {
     output += e;
   };
 
@@ -94,7 +94,7 @@ async function existsMaster(hostInfo, argTimeout) {
  * create master ssh connection
  * @param {Object} hostInfo - hostinfo object
  */
-async function connect(hostInfo, timeout = 60) {
+async function connect (hostInfo, timeout = 60) {
   debug("connect called");
 
   if (await existsMaster(hostInfo, timeout)) {
@@ -110,8 +110,8 @@ async function connect(hostInfo, timeout = 60) {
   const re = new RegExp(`^${words}`);
 
   let ac = null;
-  const p = new Promise((resolve, reject)=>{
-    ac = watchDogTimer(timeout, "make connection", ()=>{
+  const p = new Promise((resolve, reject) => {
+    ac = watchDogTimer(timeout, "make connection", () => {
       sendPty(hostInfo.masterPty, "\n", debugSendMasterPty, 137);
       sendPty(hostInfo.masterPty, "exit\n", debugSendMasterPty, 138);
 
@@ -123,9 +123,9 @@ async function connect(hostInfo, timeout = 60) {
     });
 
     let done = false;
-    hostInfo.masterPty.onData((data)=>{
+    hostInfo.masterPty.onData((data) => {
       if (done) {
-        //safeguard
+        // safeguard
         return;
       }
       const output = data.toString();
@@ -145,12 +145,12 @@ async function connect(hostInfo, timeout = 60) {
         reject(new Error("Operation timed out"));
       }
     });
-    hostInfo.masterPty.onData((data)=>{
+    hostInfo.masterPty.onData((data) => {
       const output = data.toString();
       sshLoginCallback(output, hostInfo.masterPty, hostInfo.password, hostInfo.passphrase, debugSendMasterPty)
         .catch(reject);
     });
-    hostInfo.masterPty.onExit((e)=>{
+    hostInfo.masterPty.onExit((e) => {
       debug("master pty exit", e);
       resolve(e);
     });
@@ -175,7 +175,7 @@ async function connect(hostInfo, timeout = 60) {
  * remove master session
  * @param {Object} hostInfo - hostinfo object
  */
-async function disconnect(hostInfo) {
+async function disconnect (hostInfo) {
   debug("disconnect called");
 
   if (await existsMaster(hostInfo)) {
@@ -183,7 +183,7 @@ async function disconnect(hostInfo) {
     args.push("-Oexit");
 
     let output = "";
-    const cb = (e)=>{
+    const cb = (e) => {
       output += e;
     };
     try {
@@ -218,20 +218,21 @@ async function disconnect(hostInfo) {
  * @param {number} timeout - timeout (in sec.)
  * @returns {string[]} - output from ls
  */
-async function ls(hostInfo, target, lsOpt, timeout) {
+async function ls (hostInfo, target, lsOpt, timeout) {
   debug("ls called");
   const outputArray = [];
   try {
-    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data)=>{
+    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data) => {
       outputArray.push(data);
     });
   } catch (e) {
-    //non-zero retrun should be allowed
+    // non-zero retrun should be allowed
     if (typeof e.rt === "undefined" || e.rt < 0) {
       throw e;
     }
   }
-  return outputArray.length === 0 ? []
+  return outputArray.length === 0
+    ? []
     : outputArray
       .join("\n")
       .replace(/\n+/g, "\n")
@@ -243,13 +244,13 @@ async function ls(hostInfo, target, lsOpt, timeout) {
  * retry fork() if it throw retryable error
  * @param {Function}  func - function to be wrapped
  */
-async function retryWrapper(func, hostInfo) {
+async function retryWrapper (func, hostInfo) {
   const minTimeout = hostInfo.retryMinTimeout * 1000 || 1000;
   const maxTimeout = hostInfo.retryMaxTimeout * 1000 || 5000;
   const retries = hostInfo.maxRetry || 1;
-  return promiseRetry({ retries, minTimeout, maxTimeout }, (retry, number)=>{
+  return promiseRetry({ retries, minTimeout, maxTimeout }, (retry, number) => {
     return func()
-      .catch((e)=>{
+      .catch((e) => {
         if (e.retryable) {
           debug(`retrying: ${number} times`);
           disconnect(hostInfo).then(retry);
@@ -259,7 +260,6 @@ async function retryWrapper(func, hostInfo) {
   });
 }
 
-
 module.exports = {
   sshExec,
   canConnect,

package/lib/util.js

@@ -25,7 +25,7 @@ const ajv = new Ajv({
 });
 require("ajv-keywords")(ajv, "transform");
 
-//never validate password and passphrase value to avoid security insident
+// never validate password and passphrase value to avoid security insident
 const hostInfoSchema = {
   type: "object",
   properties: {
@@ -64,7 +64,7 @@ const validate = ajv.compile(hostInfoSchema);
  * @param {Function} func - function
  * @param {data} data - binary data which can be converted to string
  */
-const buff2String = (func, data)=>{
+const buff2String = (func, data) => {
   func(data.toString().replace(/\r\n/g, EOL));
 };
 
@@ -72,9 +72,12 @@ const buff2String = (func, data)=>{
  * check if given hostInfo object is OK
  * @param { Object } hostInfo - host information object defined in index.js
  */
-const sanityCheck = (hostInfo)=>{
+const sanityCheck = (hostInfo) => {
   debug("sanityCheck called", hostInfo);
-  //keep password, passphrase, and masterPty
+  // keep password, passphrase, and masterPty before validate.
+  // these properties can have invalid value for JSON.
+  // ajv will remove that at validation pahse becase of additionalProperties setting
+  // so we keep them here and put back later.
   const { password, passphrase, masterPty } = hostInfo;
   validate(hostInfo);
 
@@ -96,7 +99,7 @@ const sanityCheck = (hostInfo)=>{
       }
       if (prop.startsWith("sshOpt")) {
         debug("remove empty member of sshOpt");
-        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt)=>{
+        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt) => {
           return opt !== "";
         });
         continue;
@@ -133,7 +136,7 @@ const sanityCheck = (hostInfo)=>{
  * @param { Object} hostInfo - host information object defined in index.js
  * @param {boolean} withoutDestination - return except for hostname
  */
-const getSshOption = (hostInfo, withoutDestination)=>{
+const getSshOption = (hostInfo, withoutDestination) => {
   debug("getSshOption called");
   const args = [];
 
@@ -186,19 +189,19 @@ const getSshOption = (hostInfo, withoutDestination)=>{
     args.push(`-oConnectTimeout=${hostInfo.ConnectTimeout}`);
   }
   if (Array.isArray(hostInfo.sshOpt)) {
-    args.push(...hostInfo.sshOpt.filter((e)=>{
+    args.push(...hostInfo.sshOpt.filter((e) => {
       return typeof e === "string";
     }));
   }
   return args;
 };
 
-const isArrayOfString = (target)=>{
+const isArrayOfString = (target) => {
   if (!Array.isArray(target)) {
     return false;
   }
-  return !target.some((e)=>{
-    //target has non string member
+  return !target.some((e) => {
+    // target has non string member
     return typeof e !== "string";
   });
 };
@@ -210,7 +213,7 @@ const isArrayOfString = (target)=>{
  * @param {Function} logger - logging function
  * @param {string} label - where this function is called
  */
-const sendPty = async (pty, message, logger, label)=>{
+const sendPty = async (pty, message, logger, label) => {
   logger(`${label}: ${message}`);
   pty.write(message);
 };
@@ -222,15 +225,15 @@ const sendPty = async (pty, message, logger, label)=>{
  * @param {Function} cb - call back function which will be called after timeout
  * @returns {AbortController} - ac to stop watch dog timer
  */
-const watchDogTimer = (timeout, label, cb)=>{
+const watchDogTimer = (timeout, label, cb) => {
   const ac = new AbortController();
   const signal = ac.signal;
   setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(()=>{
+    .then(() => {
       debug(`can not finish ${label} within ${timeout} sec`);
       return typeof cb === "function" ? cb() : true;
     })
-    .catch((err)=>{
+    .catch((err) => {
       if (err.name === "AbortError") {
         debug(`timeout was aborted because ${label} has finished or canceled`);
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.2.3",
+  "version": "2.2.6",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -46,18 +46,19 @@
     "chai-as-promised": "^7.1.1",
     "chai-fs": "^2.0.0",
     "eslint": "^8.38.0",
-    "eslint-config-eslint": "^7.0.0",
+    "eslint-config-standard": "^17.1.0",
     "eslint-plugin-chai-expect": "^3.0.0",
-    "eslint-plugin-chai-friendly": "^0.7.2",
-    "eslint-plugin-jsdoc": "^43.0.6",
-    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-chai-friendly": "^0.7.4",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.1.1",
     "fs-extra": "^11.1.1",
     "husky": "^8.0.0",
     "lint-staged": "^13.2.1",
     "mocha": "^10.2.0",
-    "sinon": "^15.0.3",
-    "rewire": "^7.0.0",
     "nyc": "^15.1.0",
+    "rewire": "^7.0.0",
+    "sinon": "^15.0.3",
     "sinon-chai": "^3.7.0"
   }
 }

package/run_test_all.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+docker-compose up testbed -d
+export TEST_HOST=localhost
+export TEST_USER=testuser
+export TEST_PW=passw0rd
+export TEST_PORT=4000
+npm run test
+docker-compose run --build --rm tester &&
+docker-compose run --build --rm tester-bullseye &&
+docker-compose run --build --rm tester-buster &&
+docker-compose rm --stop --force testbed

package/test/interface.js

@@ -1,8 +1,8 @@
 "use strict";
-process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
 Error.traceLimit = 100000;
 
-//setup test framework
+// setup test framework
 const chai = require("chai");
 const { expect } = require("chai");
 const sinon = require("sinon");
@@ -11,7 +11,7 @@ chai.use(require("chai-as-promised"));
 
 const rewire = require("rewire");
 
-//testee
+// testee
 const SshClientWrapper = rewire("../lib/index.js");
 
 const sshExec = sinon.stub();
@@ -21,39 +21,37 @@ const ls = sinon.stub();
 const send = sinon.stub();
 const recv = sinon.stub();
 
-//eslint-disable-next-line no-underscore-dangle
+// eslint-disable-next-line no-underscore-dangle
 SshClientWrapper.__set__({
   sshExec, canConnect, disconnect, ls, send, recv
 });
 
-
-describe("test for interface", ()=>{
-  describe("test for constructor", ()=>{
-    it("should throw error when instanciate with non-empty string host", ()=>{
-      expect(()=>{
-        //eslint-disable-next-line no-new
+describe("test for interface", () => {
+  describe("test for constructor", () => {
+    it("should throw error when instanciate with non-empty string host", () => {
+      expect(() => {
+        // eslint-disable-next-line no-new
         new SshClientWrapper({});
       }).to.throw("host is required");
-      expect(()=>{
-        //eslint-disable-next-line no-new
+      expect(() => {
+        // eslint-disable-next-line no-new
         new SshClientWrapper({ host: "" });
       }).to.throw("empty host is not allowed");
     });
-    it("should successfully instanciate only with host prop", ()=>{
+    it("should successfully instanciate only with host prop", () => {
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("exec");
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("ls");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("watch");
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("send");
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("recv");
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("canConnect");
       expect(new SshClientWrapper({ host: "hoge" })).to.have.property("disconnect");
     });
   });
-  describe("test for public method", ()=>{
+  describe("test for public method", () => {
     let ssh;
     const hostInfoOrg = { host: "hoge" };
     const hostInfo = { ...hostInfoOrg, masterPty: null, rsyncVersion: null };
-    beforeEach(()=>{
+    beforeEach(() => {
       ssh = new SshClientWrapper(hostInfoOrg);
       sshExec.reset();
       canConnect.reset();
@@ -62,113 +60,113 @@ describe("test for interface", ()=>{
       send.reset();
       recv.reset();
     });
-    describe("test for exec", ()=>{
-      it("should call sshExec with cmd", ()=>{
+    describe("test for exec", () => {
+      it("should call sshExec with cmd", () => {
         ssh.exec("ls");
         expect(sshExec).to.be.calledWith(hostInfo, "ls", 0, null);
       });
-      it("should call sshExec with cmd and timeout", ()=>{
+      it("should call sshExec with cmd and timeout", () => {
         ssh.exec("ls", 10);
         expect(sshExec).to.be.calledWith(hostInfo, "ls", 10, null);
       });
-      it("should call sshExec with cmd, timeout and call back function", ()=>{
-        const cb = ()=>{};
+      it("should call sshExec with cmd, timeout and call back function", () => {
+        const cb = () => {};
         ssh.exec("ls", 10, cb);
         expect(sshExec).to.be.calledWith(hostInfo, "ls", 10, cb);
       });
-      it("should reject if cmd is not string (number)", ()=>{
+      it("should reject if cmd is not string (number)", () => {
         return expect(ssh.exec(0)).to.be.rejectedWith("cmd must be string");
       });
-      it("should reject if cmd is not string (null)", ()=>{
+      it("should reject if cmd is not string (null)", () => {
         return expect(ssh.exec(null)).to.be.rejectedWith("cmd must be string");
       });
-      it("should reject if cmd is empty string", ()=>{
+      it("should reject if cmd is empty string", () => {
         return expect(ssh.exec("")).to.be.rejectedWith("cmd must be string");
       });
     });
-    describe("test for ls", ()=>{
-      it("should call ls without timeout", ()=>{
+    describe("test for ls", () => {
+      it("should call ls without timeout", () => {
         ssh.ls("hoge");
         expect(ls).to.be.calledWith(hostInfo, "hoge", [], 0);
       });
-      it("should call ls with option", ()=>{
+      it("should call ls with option", () => {
         ssh.ls("hoge", ["-l", "-r", "-t"]);
         expect(ls).to.be.calledWith(hostInfo, "hoge", ["-l", "-r", "-t"], 0);
       });
-      it("should call ls with option and timeout", ()=>{
+      it("should call ls with option and timeout", () => {
         ssh.ls("hoge", ["-l", "-r", "-t"], 10);
         expect(ls).to.be.calledWith(hostInfo, "hoge", ["-l", "-r", "-t"], 10);
       });
     });
-    describe("test for send", ()=>{
-      it("should call send with src and dst", ()=>{
+    describe("test for send", () => {
+      it("should call send with src and dst", () => {
         ssh.send(["src"], "dst");
         expect(send).to.be.calledWith(hostInfo, ["src"], "dst", [], 0);
       });
-      it("should call send with src, dst, and opt", ()=>{
+      it("should call send with src, dst, and opt", () => {
         ssh.send(["src"], "dst", ["--dry-run", "--delete"]);
         expect(send).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 0);
       });
-      it("should call send with src, dst, opt, and timeout", ()=>{
+      it("should call send with src, dst, opt, and timeout", () => {
         ssh.send(["src"], "dst", ["--dry-run", "--delete"], 10);
         expect(send).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 10);
       });
-      it("should be rejected if src is not array of string", ()=>{
+      it("should be rejected if src is not array of string", () => {
         return expect(ssh.send(1)).to.be.rejectedWith("src must be array of string");
       });
-      it("should be rejected if src has only empty string element", ()=>{
+      it("should be rejected if src has only empty string element", () => {
         return expect(ssh.send(["", ""])).to.be.rejectedWith("src must contain non-empty string");
       });
-      it("should be rejected if src has only empty string element", ()=>{
+      it("should be rejected if src has only empty string element", () => {
         return expect(ssh.send([""])).to.be.rejectedWith("src must contain non-empty string");
       });
-      it("should be called if src includes empty string ", ()=>{
+      it("should be called if src includes empty string ", () => {
         ssh.send(["src", ""], "dst");
         expect(send).to.be.calledWith(hostInfo, ["src", ""], "dst", [], 0);
       });
-      it("should be rejected if dst is not string", ()=>{
+      it("should be rejected if dst is not string", () => {
         return expect(ssh.send(["src"], 0)).to.be.rejectedWith("dst must be string");
       });
-      it("should be rejected if dst is empty string", ()=>{
+      it("should be rejected if dst is empty string", () => {
         return expect(ssh.send(["src"], "")).to.be.rejectedWith("dst must be non-empty string");
       });
-      it("should be rejected if opt is not array of string", ()=>{
+      it("should be rejected if opt is not array of string", () => {
         return expect(ssh.send(["src"], "dst", [null])).to.be.rejectedWith("opt must be array of string");
       });
     });
-    describe("test for recv", ()=>{
-      it("should call recv with src and dst", ()=>{
+    describe("test for recv", () => {
+      it("should call recv with src and dst", () => {
         ssh.recv(["src"], "dst");
         expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", [], 0);
       });
-      it("should call recv with src, dst, and opt", ()=>{
+      it("should call recv with src, dst, and opt", () => {
         ssh.recv(["src"], "dst", ["--dry-run", "--delete"]);
         expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 0);
       });
-      it("should call recv with src, dst, opt, and timeout", ()=>{
+      it("should call recv with src, dst, opt, and timeout", () => {
         ssh.recv(["src"], "dst", ["--dry-run", "--delete"], 10);
         expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 10);
       });
-      it("should be rejected if src is not array of string", ()=>{
+      it("should be rejected if src is not array of string", () => {
         return expect(ssh.recv(1)).to.be.rejectedWith("src must be array of string");
       });
-      it("should be rejected if src has only empty string element", ()=>{
+      it("should be rejected if src has only empty string element", () => {
         return expect(ssh.recv(["", ""])).to.be.rejectedWith("src must contain non-empty string");
       });
-      it("should be rejected if src has only empty string element", ()=>{
+      it("should be rejected if src has only empty string element", () => {
         return expect(ssh.recv([""])).to.be.rejectedWith("src must contain non-empty string");
       });
-      it("should be called if src includes empty string ", ()=>{
+      it("should be called if src includes empty string ", () => {
         ssh.recv(["src", ""], "dst");
         expect(recv).to.be.calledWith(hostInfo, ["src", ""], "dst", [], 0);
       });
-      it("should be rejected if dst is not string", ()=>{
+      it("should be rejected if dst is not string", () => {
         return expect(ssh.recv(["src"], 0)).to.be.rejectedWith("dst must be string");
       });
-      it("should be rejected if dst is empty string", ()=>{
+      it("should be rejected if dst is empty string", () => {
         return expect(ssh.recv(["src"], "")).to.be.rejectedWith("dst must be non-empty string");
       });
-      it("should be rejected if opt is not array of string", ()=>{
+      it("should be rejected if opt is not array of string", () => {
         return expect(ssh.recv(["src"], "dst", [null])).to.be.rejectedWith("opt must be array of string");
       });
     });