ssh2-sftp-client 6.0.0 → 6.0.1

package/CHANGELOG.org

@@ -1,6 +1,14 @@
 * Change Logging
 
-** V6.0.0
+** Version 6.0.1
+   - Fix issue with connect retry not releasing 'ready' listeners
+   - Add finally clauses to all promises to ensure temporary listeners are deleted
+   - Add nyc module to report on code test coverage
+   - Add additional utils tests to increase test coverage
+   - Removed some dead code and unused utility functions to reduce download size
+   - Cleanup tests and reduce inter-test dependencies
+
+** V6.0.0.0
    - Update connection retry code to use the promise-retry module instead of
      plain rety module
    - Added optional filter argument for uploadDir/downlDir to select which files

package/README.md

@@ -2,7 +2,8 @@
 - [Installation](#sec-2)
 - [Basic Usage](#sec-3)
 - [Version 6.x Changes](#sec-4)
-  - [Version 6.0.0 Changes](#sec-4-1)
+  - [Version 6.0.1](#sec-4-1)
+  - [Version 6.0.0 Changes](#sec-4-2)
 - [Documentation](#sec-5)
   - [Specifying Paths](#sec-5-1)
   - [Methods](#sec-5-2)
@@ -104,7 +105,15 @@ sftp.connect({
 
 # Version 6.x Changes<a id="sec-4"></a>
 
-## Version 6.0.0 Changes<a id="sec-4-1"></a>
+## Version 6.0.1<a id="sec-4-1"></a>
+
+-   Fix issue with connect retry not releasing 'ready' listener.
+-   Add finally clauses to all promises to ensure release of temporary listeners.
+-   Add nyc module to improve test coverage
+-   Added additional utils tests to improve test coverage
+-   Removed some unnecessary util functions to reduce code size
+
+## Version 6.0.0 Changes<a id="sec-4-2"></a>
 
 -   Added new optional argument *notFoundOK* to `delete()` method. If true, no error is thrown when trying to delete a file which does not exist. Default is false.
 -   Added new filter argument to `uploadDir()` and `downloadDir()` methods. The filter argument is a regular expression used to match the files and directories to be included in the upload or download. Defaults to match all files and directories.

package/README.org

@@ -68,6 +68,14 @@ npm install ssh2-sftp-client
 #+end_src
 
 * Version 6.x Changes
+** Version 6.0.1
+
+- Fix issue with connect retry not releasing 'ready' listener.
+- Add finally clauses to all promises to ensure release of temporary listeners.
+- Add nyc module to improve test coverage
+- Added additional utils tests to improve test coverage
+- Removed some unnecessary util functions to reduce code size
+
 ** Version 6.0.0 Changes
 
 - Added new optional argument /notFoundOK/ to ~delete()~ method. If true, no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh2-sftp-client",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "description": "ssh2 sftp client for node",
   "main": "src/index.js",
   "repository": {
@@ -9,7 +9,8 @@
   },
   "keywords": ["sftp", "nodejs", "promises"],
   "scripts": {
-    "test": "mocha"
+    "test": "mocha",
+    "coverage": "nyc npm run test"
   },
   "author": "Tim Cross",
   "email": "theophilusx@gmail.com",
@@ -23,7 +24,8 @@
   "dependencies": {
     "concat-stream": "^2.0.0",
     "promise-retry": "^2.0.1",
-    "ssh2": "^0.8.9"
+    "ssh2": "^0.8.9",
+    "winston": "^3.3.3"
   },
   "devDependencies": {
     "chai": "^4.2.0",
@@ -33,6 +35,7 @@
     "dotenv": "^8.2.0",
     "mocha": "^8.2.1",
     "moment": "^2.29.1",
+    "nyc": "^15.1.0",
     "through2": "^4.0.2"
   }
 }

package/src/index.js

@@ -7,10 +7,16 @@
 const {Client} = require('ssh2');
 const fs = require('fs');
 const concat = require('concat-stream');
-//const retry = require('retry');
 const promiseRetry = require('promise-retry');
 const {join, parse} = require('path');
-const utils = require('./utils');
+const {
+  fmtError,
+  addTempListeners,
+  removeTempListeners,
+  haveConnection,
+  normalizeRemotePath,
+  localExists
+} = require('./utils');
 const {errorCode} = require('./constants');
 
 class SftpClient {
@@ -38,7 +44,7 @@ class SftpClient {
     });
     this.client.on('error', (err) => {
       if (!this.errorHandled) {
-        throw utils.formatError(
+        throw fmtError(
           `Unexpected error: ${err.message}`,
           'global-error-handler',
           err.code
@@ -92,30 +98,49 @@ class SftpClient {
    *
    */
   sftpConnect(config) {
+    let connectReady;
+
     return new Promise((resolve, reject) => {
-      let connectReady = () => {
+      addTempListeners(this, 'sftpConnect', reject);
+      connectReady = () => {
         this.client.sftp((err, sftp) => {
           if (err) {
             this.debugMsg(`SFTP channel error: ${err.message} ${err.code}`);
-            reject(utils.formatError(err, 'sftpConnect', err.code));
+            reject(fmtError(err, 'sftpConnect', err.code));
           } else {
-            //this.sftp = sftp;
+            this.debugMsg('SFTP channel established');
             resolve(sftp);
           }
-          this.client.removeListener('ready', connectReady);
         });
       };
-      utils.addTempListeners(this, 'sftpConnect', reject);
+      // addTempListeners(this, 'sftpConnect', reject);
       this.client.on('ready', connectReady).connect(config);
+    }).finally((rsp) => {
+      this.removeListener('ready', connectReady);
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
-  retryConnect(config) {
+  connect(config) {
+    if (config.debug) {
+      this.debug = config.debug;
+      this.debugMsg('Debugging turned on');
+    }
+    if (this.sftp) {
+      this.debugMsg('Already connected - reject');
+      return Promise.reject(
+        fmtError(
+          'An existing SFTP connection is already defined',
+          'connect',
+          errorCode.connect
+        )
+      );
+    }
     return promiseRetry(
       (retry, attempt) => {
         this.debugMsg(`Connect attempt ${attempt}`);
         return this.sftpConnect(config).catch((err) => {
-          utils.removeTempListeners(this.client);
           retry(err);
         });
       },
@@ -124,30 +149,9 @@ class SftpClient {
         factor: config.retry_factor || 2,
         minTimeout: config.retry_minTimeout || 1000
       }
-    );
-  }
-
-  async connect(config) {
-    try {
-      if (config.debug) {
-        this.debug = config.debug;
-        this.debugMsg('Debugging turned on');
-      }
-      if (this.sftp) {
-        this.debugMsg('Already connected - reject');
-        throw utils.formatError(
-          'An existing SFTP connection is already defined',
-          'connect',
-          errorCode.connect
-        );
-      }
-      //this.sftp = await this.sftpConnect(config);
-      this.sftp = await this.retryConnect(config);
-      this.debugMsg('SFTP Connection established');
-      utils.removeTempListeners(this.client);
-    } catch (err) {
-      throw utils.formatError(err.message, 'connect', err.errorCode);
-    }
+    ).then((sftp) => {
+      this.sftp = sftp;
+    });
   }
 
   /**
@@ -165,8 +169,8 @@ class SftpClient {
   realPath(remotePath) {
     return new Promise((resolve, reject) => {
       this.debugMsg(`realPath -> ${remotePath}`);
-      utils.addTempListeners(this, 'realPath', reject);
-      if (utils.haveConnection(this, 'realPath', reject)) {
+      addTempListeners(this, 'realPath', reject);
+      if (haveConnection(this, 'realPath', reject)) {
         this.sftp.realpath(remotePath, (err, absPath) => {
           if (err) {
             this.debugMsg(`realPath Error: ${err.message} Code: ${err.code}`);
@@ -174,19 +178,17 @@ class SftpClient {
               resolve('');
             } else {
               reject(
-                utils.formatError(
-                  `${err.message} ${remotePath}`,
-                  'realPath',
-                  err.code
-                )
+                fmtError(`${err.message} ${remotePath}`, 'realPath', err.code)
               );
             }
           }
           this.debugMsg(`realPath <- ${absPath}`);
           resolve(absPath);
-          utils.removeTempListeners(this.client);
         });
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -204,13 +206,13 @@ class SftpClient {
     const _stat = (aPath) => {
       return new Promise((resolve, reject) => {
         this.debugMsg(`stat -> ${aPath}`);
-        utils.addTempListeners(this, 'stat', reject);
+        addTempListeners(this, 'stat', reject);
         this.sftp.stat(aPath, (err, stats) => {
           if (err) {
             this.debugMsg(`stat error ${err.message} code: ${err.code}`);
             if (err.code === 2 || err.code === 4) {
               reject(
-                utils.formatError(
+                fmtError(
                   `No such file: ${remotePath}`,
                   '_stat',
                   errorCode.notexist
@@ -218,11 +220,7 @@ class SftpClient {
               );
             } else {
               reject(
-                utils.formatError(
-                  `${err.message} ${remotePath}`,
-                  '_stat',
-                  err.code
-                )
+                fmtError(`${err.message} ${remotePath}`, '_stat', err.code)
               );
             }
           } else {
@@ -243,17 +241,23 @@ class SftpClient {
               isSocket: stats.isSocket()
             });
           }
-          utils.removeTempListeners(this.client);
         });
+      }).finally((rsp) => {
+        removeTempListeners(this.client);
+        return rsp;
       });
     };
 
     try {
-      utils.haveConnection(this, 'stat');
-      let absPath = await utils.normalizeRemotePath(this, remotePath);
+      haveConnection(this, 'stat');
+      let absPath = await normalizeRemotePath(this, remotePath);
       return _stat(absPath);
     } catch (err) {
-      return utils.handleError(err, 'stat');
+      if (err.custom) {
+        throw err;
+      } else {
+        throw fmtError(err, 'stat', err.code);
+      }
     }
   }
 
@@ -270,11 +274,11 @@ class SftpClient {
    */
   async exists(remotePath) {
     try {
-      if (utils.haveConnection(this, 'exists')) {
+      if (haveConnection(this, 'exists')) {
         if (remotePath === '.') {
           return 'd';
         }
-        let absPath = await utils.normalizeRemotePath(this, remotePath);
+        let absPath = await normalizeRemotePath(this, remotePath);
         try {
           this.debugMsg(`exists -> ${absPath}`);
           let info = await this.stat(absPath);
@@ -299,7 +303,11 @@ class SftpClient {
         return false;
       }
     } catch (err) {
-      return utils.handleError(err, 'exists');
+      if (err.custom) {
+        throw err;
+      } else {
+        throw fmtError(err, 'exists', err.code);
+      }
     }
   }
 
@@ -319,20 +327,14 @@ class SftpClient {
    */
   list(remotePath, pattern = /.*/) {
     return new Promise((resolve, reject) => {
-      if (utils.haveConnection(this, 'list', reject)) {
+      if (haveConnection(this, 'list', reject)) {
         const reg = /-/gi;
         this.debugMsg(`list -> ${remotePath} filter -> ${pattern}`);
-        utils.addTempListeners(this, 'list', reject);
+        addTempListeners(this, 'list', reject);
         this.sftp.readdir(remotePath, (err, fileList) => {
           if (err) {
             this.debugMsg(`list error ${err.message} code: ${err.code}`);
-            reject(
-              utils.formatError(
-                `${err.message} ${remotePath}`,
-                'list',
-                err.code
-              )
-            );
+            reject(fmtError(`${err.message} ${remotePath}`, 'list', err.code));
           } else {
             this.debugMsg('list <- ', fileList);
             let newList = [];
@@ -365,9 +367,11 @@ class SftpClient {
             }
             resolve(newList.filter((item) => regex.test(item.name)));
           }
-          utils.removeTempListeners(this.client);
         });
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -387,16 +391,12 @@ class SftpClient {
    */
   get(remotePath, dst, options = {}) {
     return new Promise((resolve, reject) => {
-      if (utils.haveConnection(this, 'get', reject)) {
+      if (haveConnection(this, 'get', reject)) {
         this.debugMsg(`get -> ${remotePath} `, options);
-        utils.addTempListeners(this, 'get', reject);
+        addTempListeners(this, 'get', reject);
         let rdr = this.sftp.createReadStream(remotePath, options);
         rdr.once('error', (err) => {
-          utils.removeListeners(rdr);
-          reject(
-            utils.formatError(`${err.message} ${remotePath}`, 'get', err.code)
-          );
-          utils.removeTempListeners(this.client);
+          reject(fmtError(`${err.message} ${remotePath}`, 'get', err.code));
         });
         if (dst === undefined) {
           // no dst specified, return buffer of data
@@ -404,7 +404,6 @@ class SftpClient {
           let concatStream = concat((buff) => {
             rdr.removeAllListeners('error');
             resolve(buff);
-            utils.removeTempListeners(this.client);
           });
           rdr.pipe(concatStream);
         } else {
@@ -418,9 +417,8 @@ class SftpClient {
             wtr = dst;
           }
           wtr.once('error', (err) => {
-            utils.removeListeners(rdr);
             reject(
-              utils.formatError(
+              fmtError(
                 `${err.message} ${typeof dst === 'string' ? dst : ''}`,
                 'get',
                 err.code
@@ -429,10 +427,8 @@ class SftpClient {
             if (options.autoClose === false) {
               rdr.destroy();
             }
-            utils.removeTempListeners(this.client);
           });
           wtr.once('finish', () => {
-            utils.removeListeners(rdr);
             if (options.autoClose === false) {
               rdr.destroy();
             }
@@ -441,11 +437,13 @@ class SftpClient {
             } else {
               resolve(wtr);
             }
-            utils.removeTempListeners(this.client);
           });
           rdr.pipe(wtr);
         }
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -470,30 +468,30 @@ class SftpClient {
             ftype === false
               ? `No such file ${remotePath}`
               : `Not a regular file ${remotePath}`;
-          return Promise.reject(
-            utils.formatError(msg, 'fastGet', errorCode.badPath)
-          );
+          return Promise.reject(fmtError(msg, 'fastGet', errorCode.badPath));
         }
       })
       .then(() => {
         return new Promise((resolve, reject) => {
-          if (utils.haveConnection(this, 'fastGet', reject)) {
+          if (haveConnection(this, 'fastGet', reject)) {
             this.debugMsg(
               `fastGet -> remote: ${remotePath} local: ${localPath} `,
               options
             );
-            utils.addTempListeners(this, 'fastGet', reject);
+            addTempListeners(this, 'fastGet', reject);
             this.sftp.fastGet(remotePath, localPath, options, (err) => {
               if (err) {
                 this.debugMsg(`fastGet error ${err.message} code: ${err.code}`);
-                reject(utils.formatError(err, 'fastGet'));
+                reject(fmtError(err, 'fastGet'));
               }
               resolve(
                 `${remotePath} was successfully download to ${localPath}!`
               );
-              utils.removeTempListeners(this.client);
             });
           }
+        }).finally((rsp) => {
+          removeTempListeners(this.client);
+          return rsp;
         });
       });
   }
@@ -513,18 +511,13 @@ class SftpClient {
    */
   fastPut(localPath, remotePath, options) {
     this.debugMsg(`fastPut -> local ${localPath} remote ${remotePath}`);
-    return utils
-      .localExists(localPath)
+    return localExists(localPath)
       .then((localStatus) => {
         this.debugMsg(`fastPut <- localStatus ${localStatus}`);
         if (localStatus !== '-') {
           this.debugMsg('fastPut reject bad source path');
           return Promise.reject(
-            utils.formatError(
-              `Bad path ${localPath}`,
-              'fastPut',
-              errorCode.badPath
-            )
+            fmtError(`Bad path ${localPath}`, 'fastPut', errorCode.badPath)
           );
         }
         return new Promise((resolve, reject) => {
@@ -532,11 +525,7 @@ class SftpClient {
             if (err) {
               this.debugMsg('fastPut reject no access source');
               reject(
-                utils.formatError(
-                  `${err.message} ${localPath}`,
-                  'fastPut',
-                  err.code
-                )
+                fmtError(`${err.message} ${localPath}`, 'fastPut', err.code)
               );
             } else {
               this.debugMsg('fastPut source access ok');
@@ -547,18 +536,18 @@ class SftpClient {
       })
       .then(() => {
         return new Promise((resolve, reject) => {
-          if (utils.haveConnection(this, 'fastPut', reject)) {
+          if (haveConnection(this, 'fastPut', reject)) {
             this.debugMsg(
               `fastPut -> local: ${localPath} remote: ${remotePath} opts: ${JSON.stringify(
                 options
               )}`
             );
-            utils.addTempListeners(this, 'fastPut', reject);
+            addTempListeners(this, 'fastPut', reject);
             this.sftp.fastPut(localPath, remotePath, options, (err) => {
               if (err) {
                 this.debugMsg(`fastPut error ${err.message} ${err.code}`);
                 reject(
-                  utils.formatError(
+                  fmtError(
                     `${err.message} Local: ${localPath} Remote: ${remotePath}`,
                     'fastPut',
                     err.code
@@ -571,11 +560,10 @@ class SftpClient {
               );
             });
           }
+        }).finally((rsp) => {
+          removeTempListeners(this.client);
+          return rsp;
         });
-      })
-      .then((msg) => {
-        utils.removeTempListeners(this.client);
-        return msg;
       });
   }
 
@@ -597,13 +585,12 @@ class SftpClient {
       } -> ${remotePath}`,
       options
     );
-    return utils
-      .localExists(typeof localSrc === 'string' ? localSrc : 'dummy')
+    return localExists(typeof localSrc === 'string' ? localSrc : 'dummy')
       .then((localStatus) => {
         if (typeof localSrc === 'string' && localStatus !== '-') {
           this.debugMsg(`put: file does not exist ${localSrc} - rejecting`);
           return Promise.reject(
-            utils.formatError(`Bad path ${localSrc}`, 'put', errorCode.badPath)
+            fmtError(`Bad path ${localSrc}`, 'put', errorCode.badPath)
           );
         }
         return new Promise((resolve, reject) => {
@@ -615,7 +602,7 @@ class SftpClient {
                 if (err) {
                   this.debugMsg(`put: Cannot read ${localSrc} - rejecting`);
                   reject(
-                    utils.formatError(
+                    fmtError(
                       `Permission denied ${localSrc}`,
                       'put',
                       errorCode.permission
@@ -635,26 +622,17 @@ class SftpClient {
       })
       .then(() => {
         return new Promise((resolve, reject) => {
-          if (utils.haveConnection(this, 'put', reject)) {
-            utils.addTempListeners(this, 'put', reject);
+          if (haveConnection(this, 'put', reject)) {
+            addTempListeners(this, 'put', reject);
             let stream = this.sftp.createWriteStream(remotePath, options);
             stream.once('error', (err) => {
-              reject(
-                utils.formatError(
-                  `${err.message} ${remotePath}`,
-                  'put',
-                  err.code
-                )
-              );
-              utils.removeTempListeners(this.client);
+              reject(fmtError(`${err.message} ${remotePath}`, 'put', err.code));
             });
             stream.once('finish', () => {
-              utils.removeListeners(stream);
               if (options.autoClose === false) {
                 stream.destroy();
               }
               resolve(`Uploaded data stream to ${remotePath}`);
-              utils.removeTempListeners(this.client);
             });
             if (localSrc instanceof Buffer) {
               this.debugMsg('put source is a buffer');
@@ -669,9 +647,8 @@ class SftpClient {
                 rdr = localSrc;
               }
               rdr.once('error', (err) => {
-                utils.removeListeners(stream);
                 reject(
-                  utils.formatError(
+                  fmtError(
                     `${err.message} ${
                       typeof localSrc === 'string' ? localSrc : ''
                     }`,
@@ -682,11 +659,13 @@ class SftpClient {
                 if (options.autoClose === false) {
                   stream.destroy();
                 }
-                utils.removeTempListeners(this.client);
               });
               rdr.pipe(stream);
             }
           }
+        }).finally((rsp) => {
+          removeTempListeners(this.client);
+          return rsp;
         });
       });
   }
@@ -701,31 +680,21 @@ class SftpClient {
    */
   append(input, remotePath, options = {}) {
     return new Promise((resolve, reject) => {
-      if (utils.haveConnection(this, 'append', reject)) {
+      if (haveConnection(this, 'append', reject)) {
         if (typeof input === 'string') {
-          reject(
-            utils.formatError('Cannot append one file to another', 'append')
-          );
+          reject(fmtError('Cannot append one file to another', 'append'));
         } else {
           this.debugMsg(`append -> remote: ${remotePath} `, options);
-          utils.addTempListeners(this, 'append', reject);
+          addTempListeners(this, 'append', reject);
           options.flags = 'a';
           let stream = this.sftp.createWriteStream(remotePath, options);
           stream.once('error', (err) => {
-            utils.removeListeners(stream);
             reject(
-              utils.formatError(
-                `${err.message} ${remotePath}`,
-                'append',
-                err.code
-              )
+              fmtError(`${err.message} ${remotePath}`, 'append', err.code)
             );
-            utils.removeTempListeners(this.client);
           });
           stream.once('finish', () => {
-            utils.removeListeners(stream);
             resolve(`Appended data to ${remotePath}`);
-            utils.removeTempListeners(this.client);
           });
           if (input instanceof Buffer) {
             stream.end(input);
@@ -734,6 +703,9 @@ class SftpClient {
           }
         }
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -750,23 +722,23 @@ class SftpClient {
     const _mkdir = (p) => {
       return new Promise((resolve, reject) => {
         this.debugMsg(`mkdir -> ${p}`);
-        utils.addTempListeners(this, 'mkdir', reject);
+        addTempListeners(this, 'mkdir', reject);
         this.sftp.mkdir(p, (err) => {
           if (err) {
             this.debugMsg(`mkdir error ${err.message} code: ${err.code}`);
-            reject(
-              utils.formatError(`${err.message} ${p}`, '_mkdir', err.code)
-            );
+            reject(fmtError(`${err.message} ${p}`, '_mkdir', err.code));
           }
           resolve(`${p} directory created`);
-          utils.removeTempListeners(this.client);
         });
+      }).finally((rsp) => {
+        removeTempListeners(this.client);
+        return rsp;
       });
     };
 
     try {
-      utils.haveConnection(this, 'mkdir');
-      let rPath = await utils.normalizeRemotePath(this, remotePath);
+      haveConnection(this, 'mkdir');
+      let rPath = await normalizeRemotePath(this, remotePath);
       if (!recursive) {
         return _mkdir(rPath);
       }
@@ -779,7 +751,11 @@ class SftpClient {
       }
       return _mkdir(rPath);
     } catch (err) {
-      return utils.handleError(`${err.message} ${remotePath}`, 'mkdir');
+      if (err.custom) {
+        throw err;
+      } else {
+        throw fmtError(`${err.message} ${remotePath}`, 'mkdir', err.code);
+      }
     }
   }
 
@@ -797,23 +773,23 @@ class SftpClient {
     const _rmdir = (p) => {
       return new Promise((resolve, reject) => {
         this.debugMsg(`rmdir -> ${p}`);
-        utils.addTempListeners(this, 'rmdir', reject);
+        addTempListeners(this, 'rmdir', reject);
         this.sftp.rmdir(p, (err) => {
           if (err) {
             this.debugMsg(`rmdir error ${err.message} code: ${err.code}`);
-            reject(
-              utils.formatError(`${err.message} ${p}`, '_rmdir', err.code)
-            );
+            reject(fmtError(`${err.message} ${p}`, '_rmdir', err.code));
           }
           resolve('Successfully removed directory');
-          utils.removeTempListeners(this.client);
         });
+      }).finally((rsp) => {
+        removeTempListeners(this.client);
+        return rsp;
       });
     };
 
     try {
-      utils.haveConnection(this, 'rmdir');
-      let absPath = await utils.normalizeRemotePath(this, remotePath);
+      haveConnection(this, 'rmdir');
+      let absPath = await normalizeRemotePath(this, remotePath);
       if (!recursive) {
         return _rmdir(absPath);
       }
@@ -832,7 +808,11 @@ class SftpClient {
       }
       return _rmdir(absPath);
     } catch (err) {
-      return utils.handleError(err, 'rmdir');
+      if (err.custom) {
+        throw err;
+      } else {
+        throw fmtError(err, 'rmdir', err.code);
+      }
     }
   }
 
@@ -849,9 +829,9 @@ class SftpClient {
    */
   delete(remotePath, notFoundOK = false) {
     return new Promise((resolve, reject) => {
-      if (utils.haveConnection(this, 'delete', reject)) {
+      if (haveConnection(this, 'delete', reject)) {
         this.debugMsg(`delete -> ${remotePath}`);
-        utils.addTempListeners(this, 'delete', reject);
+        addTempListeners(this, 'delete', reject);
         this.sftp.unlink(remotePath, (err) => {
           if (err) {
             this.debugMsg(`delete error ${err.message} code: ${err.code}`);
@@ -860,18 +840,16 @@ class SftpClient {
               resolve(`Successfully deleted ${remotePath}`);
             } else {
               reject(
-                utils.formatError(
-                  `${err.message} ${remotePath}`,
-                  'delete',
-                  err.code
-                )
+                fmtError(`${err.message} ${remotePath}`, 'delete', err.code)
               );
             }
           }
           resolve(`Successfully deleted ${remotePath}`);
-          utils.removeTempListeners(this.client);
         });
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -888,14 +866,14 @@ class SftpClient {
    */
   rename(fromPath, toPath) {
     return new Promise((resolve, reject) => {
-      if (utils.haveConnection(this, 'rename', reject)) {
+      if (haveConnection(this, 'rename', reject)) {
         this.debugMsg(`rename -> ${fromPath} ${toPath}`);
-        utils.addTempListeners(this, 'rename', reject);
+        addTempListeners(this, 'rename', reject);
         this.sftp.rename(fromPath, toPath, (err) => {
           if (err) {
             this.debugMsg(`rename error ${err.message} code: ${err.code}`);
             reject(
-              utils.formatError(
+              fmtError(
                 `${err.message} From: ${fromPath} To: ${toPath}`,
                 'rename',
                 err.code
@@ -903,9 +881,11 @@ class SftpClient {
             );
           }
           resolve(`Successfully renamed ${fromPath} to ${toPath}`);
-          utils.removeTempListeners(this.client);
         });
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -923,14 +903,14 @@ class SftpClient {
    */
   posixRename(fromPath, toPath) {
     return new Promise((resolve, reject) => {
-      if (utils.haveConnection(this, 'posixRename', reject)) {
+      if (haveConnection(this, 'posixRename', reject)) {
         this.debugMsg(`posixRename -> ${fromPath} ${toPath}`);
-        utils.addTempListeners(this, 'posixRename', reject);
+        addTempListeners(this, 'posixRename', reject);
         this.sftp.ext_openssh_rename(fromPath, toPath, (err) => {
           if (err) {
             this.debugMsg(`posixRename error ${err.message} code: ${err.code}`);
             reject(
-              utils.formatError(
+              fmtError(
                 `${err.message} From: ${fromPath} To: ${toPath}`,
                 'posixRename',
                 err.code
@@ -938,9 +918,11 @@ class SftpClient {
             );
           }
           resolve(`Successful POSIX rename ${fromPath} to ${toPath}`);
-          utils.removeTempListeners(this.client);
         });
       }
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -957,16 +939,16 @@ class SftpClient {
   chmod(remotePath, mode) {
     return new Promise((resolve, reject) => {
       this.debugMsg(`chmod -> ${remotePath} ${mode}`);
-      utils.addTempListeners(this, 'chmod', reject);
+      addTempListeners(this, 'chmod', reject);
       this.sftp.chmod(remotePath, mode, (err) => {
         if (err) {
-          reject(
-            utils.formatError(`${err.message} ${remotePath}`, 'chmod', err.code)
-          );
+          reject(fmtError(`${err.message} ${remotePath}`, 'chmod', err.code));
         }
         resolve('Successfully change file mode');
-        utils.removeTempListeners(this.client);
       });
+    }).finally((rsp) => {
+      removeTempListeners(this.client);
+      return rsp;
     });
   }
 
@@ -986,14 +968,10 @@ class SftpClient {
   async uploadDir(srcDir, dstDir, filter = /.*/) {
     try {
       this.debugMsg(`uploadDir -> ${srcDir} ${dstDir}`);
-      utils.haveConnection(this, 'uploadDir');
+      haveConnection(this, 'uploadDir');
       let dstStatus = await this.exists(dstDir);
       if (dstStatus && dstStatus !== 'd') {
-        throw utils.formatError(
-          `Bad path ${dstDir}`,
-          'uploadDir',
-          errorCode.badPath
-        );
+        throw fmtError(`Bad path ${dstDir}`, 'uploadDir', errorCode.badPath);
       }
       if (!dstStatus) {
         await this.mkdir(dstDir, true);
@@ -1021,7 +999,11 @@ class SftpClient {
       }
       return `${srcDir} uploaded to ${dstDir}`;
     } catch (err) {
-      return utils.handleError(err, 'uploadDir');
+      if (err.custom) {
+        throw err;
+      } else {
+        throw fmtError(err, 'uploadDir');
+      }
     }
   }
 
@@ -1041,15 +1023,11 @@ class SftpClient {
   async downloadDir(srcDir, dstDir, filter = /.*/) {
     try {
       this.debugMsg(`downloadDir -> ${srcDir} ${dstDir}`);
-      utils.haveConnection(this, 'downloadDir');
+      haveConnection(this, 'downloadDir');
       let fileList = await this.list(srcDir, filter);
-      let dstStatus = await utils.localExists(dstDir);
+      let dstStatus = await localExists(dstDir);
       if (dstStatus && dstStatus !== 'd') {
-        throw utils.formatError(
-          `Bad path ${dstDir}`,
-          'downloadDir',
-          errorCode.badPath
-        );
+        throw fmtError(`Bad path ${dstDir}`, 'downloadDir', errorCode.badPath);
       }
       if (!dstStatus) {
         fs.mkdirSync(dstDir, {recursive: true});
@@ -1072,7 +1050,11 @@ class SftpClient {
       }
       return `${srcDir} downloaded to ${dstDir}`;
     } catch (err) {
-      return utils.handleError(err, 'downloadDir');
+      if (err.custom) {
+        throw err;
+      } else {
+        throw fmtError(err, 'downloadDir', err.code);
+      }
     }
   }
 
@@ -1083,42 +1065,23 @@ class SftpClient {
    *
    */
   end() {
+    let endCloseHandler;
     return new Promise((resolve, reject) => {
-      const endErrorListener = (err) => {
-        // we don't care about errors at this point
-        // so do nothiing
-        this.debugMsg(
-          `endErrorListener called with ${err.message} and code ${err.code}`
-        );
-        this.errorHandled = true;
-        if (err.code !== 'ECONNRESET') {
-          reject(utils.formatError(err, 'end'));
-        } else {
-          this.debugMsg('Error is ECONNRESET - ignoring error');
-        }
-      };
-
-      try {
-        if (!utils.hasListener(this.client, 'error', 'endErrorListener')) {
-          this.debugMsg('Adding enderrorListener');
-          this.client.prependListener('error', endErrorListener);
-        } else {
-          this.debugMsg('endErrorListener already set');
-        }
-        this.endCalled = true;
-        if (utils.haveConnection(this, 'end', reject)) {
-          this.debugMsg('Have connection - calling end()');
-          this.client.end();
-        } else {
-          this.debugMsg('No connection - skipping call to end()');
-        }
-        resolve(true);
-      } catch (err) {
-        utils.handleError(err, 'end', reject);
-      } finally {
+      this.endCalled = true;
+      addTempListeners(this, 'end', reject);
+      endCloseHandler = () => {
         this.sftp = undefined;
-        this.endCalled = false;
+        resolve(true);
+      };
+      this.on('close', endCloseHandler);
+      if (haveConnection(this, 'end', reject)) {
+        this.debugMsg('Have connection - calling end()');
+        this.client.end();
       }
+    }).finally(() => {
+      removeTempListeners(this.client);
+      this.removeListener('close', endCloseHandler);
+      return true;
     });
   }
 }

package/src/utils.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const {prependListener} = require('cluster');
 const fs = require('fs');
 const {errorCode} = require('./constants');
 
@@ -13,7 +12,7 @@ const {errorCode} = require('./constants');
  *                              attempts to complete before giving up
  * @returns {Error} New error with custom error message
  */
-function formatError(err, name = 'sftp', eCode, retryCount) {
+function fmtError(err, name = 'sftp', eCode, retryCount) {
   let msg = '';
   let code = '';
   let retry = retryCount
@@ -46,9 +45,6 @@ function formatError(err, name = 'sftp', eCode, retryCount) {
           `${name}: Remote host has reset the connection: ` +
           `${err.message}${retry}`;
         break;
-      case 'ENOENT':
-        msg = `${name}: ${err.message}${retry}`;
-        break;
       default:
         msg = `${name}: ${err.message}${retry}`;
     }
@@ -60,44 +56,6 @@ function formatError(err, name = 'sftp', eCode, retryCount) {
   return newError;
 }
 
-/**
- * Tests an error to see if it is one which has already been customised
- * by this module or not. If not, applies appropriate customisation.
- *
- * @param {Error} err - an Error object
- * @param {String} name - name to be used in customised error message
- * @param {Function} reject - If defined, call this function instead of
- *                            throwing the error
- * @throws {Error}
- */
-function handleError(err, name, reject) {
-  if (reject) {
-    if (err.custom) {
-      reject(err);
-    } else {
-      reject(formatError(err, name));
-    }
-  } else {
-    if (err.custom) {
-      throw err;
-    } else {
-      throw formatError(err, name, err.code);
-    }
-  }
-}
-
-/**
- * Remove all ready, error and end listeners.
- *
- * @param {Emitter} emitter - The emitter object to remove listeners from
- */
-function removeListeners(emitter) {
-  let listeners = emitter.eventNames();
-  listeners.forEach((name) => {
-    emitter.removeAllListeners(name);
-  });
-}
-
 let tempListeners = [];
 
 /**
@@ -108,13 +66,13 @@ let tempListeners = [];
  * @throws {Error} Throws new error
  */
 function errorListener(client, name, reject) {
-  let fn = function (err) {
+  let fn = (err) => {
     if (!client.errorHandled) {
       client.errorHandled = true;
       if (reject) {
-        reject(formatError(err, name, err.code));
+        reject(fmtError(err, name, err.code));
       } else {
-        throw formatError(err, name, err.code);
+        throw fmtError(err, name, err.code);
       }
     }
     client.debugMsg(`Handled Error: ${err.message} ${err.code}`);
@@ -125,15 +83,15 @@ function errorListener(client, name, reject) {
 
 function endListener(client, name, reject) {
   let fn = function () {
+    client.debugMsg(`Handled end event for ${name}`);
     if (!client.endCalled) {
+      client.sftp = undefined;
       if (reject) {
-        reject(formatError('Unexpected end event raised', name));
+        reject(fmtError('Unexpected end event raised', name));
       } else {
-        throw formatError('Unexpected end event raised', name);
+        throw fmtError('Unexpected end event raised', name);
       }
     }
-    client.debugMsg(`Handled end event for ${name}`);
-    client.sftp = undefined;
   };
   tempListeners.push(['end', fn]);
   return fn;
@@ -141,15 +99,15 @@ function endListener(client, name, reject) {
 
 function closeListener(client, name, reject) {
   let fn = function () {
+    client.debugMsg(`handled close event for ${name}`);
     if (!client.endCalled) {
+      client.sftp = undefined;
       if (reject) {
-        reject(formatError('Unexpected close event raised', name));
+        reject(fmtError('Unexpected close event raised', name));
       } else {
-        throw formatError('Unexpected close event raised', name);
+        throw fmtError('Unexpected close event raised', name);
       }
     }
-    client.debugMsg(`handled close event for ${name}`);
-    client.sftp = undefined;
   };
   tempListeners.push(['close', fn]);
   return fn;
@@ -213,7 +171,7 @@ async function normalizeRemotePath(client, aPath) {
     }
     return aPath;
   } catch (err) {
-    throw formatError(err, 'normalizeRemotePath');
+    throw fmtError(err, 'normalizeRemotePath');
   }
 }
 
@@ -229,7 +187,7 @@ async function normalizeRemotePath(client, aPath) {
  */
 function haveConnection(client, name, reject) {
   if (!client.sftp) {
-    let newError = formatError(
+    let newError = fmtError(
       'No SFTP connection available',
       name,
       errorCode.connect
@@ -244,31 +202,8 @@ function haveConnection(client, name, reject) {
   return true;
 }
 
-function dumpListeners(emitter) {
-  let eventNames = emitter.eventNames();
-  if (eventNames.length) {
-    console.log('Listener Data');
-    eventNames.map((n) => {
-      let listeners = emitter.listeners(n);
-      console.log(`${n}: ${emitter.listenerCount(n)}`);
-      console.dir(listeners);
-      listeners.map((l) => {
-        console.log(`listener name = ${l.name}`);
-      });
-    });
-  }
-}
-
-function hasListener(emitter, eventName, listenerName) {
-  let listeners = emitter.listeners(eventName);
-  let matches = listeners.filter((l) => l.name == listenerName);
-  return matches.length === 0 ? false : true;
-}
-
 module.exports = {
-  formatError,
-  handleError,
-  removeListeners,
+  fmtError,
   errorListener,
   endListener,
   closeListener,
@@ -276,7 +211,5 @@ module.exports = {
   removeTempListeners,
   localExists,
   normalizeRemotePath,
-  haveConnection,
-  dumpListeners,
-  hasListener
+  haveConnection
 };