ssh-client-wrapper 1.8.1 → 1.8.3

package/lib/fork.js

@@ -1,34 +1,33 @@
 "use strict";
-const debug = require("debug")("sshClientWrapper:fork");
-const debugVerbose = require("debug")("sshClientWrapper:fork_verbose");
-const debugSendPty = require("debug")("sshClientWrapper:fork_sendpty");
+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");
 
-const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String } = require("./util.js");
+const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String, sendPty } = require("./util.js");
 
 const nodePtyOpt = {
   shell: process.platform === "win32" ? process.env.ComSpec : process.env.SHELL,
   windowsHide: true
 };
 
-function sshLoginCallback(output, ptyProcess, pw, ph) {
+function sshLoginCallback(output, ptyProcess, pw, ph, logger = debugSendPty) {
   if (reNewHostPrompt.test(output)) {
-    debugSendPty("yes");
-    ptyProcess.write("yes\n");
+    sendPty(ptyProcess, "yes\n", logger, 17);
     return;
   }
   if (rePwPrompt.test(output)) {
     if (typeof pw === "string") {
       debug("use given password");
-      debugSendPty(pw);
-      ptyProcess.write(`${pw}\n`);
+      sendPty(ptyProcess, `${pw}\n`, logger, 23);
       return;
     }
     if (typeof pw === "function") {
       debug("call password callback function");
       pw()
         .then((v)=>{
-          ptyProcess.write(`${v}\n`);
+          sendPty(ptyProcess, `${v}\n`, logger, 30);
         });
       return;
     }
@@ -36,29 +35,36 @@ function sshLoginCallback(output, ptyProcess, pw, ph) {
   if (rePhPrompt.test(output)) {
     if (typeof ph === "string") {
       debug("use given passphrase");
-      debugSendPty(ph);
-      ptyProcess.write(`${ph}\n`);
+      sendPty(ptyProcess, `${ph}\n`, logger, 38);
       return;
     }
     if (typeof ph === "function") {
       debug("call passphrase callback function");
       ph()
         .then((v)=>{
-          ptyProcess.write(`${v}\n`);
+          sendPty(ptyProcess, `${v}\n`, logger, 45);
         });
     }
   }
 }
 
-function getMasterPty(hostInfo) {
+/**
+ * create pty for master ssh session and store to hostInfo.masterPty
+ */
+function getMasterPty(hostInfo, logger) {
   debug("fork pty for master connection");
+
+  if (hostInfo.masterPty) {
+    debug(`kill existing master pty for ${hostInfo.host}`);
+    hostInfo.masterPty.kill();
+  }
   const ptyProcess = spawn(nodePtyOpt.shell, [], nodePtyOpt);
-  ptyProcess.onData(buff2String.bind(null, debugVerbose));
+  ptyProcess.onData(buff2String.bind(null, debugMasterVerbose));
   ptyProcess.onData((data)=>{
     const output = data.toString();
-    sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase);
+    sshLoginCallback(output, ptyProcess, hostInfo.password, hostInfo.passphrase, logger);
   });
-  return ptyProcess;
+  hostInfo.masterPty = ptyProcess;
 }
 
 async function fork(hostInfo, cmd, args, outputCallback) {

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
-const debugLib = require("debug");
-const debug = debugLib("sshClientWrapper:interface");
+const debug = require("debug")("sshClientWrapper:interface");
+const debugVerbose = require("debug")("sshClientWrapper:verbose:interface");
 const { sshExec, canConnect, disconnect, ls } = require("./sshExec.js");
 const { send, recv } = require("./rsyncExec.js");
 const { isArrayOfString, sanityCheck } = require("./util.js");
@@ -36,6 +36,8 @@ const { isArrayOfString, sanityCheck } = require("./util.js");
  */
 class SshClientWrapper {
   constructor(hostInfo) {
+    debug("constructor called for", hostInfo.host);
+    debugVerbose("hostInfo=", hostInfo);
     sanityCheck(hostInfo);
     this.hostInfo = { ...hostInfo };
     this.hostInfo.masterPty = null;
@@ -66,6 +68,7 @@ class SshClientWrapper {
    * @returns {string[]} - output from ls
    */
   async ls(target, lsOpt = []) {
+    debug("ls called", target, lsOpt);
     return ls(this.hostInfo, target, lsOpt);
   }
 
@@ -158,7 +161,8 @@ class SshClientWrapper {
    * @returns {Promise} - Resolved with true on success, otherwise rejected with Error.
    */
   async canConnect(timeout = 60) {
-    debug("canConnect called timeout=", timeout);
+    debug("canConnect called with timeout=", timeout);
+    debugVerbose("hostInfo=", this.hostInfo);
 
     if (!Number.isInteger(timeout) || timeout <= 0) {
       return new Error("timeout must be positive integer");
@@ -170,7 +174,7 @@ class SshClientWrapper {
    * Disconnect master session
    */
   async disconnect() {
-    debug("disconnect called");
+    debug(`disconnect from ${this.hostInfo.host} called`);
     disconnect(this.hostInfo);
   }
 }

package/lib/rsyncExec.js

@@ -1,7 +1,7 @@
 "use strict";
 const path = require("path");
-const debug = require("debug")("sshClientWrapper:rsyncExec");
-const debugVerbose = require("debug")("sshClientWrapper:rsyncExec_verbose");
+const debug = require("debug")("sshClientWrapper:debug:rsyncExec");
+const debugVerbose = require("debug")("sshClientWrapper:verbose:rsyncExec");
 const { glob } = require("glob");
 
 const { connect, retryWrapper, sshExec } = require("./sshExec.js");

package/lib/sshExec.js

@@ -2,9 +2,10 @@
 const { setTimeout: setTimeoutPromise } = require("timers/promises");
 const crypto = require("crypto");
 const promiseRetry = require("promise-retry");
-const debug = require("debug")("sshClientWrapper:sshExec");
-const debugVerbose = require("debug")("sshClientWrapper:sshExec_verbose");
-const { sshCmd, getSshOption, sanityCheck } = require("./util.js");
+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 } = require("./util.js");
 const { fork, getMasterPty } = require("./fork.js");
 
 /**
@@ -64,6 +65,7 @@ async function canConnect(hostInfo, timeout = 60) {
  * @returns {boolean} - true if master session exists
  */
 async function existsMaster(hostInfo) {
+  debugVerbose("existsMaster called");
   const ac = new AbortController();
   const signal = ac.signal;
 
@@ -80,6 +82,8 @@ async function existsMaster(hostInfo) {
   const timeout = hostInfo.ConnectTimeout || 60;
   setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
     .then(()=>{
+      debug(`can not finish master session check within ${timeout} sec`);
+
       if (p.pty) {
         p.pty.kill();
       }
@@ -93,17 +97,17 @@ async function existsMaster(hostInfo) {
       }
     });
 
-
   try {
     debug(`check master session: ${sshCmd} ${args.join(" ")}`);
     p = fork(hostInfo, sshCmd, args, cb);
     await p;
-    ac.abort();
   } catch (err) {
     if (err.rt !== 255) {
       debug("check master session failed", err);
       throw err;
     }
+  } finally {
+    ac.abort();
   }
 
   return rt && !/Control socket connect.*: No such file or directory/.test(output);
@@ -118,30 +122,30 @@ async function connect(hostInfo, timeout = 60) {
     debugVerbose("master connection exists");
     return;
   }
-  debug(`create master ssh session to ${hostInfo.host}`);
 
-  if (!hostInfo.masterPty) {
-    debug(`create master pty for ${hostInfo.host}`);
-    hostInfo.masterPty = getMasterPty(hostInfo);
-  } else {
-    debug(`master pty for ${hostInfo.host} exists`);
-  }
+  debug(`create master pty for ${hostInfo.host}`);
+  getMasterPty(hostInfo, debugSendMasterPty);
 
+  debug(`create master ssh session to ${hostInfo.host}`);
   const ac = new AbortController();
   const signal = ac.signal;
   setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
     .then(()=>{
+      debug(`can not connect within ${timeout} sec`);
+      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;
-      hostInfo.masterPty.write("\n");
-      hostInfo.masterPty.write("exit\n");
       throw err;
     })
     .catch((err)=>{
       if (err.name === "AbortError") {
         debug("timeout was aborted because connection check has done");
+      } else {
+        throw err;
       }
     });
 
@@ -159,7 +163,6 @@ async function connect(hostInfo, timeout = 60) {
 
       if (re.test(output)) {
         debug("test done. call exit on remotehost");
-        hostInfo.masterPty.write("exit\n");
         done = true;
         resolve();
       } else if (/Permission denied \(/.test(output)) {
@@ -181,11 +184,14 @@ async function connect(hostInfo, timeout = 60) {
   const args = getSshOption(hostInfo);
   args.push(`echo ${words}`);
   const cmd = `${sshCmd} ${args.join(" ")}\n`;
-  debugVerbose(cmd);
-  hostInfo.masterPty.write(cmd);
-  await p;
-  ac.abort();
-  debug(`connected to ${hostInfo.host}`);
+  sendPty(hostInfo.masterPty, cmd, debugSendMasterPty, 190);
+
+  try {
+    await p;
+    debug(`connected to ${hostInfo.host}`);
+  } finally {
+    ac.abort();
+  }
 }
 
 /**
@@ -220,7 +226,7 @@ async function disconnect(hostInfo) {
 
   if (hostInfo.masterPty) {
     debug("exit masterPty");
-    hostInfo.masterPty.write("exit \n");
+    sendPty(hostInfo.masterPty, "exit \n", debugSendMasterPty, 228);
     hostInfo.masterPty = null;
   }
 }

package/lib/util.js

@@ -1,5 +1,8 @@
 "use strict";
 const { EOL } = require("os");
+const fs = require("fs");
+const debug = require("debug")("sshClientWrapper:debug:util");
+
 const sshCmd = "ssh";
 const rsyncCmd = "rsync";
 
@@ -62,8 +65,20 @@ const getSshOption = (hostInfo, withoutDestination)=>{
     args.push(hostInfo.port);
   }
   if (typeof hostInfo.keyFile === "string") {
-    args.push("-i");
-    args.push(hostInfo.keyFile);
+    try {
+      const stats = fs.statSync(hostInfo.keyFile);
+      if (stats.isFile()) {
+        args.push("-i");
+        args.push(hostInfo.keyFile);
+      } else {
+        debug(`specified keyFile(${hostInfo.keyFile}) is not file. so it is ignored`);
+      }
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        throw e;
+      }
+      debug(`specified keyFile(${hostInfo.keyFile}) not found and ignored`);
+    }
   }
 
   if (hostInfo.noStrictHostkeyChecking) {
@@ -95,6 +110,17 @@ const isArrayOfString = (target)=>{
   });
 };
 
+/**
+ * log and send message to pty
+ * @param {Object} pty - pty object which message will be send to
+ * @param {string} message - message
+ * @param {Function} logger - logging function
+ * @param {string} label - where this function is called
+ */
+const sendPty = async (pty, message, logger, label)=>{
+  logger(`${label}: ${message}`);
+  pty.write(message);
+};
 
 module.exports = {
   sshCmd,
@@ -105,5 +131,6 @@ module.exports = {
   buff2String,
   getSshOption,
   sanityCheck,
-  isArrayOfString
+  isArrayOfString,
+  sendPty
 };

package/package.json

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