ssh2-sftp-client 8.1.0 → 9.0.2

package/src/utils.js

@@ -1,63 +1,7 @@
-'use strict';
-
 const fs = require('fs');
 const path = require('path');
-
 const { errorCode } = require('./constants');
 
-/**
- * Generate a new Error object with a reformatted error message which
- * is a little more informative and useful to users.
- *
- * @param {Error|string} err - The Error object the new error will be based on
- * @param {number} retryCount - For those functions which use retry. Number of
- *                              attempts to complete before giving up
- * @returns {Error} New error with custom error message
- */
-function fmtError(err, name = 'sftp', eCode, retryCount) {
-  let msg = '';
-  let code = '';
-  let retry = retryCount
-    ? ` after ${retryCount} ${retryCount > 1 ? 'attempts' : 'attempt'}`
-    : '';
-
-  if (err === undefined) {
-    msg = `${name}: Undefined error - probably a bug!`;
-    code = errorCode.generic;
-  } else if (typeof err === 'string') {
-    msg = `${name}: ${err}${retry}`;
-    code = eCode ? eCode : errorCode.generic;
-  } else if (err.custom) {
-    msg = `${name}->${err.message}${retry}`;
-    code = err.code;
-  } else {
-    switch (err.code) {
-      case 'ENOTFOUND':
-        msg =
-          `${name}: ${err.level} error. ` +
-          `Address lookup failed for host ${err.hostname}${retry}`;
-        break;
-      case 'ECONNREFUSED':
-        msg =
-          `${name}: ${err.level} error. Remote host at ` +
-          `${err.address} refused connection${retry}`;
-        break;
-      case 'ECONNRESET':
-        msg =
-          `${name}: Remote host has reset the connection: ` +
-          `${err.message}${retry}`;
-        break;
-      default:
-        msg = `${name}: ${err.message}${retry}`;
-    }
-    code = err.code ? err.code : errorCode.generic;
-  }
-  let newError = new Error(msg);
-  newError.code = code;
-  newError.custom = true;
-  return newError;
-}
-
 /**
  * Simple default error listener. Will reformat the error message and
  * throw a new error.
@@ -66,82 +10,94 @@ function fmtError(err, name = 'sftp', eCode, retryCount) {
  * @throws {Error} Throws new error
  */
 function errorListener(client, name, reject) {
-  let fn = (err) => {
+  const fn = (err) => {
     if (client.endCalled || client.errorHandled) {
-      client.debugMsg(`${name} Error: Ignoring handled error: ${err.message}`);
+      // error already handled or expected - ignore
+      client.debugMsg(`${name} errorListener - ignoring handled error`);
+      return;
+    }
+    client.errorHandled = true;
+    const newError = new Error(`${name}: ${err.message}`);
+    newError.code = err.code;
+    if (reject) {
+      reject(newError);
     } else {
-      client.debugMsg(`${name} Error: Handling error: ${err.message}`);
-      client.errorHandled = true;
-      if (reject) {
-        client.debugMsg(`${name} Error: handled error with reject`);
-        reject(fmtError(err, name, err.code));
-      } else {
-        client.debugMsg(`${name} Error: handling error with throw`);
-        throw fmtError(err, name, err.code);
-      }
+      throw newError;
     }
   };
   return fn;
 }
 
 function endListener(client, name, reject) {
-  let fn = function () {
-    if (client.endCalled || client.endHandled) {
-      client.debugMsg(`${name} End: Ignoring expected end event`);
-    } else {
-      client.debugMsg(`${name} End: Handling end event`);
-      client.sftp = undefined;
-      client.endHandled = true;
-      if (reject) {
-        client.debugMsg(`${name} End: handling end event with reject'`);
-        reject(fmtError('Unexpected end event raised', name));
-      } else {
-        client.debugMsg(`${name} End: handling end event with throw`);
-        throw fmtError('Unexpected end event raised', name);
-      }
+  const fn = function () {
+    client.sftp = undefined;
+    if (client.endCalled || client.endHandled || client.errorHandled) {
+      // end event already handled - ignore
+      client.debugMsg(`${name} endListener - ignoring handled error`);
+      return;
     }
+    client.endHandled = true;
+    client.debugMsg(`${name} Unexpected end event - ignoring`);
+    // Don't reject/throw error, just log it and move on
+    // after invalidating the connection
+    // const err = new Error(`${name} Unexpected end event raised`);
+    // if (reject) {
+    //   reject(err);
+    // } else {
+    //   throw err;
+    // }
   };
   return fn;
 }
 
 function closeListener(client, name, reject) {
-  let fn = function () {
-    if (client.endCalled || client.closeHandled) {
-      client.debugMsg(`${name} Close: ignoring expected close event`);
-    } else {
-      client.debugMsg(`${name} Close: handling unexpected close event`);
-      client.sftp = undefined;
-      client.closeHandled = true;
-      if (reject) {
-        client.debugMsg(`${name} Close: handling close event with reject`);
-        reject(fmtError('Unexpected close event raised', name));
-      } else {
-        client.debugMsg(`${name} Close: handling close event with throw`);
-        throw fmtError('Unexpected close event raised', name);
-      }
+  const fn = function () {
+    client.sftp = undefined;
+    if (
+      client.endCalled ||
+      client.closeHandled ||
+      client.errorHandled ||
+      client.endHandled
+    ) {
+      // handled or expected close event - ignore
+      client.debugMsg(`${name} closeListener - ignoring handled error`);
+      return;
     }
+    client.closeHandled = true;
+    client.debugMsg(`${name} Unexpected close event raised - ignoring`);
+    // Don't throw/reject on close events. Just invalidate the connection
+    // and move on.
+    // const err = new Error(`${name}: Unexpected close event raised`);
+    // if (reject) {
+    //   reject(err);
+    // } else {
+    //   throw err;
+    // }
   };
   return fn;
 }
 
 function addTempListeners(client, name, reject) {
-  let listeners = {
+  const listeners = {
     end: endListener(client, name, reject),
     close: closeListener(client, name, reject),
     error: errorListener(client, name, reject),
   };
-  client.debugMsg(`${name}: Adding temp event listeners`);
   client.on('end', listeners.end);
   client.on('close', listeners.close);
   client.on('error', listeners.error);
+  client._resetEventFlags();
   return listeners;
 }
 
 function removeTempListeners(client, listeners, name) {
-  client.debugMsg(`${name}: Removing temp event listeners`);
-  client.removeListener('end', listeners.end);
-  client.removeListener('close', listeners.close);
-  client.removeListener('error', listeners.error);
+  try {
+    client.removeListener('end', listeners.end);
+    client.removeListener('close', listeners.close);
+    client.removeListener('error', listeners.error);
+  } catch (err) {
+    throw new Error(`${name}: Error removing temp listeners: ${err.message}`);
+  }
 }
 
 /**
@@ -165,11 +121,9 @@ function localExists(filePath) {
   } else if (stats.isFile()) {
     return '-';
   } else {
-    throw fmtError(
-      `Bad path: ${filePath}: target must be a file or directory`,
-      'localExists',
-      errorCode.badPath
-    );
+    const err = new Error(`Bad path: ${filePath}: target must be a file or directory`);
+    err.code = errorCode.badPath;
+    throw err;
   }
 }
 
@@ -284,15 +238,15 @@ function haveLocalCreate(filePath) {
 async function normalizeRemotePath(client, aPath) {
   try {
     if (aPath.startsWith('..')) {
-      let root = await client.realPath('..');
+      const root = await client.realPath('..');
       return root + client.remotePathSep + aPath.slice(3);
     } else if (aPath.startsWith('.')) {
-      let root = await client.realPath('.');
+      const root = await client.realPath('.');
       return root + client.remotePathSep + aPath.slice(2);
     }
     return aPath;
   } catch (err) {
-    throw fmtError(err, 'normalizeRemotePath');
+    throw new Error(`normalizeRemotePath: ${err.message}`);
   }
 }
 
@@ -308,11 +262,8 @@ async function normalizeRemotePath(client, aPath) {
  */
 function haveConnection(client, name, reject) {
   if (!client.sftp) {
-    let newError = fmtError(
-      'No SFTP connection available',
-      name,
-      errorCode.connect
-    );
+    const newError = new Error(`${name}: No SFTP connection available`);
+    newError.code = errorCode.connect;
     if (reject) {
       reject(newError);
       return false;
@@ -336,7 +287,6 @@ function sleep(ms) {
 }
 
 module.exports = {
-  fmtError,
   errorListener,
   endListener,
   closeListener,