ssh2-sftp-client 6.0.1 → 7.0.0

package/src/index.js

@@ -4,20 +4,20 @@
 
 'use strict';
 
-const {Client} = require('ssh2');
+const { Client } = require('ssh2');
 const fs = require('fs');
 const concat = require('concat-stream');
 const promiseRetry = require('promise-retry');
-const {join, parse} = require('path');
+const { join, parse } = require('path');
 const {
   fmtError,
   addTempListeners,
   removeTempListeners,
   haveConnection,
   normalizeRemotePath,
-  localExists
+  localExists,
 } = require('./utils');
-const {errorCode} = require('./constants');
+const { errorCode } = require('./constants');
 
 class SftpClient {
   constructor(clientName) {
@@ -32,21 +32,30 @@ class SftpClient {
 
     this.client.on('close', () => {
       if (!this.endCalled) {
-        this.debugMsg('Unexpected close event raised by server');
+        this.debugMsg(
+          `${this.clientName}: Unexpected close event raised by server`
+        );
         this.sftp = undefined;
       }
     });
+
     this.client.on('end', () => {
       if (!this.endCalled) {
-        this.debugMsg('Unexpected end event raised by server');
+        this.debugMsg(
+          `${this.clientName}: Unexpected end event raised by server`
+        );
         this.sftp = undefined;
       }
     });
+
     this.client.on('error', (err) => {
       if (!this.errorHandled) {
+        this.debugMsg(
+          `${this.clientName}: Global Error Handler: ${err.message}`
+        );
         throw fmtError(
           `Unexpected error: ${err.message}`,
-          'global-error-handler',
+          `${this.clientName}: global error handler`,
           err.code
         );
       } else {
@@ -97,28 +106,37 @@ class SftpClient {
    * @return {Promise} which will resolve to an sftp client object
    *
    */
-  sftpConnect(config) {
-    let connectReady;
-
+  getConnection(config) {
+    let doReady;
     return new Promise((resolve, reject) => {
       addTempListeners(this, 'sftpConnect', reject);
-      connectReady = () => {
-        this.client.sftp((err, sftp) => {
-          if (err) {
-            this.debugMsg(`SFTP channel error: ${err.message} ${err.code}`);
-            reject(fmtError(err, 'sftpConnect', err.code));
-          } else {
-            this.debugMsg('SFTP channel established');
-            resolve(sftp);
-          }
-        });
+      doReady = () => {
+        resolve(true);
       };
-      // addTempListeners(this, 'sftpConnect', reject);
-      this.client.on('ready', connectReady).connect(config);
-    }).finally((rsp) => {
-      this.removeListener('ready', connectReady);
-      removeTempListeners(this.client);
-      return rsp;
+      this.client.on('ready', doReady);
+      this.client.connect(config);
+    })
+      .catch((err) => {
+        return Promise.reject(err);
+      })
+      .finally((resp) => {
+        this.removeListener('ready', doReady);
+        removeTempListeners(this);
+        return resp;
+      });
+  }
+
+  getSftpChannel() {
+    return new Promise((resolve, reject) => {
+      this.client.sftp((err, sftp) => {
+        if (err) {
+          this.debugMsg(`SFTP Channel Error: ${err.message}`);
+          reject(fmtError(err, 'getSftpChannel', err.code));
+        } else {
+          this.sftp = sftp;
+          resolve(sftp);
+        }
+      });
     });
   }
 
@@ -140,17 +158,17 @@ class SftpClient {
     return promiseRetry(
       (retry, attempt) => {
         this.debugMsg(`Connect attempt ${attempt}`);
-        return this.sftpConnect(config).catch((err) => {
+        return this.getConnection(config).catch((err) => {
           retry(err);
         });
       },
       {
         retries: config.retries || 1,
         factor: config.retry_factor || 2,
-        minTimeout: config.retry_minTimeout || 1000
+        minTimeout: config.retry_minTimeout || 1000,
       }
-    ).then((sftp) => {
-      this.sftp = sftp;
+    ).then(() => {
+      return this.getSftpChannel();
     });
   }
 
@@ -187,7 +205,7 @@ class SftpClient {
         });
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -238,12 +256,12 @@ class SftpClient {
               isCharacterDevice: stats.isCharacterDevice(),
               isSymbolicLink: stats.isSymbolicLink(),
               isFIFO: stats.isFIFO(),
-              isSocket: stats.isSocket()
+              isSocket: stats.isSocket(),
             });
           }
         });
       }).finally((rsp) => {
-        removeTempListeners(this.client);
+        removeTempListeners(this);
         return rsp;
       });
     };
@@ -350,10 +368,10 @@ class SftpClient {
                   rights: {
                     user: item.longname.substr(1, 3).replace(reg, ''),
                     group: item.longname.substr(4, 3).replace(reg, ''),
-                    other: item.longname.substr(7, 3).replace(reg, '')
+                    other: item.longname.substr(7, 3).replace(reg, ''),
                   },
                   owner: item.attrs.uid,
-                  group: item.attrs.gid
+                  group: item.attrs.gid,
                 };
               });
             }
@@ -370,7 +388,7 @@ class SftpClient {
         });
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -385,33 +403,44 @@ class SftpClient {
    *
    * @param {String} path, remote file path
    * @param {string|stream|undefined} dst, data destination
-   * @param {Object} userOptions, options passed to get
+   * @param {Object} options, options object with supported properties of readStreamOptions,
+   *                          writeStreamOptions and pipeOptions.
    *
    * @return {Promise}
    */
-  get(remotePath, dst, options = {}) {
+  get(
+    remotePath,
+    dst,
+    options = { readStreamOptions: {}, writeStreamOptions: {}, pipeOptions: {} }
+  ) {
+    let rdr, wtr;
+
     return new Promise((resolve, reject) => {
       if (haveConnection(this, 'get', reject)) {
         this.debugMsg(`get -> ${remotePath} `, options);
         addTempListeners(this, 'get', reject);
-        let rdr = this.sftp.createReadStream(remotePath, options);
+        rdr = this.sftp.createReadStream(
+          remotePath,
+          options.readStreamOptions ? options.readStreamOptions : {}
+        );
         rdr.once('error', (err) => {
           reject(fmtError(`${err.message} ${remotePath}`, 'get', err.code));
         });
         if (dst === undefined) {
           // no dst specified, return buffer of data
           this.debugMsg('get returning buffer of data');
-          let concatStream = concat((buff) => {
-            rdr.removeAllListeners('error');
+          wtr = concat((buff) => {
+            //rdr.removeAllListeners('error');
             resolve(buff);
           });
-          rdr.pipe(concatStream);
         } else {
-          let wtr;
           if (typeof dst === 'string') {
             // dst local file path
             this.debugMsg('get returning local file');
-            wtr = fs.createWriteStream(dst);
+            wtr = fs.createWriteStream(
+              dst,
+              options.writeStreamOptions ? options.writeStreamOptions : {}
+            );
           } else {
             this.debugMsg('get returning data into supplied stream');
             wtr = dst;
@@ -424,25 +453,34 @@ class SftpClient {
                 err.code
               )
             );
-            if (options.autoClose === false) {
-              rdr.destroy();
-            }
           });
-          wtr.once('finish', () => {
-            if (options.autoClose === false) {
-              rdr.destroy();
-            }
+          rdr.once('end', () => {
             if (typeof dst === 'string') {
               resolve(dst);
             } else {
               resolve(wtr);
             }
           });
-          rdr.pipe(wtr);
         }
+        rdr.pipe(wtr, options.pipeOptions ? options.pipeOptions : {});
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
+      if (
+        rdr &&
+        options.readStreamOptions &&
+        options.readStreamOptions.autoClose === false
+      ) {
+        rdr.destroy();
+      }
+      if (
+        wtr &&
+        options.writeStreamOptions &&
+        options.writeStreamOptions.autoClose === false &&
+        typeof dst === 'string'
+      ) {
+        wtr.destroy();
+      }
       return rsp;
     });
   }
@@ -490,7 +528,7 @@ class SftpClient {
             });
           }
         }).finally((rsp) => {
-          removeTempListeners(this.client);
+          removeTempListeners(this);
           return rsp;
         });
       });
@@ -511,60 +549,42 @@ class SftpClient {
    */
   fastPut(localPath, remotePath, options) {
     this.debugMsg(`fastPut -> local ${localPath} remote ${remotePath}`);
-    return localExists(localPath)
-      .then((localStatus) => {
-        this.debugMsg(`fastPut <- localStatus ${localStatus}`);
-        if (localStatus !== '-') {
-          this.debugMsg('fastPut reject bad source path');
-          return Promise.reject(
-            fmtError(`Bad path ${localPath}`, 'fastPut', errorCode.badPath)
+    return localExists(localPath).then((localStatus) => {
+      this.debugMsg(`fastPut <- localStatus ${localStatus}`);
+      if (localStatus !== '-') {
+        this.debugMsg('fastPut reject bad source path');
+        return Promise.reject(
+          fmtError(`Bad path ${localPath}`, 'fastPut', errorCode.badPath)
+        );
+      }
+      return new Promise((resolve, reject) => {
+        if (haveConnection(this, 'fastPut', reject)) {
+          this.debugMsg(
+            `fastPut -> local: ${localPath} remote: ${remotePath} opts: ${JSON.stringify(
+              options
+            )}`
           );
-        }
-        return new Promise((resolve, reject) => {
-          fs.access(localPath, fs.constants.F_OK | fs.constants.R_OK, (err) => {
+          addTempListeners(this, 'fastPut', reject);
+          this.sftp.fastPut(localPath, remotePath, options, (err) => {
             if (err) {
-              this.debugMsg('fastPut reject no access source');
+              this.debugMsg(`fastPut error ${err.message} ${err.code}`);
               reject(
-                fmtError(`${err.message} ${localPath}`, 'fastPut', err.code)
+                fmtError(
+                  `${err.message} Local: ${localPath} Remote: ${remotePath}`,
+                  'fastPut',
+                  err.code
+                )
               );
-            } else {
-              this.debugMsg('fastPut source access ok');
-              resolve(true);
             }
+            this.debugMsg('fastPut file transferred');
+            resolve(`${localPath} was successfully uploaded to ${remotePath}!`);
           });
-        });
-      })
-      .then(() => {
-        return new Promise((resolve, reject) => {
-          if (haveConnection(this, 'fastPut', reject)) {
-            this.debugMsg(
-              `fastPut -> local: ${localPath} remote: ${remotePath} opts: ${JSON.stringify(
-                options
-              )}`
-            );
-            addTempListeners(this, 'fastPut', reject);
-            this.sftp.fastPut(localPath, remotePath, options, (err) => {
-              if (err) {
-                this.debugMsg(`fastPut error ${err.message} ${err.code}`);
-                reject(
-                  fmtError(
-                    `${err.message} Local: ${localPath} Remote: ${remotePath}`,
-                    'fastPut',
-                    err.code
-                  )
-                );
-              }
-              this.debugMsg('fastPut file transferred');
-              resolve(
-                `${localPath} was successfully uploaded to ${remotePath}!`
-              );
-            });
-          }
-        }).finally((rsp) => {
-          removeTempListeners(this.client);
-          return rsp;
-        });
+        }
+      }).finally((rsp) => {
+        removeTempListeners(this);
+        return rsp;
       });
+    });
   }
 
   /**
@@ -574,100 +594,95 @@ class SftpClient {
    *
    * @param  {String|Buffer|stream} src - source data to use
    * @param  {String} remotePath - path to remote file
-   * @param  {Object} options - options used for write stream configuration
-   *                            value supported by node streams.
+   * @param  {Object} options - options used for read, write stream and pipe configuration
+   *                            value supported by node. Allowed properties are readStreamOptions,
+   *                            writeStreamOptions and pipeOptions.
    * @return {Promise}
    */
-  put(localSrc, remotePath, options = {}) {
-    this.debugMsg(
-      `put ${
-        typeof localSrc === 'string' ? localSrc : '<buffer | stream>'
-      } -> ${remotePath}`,
-      options
-    );
-    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(
-            fmtError(`Bad path ${localSrc}`, 'put', errorCode.badPath)
+  doPut(
+    localSrc,
+    remotePath,
+    options = { readStreamOptions: {}, writeStreamOptions: {}, pipeOptions: {} }
+  ) {
+    let wtr, rdr;
+
+    return new Promise((resolve, reject) => {
+      addTempListeners(this, 'put', reject);
+      wtr = this.sftp.createWriteStream(
+        remotePath,
+        options.writeStreamOptions ? options.writeStreamOptions : {}
+      );
+      wtr.once('error', (err) => {
+        reject(fmtError(`${err.message} ${remotePath}`, 'put', err.code));
+      });
+      wtr.once('finish', () => {
+        resolve(`Uploaded data stream to ${remotePath}`);
+      });
+      if (localSrc instanceof Buffer) {
+        this.debugMsg('put source is a buffer');
+        wtr.end(localSrc);
+      } else {
+        if (typeof localSrc === 'string') {
+          this.debugMsg(`put source is a file path: ${localSrc}`);
+          rdr = fs.createReadStream(
+            localSrc,
+            options.readStreamOptions ? options.readStreamOptons : {}
           );
+        } else {
+          this.debugMsg('put source is a stream');
+          rdr = localSrc;
         }
-        return new Promise((resolve, reject) => {
-          if (typeof localSrc === 'string') {
-            fs.access(
-              localSrc,
-              fs.constants.F_OK | fs.constants.R_OK,
-              (err) => {
-                if (err) {
-                  this.debugMsg(`put: Cannot read ${localSrc} - rejecting`);
-                  reject(
-                    fmtError(
-                      `Permission denied ${localSrc}`,
-                      'put',
-                      errorCode.permission
-                    )
-                  );
-                } else {
-                  this.debugMsg('put: localSrc file OK');
-                  resolve(true);
-                }
-              }
-            );
-          } else {
-            this.debugMsg('put: localSrc buffer or string OK');
-            resolve(true);
-          }
-        });
-      })
-      .then(() => {
-        return new Promise((resolve, reject) => {
-          if (haveConnection(this, 'put', reject)) {
-            addTempListeners(this, 'put', reject);
-            let stream = this.sftp.createWriteStream(remotePath, options);
-            stream.once('error', (err) => {
-              reject(fmtError(`${err.message} ${remotePath}`, 'put', err.code));
-            });
-            stream.once('finish', () => {
-              if (options.autoClose === false) {
-                stream.destroy();
-              }
-              resolve(`Uploaded data stream to ${remotePath}`);
-            });
-            if (localSrc instanceof Buffer) {
-              this.debugMsg('put source is a buffer');
-              stream.end(localSrc);
-            } else {
-              let rdr;
-              if (typeof localSrc === 'string') {
-                this.debugMsg(`put source is a file path: ${localSrc}`);
-                rdr = fs.createReadStream(localSrc);
-              } else {
-                this.debugMsg('put source is a stream');
-                rdr = localSrc;
-              }
-              rdr.once('error', (err) => {
-                reject(
-                  fmtError(
-                    `${err.message} ${
-                      typeof localSrc === 'string' ? localSrc : ''
-                    }`,
-                    'put',
-                    err.code
-                  )
-                );
-                if (options.autoClose === false) {
-                  stream.destroy();
-                }
-              });
-              rdr.pipe(stream);
-            }
-          }
-        }).finally((rsp) => {
-          removeTempListeners(this.client);
-          return rsp;
+        rdr.once('error', (err) => {
+          reject(
+            fmtError(
+              `${err.message} ${typeof localSrc === 'string' ? localSrc : ''}`,
+              'put',
+              err.code
+            )
+          );
         });
-      });
+        rdr.pipe(wtr, options.pipeOptions ? options.pipeOptions : {});
+      }
+    }).finally((resp) => {
+      removeTempListeners(this);
+      if (
+        rdr &&
+        options.readStreamOptions &&
+        options.readStreamOptions.autoClose === false &&
+        typeof localSrc === 'string'
+      ) {
+        rdr.destroy();
+      }
+      if (
+        wtr &&
+        options.writeStreamOptions &&
+        options.writeStreamOptions.autoClose === false
+      ) {
+        wtr.destroy();
+      }
+      return resp;
+    });
+  }
+
+  async put(
+    localSrc,
+    remoePath,
+    options = { readStreamOptions: {}, writeStreamOptions: {}, pipeOptions: {} }
+  ) {
+    try {
+      haveConnection(this, 'put');
+      if (typeof localSrc === 'string') {
+        let type = await localExists(localSrc);
+        if (type !== '-' && type !== 'l') {
+          let err = new Error(`Bad path: ${localSrc}`);
+          err.code = errorCode.badPath;
+          throw err;
+        }
+      }
+      return await this.doPut(localSrc, remoePath, options);
+    } catch (err) {
+      throw fmtError(err, 'put');
+    }
   }
 
   /**
@@ -704,7 +719,7 @@ class SftpClient {
         }
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -731,7 +746,7 @@ class SftpClient {
           resolve(`${p} directory created`);
         });
       }).finally((rsp) => {
-        removeTempListeners(this.client);
+        removeTempListeners(this);
         return rsp;
       });
     };
@@ -782,7 +797,7 @@ class SftpClient {
           resolve('Successfully removed directory');
         });
       }).finally((rsp) => {
-        removeTempListeners(this.client);
+        removeTempListeners(this);
         return rsp;
       });
     };
@@ -848,7 +863,7 @@ class SftpClient {
         });
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -884,7 +899,7 @@ class SftpClient {
         });
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -921,7 +936,7 @@ class SftpClient {
         });
       }
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -947,7 +962,7 @@ class SftpClient {
         resolve('Successfully change file mode');
       });
     }).finally((rsp) => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       return rsp;
     });
   }
@@ -978,7 +993,7 @@ class SftpClient {
       }
       let dirEntries = fs.readdirSync(srcDir, {
         encoding: 'utf8',
-        withFileTypes: true
+        withFileTypes: true,
       });
       dirEntries = dirEntries.filter((item) => filter.test(item.name));
       for (let e of dirEntries) {
@@ -990,7 +1005,7 @@ class SftpClient {
           let src = join(srcDir, e.name);
           let dst = dstDir + this.remotePathSep + e.name;
           await this.fastPut(src, dst);
-          this.client.emit('upload', {source: src, destination: dst});
+          this.client.emit('upload', { source: src, destination: dst });
         } else {
           this.debugMsg(
             `uploadDir: File ignored: ${e.name} not a regular file`
@@ -1025,12 +1040,12 @@ class SftpClient {
       this.debugMsg(`downloadDir -> ${srcDir} ${dstDir}`);
       haveConnection(this, 'downloadDir');
       let fileList = await this.list(srcDir, filter);
-      let dstStatus = await localExists(dstDir);
+      let dstStatus = await localExists(dstDir, true);
       if (dstStatus && dstStatus !== 'd') {
         throw fmtError(`Bad path ${dstDir}`, 'downloadDir', errorCode.badPath);
       }
       if (!dstStatus) {
-        fs.mkdirSync(dstDir, {recursive: true});
+        fs.mkdirSync(dstDir, { recursive: true });
       }
       for (let f of fileList) {
         if (f.type === 'd') {
@@ -1041,7 +1056,7 @@ class SftpClient {
           let src = srcDir + this.remotePathSep + f.name;
           let dst = join(dstDir, f.name);
           await this.fastGet(src, dst);
-          this.client.emit('download', {source: src, destination: dst});
+          this.client.emit('download', { source: src, destination: dst });
         } else {
           this.debugMsg(
             `downloadDir: File ignored: ${f.name} not regular file`
@@ -1079,7 +1094,7 @@ class SftpClient {
         this.client.end();
       }
     }).finally(() => {
-      removeTempListeners(this.client);
+      removeTempListeners(this);
       this.removeListener('close', endCloseHandler);
       return true;
     });