@cysonius/sftp-utils - npm Package Compare versions

Comparing version 0.0.4 to 0.0.5

index.js

@@ -5,34 +5,94 @@ const checkTypes=require('check-types');
 const nodePath=require('path');
+const EventEmitter = require("events").EventEmitter;
 
+class SFTP extends EventEmitter{
+    constructor(config){
+        super();
+        if (!config)throw new Error("Invalid SFTP Config");
+        if (!config.host)throw new Error("Invalid SFTP Config");
 
-class SFTP{
-    constructor(sftp,conn){
-        this._sftp=sftp;
-        this._conn=conn;
+        this._sftp=null;
+        this._conn=null;
+        this._connActive=false;
+        this.config=config;
+        let baseObj=this;
     }
 
-    static load(serverConfig,callback){
-        if (!serverConfig)return callback({message:"Invalid Server Config",statusCode:400});
-        if (!serverConfig.host)return callback({message:"Invalid Server Config",statusCode:400});
 
-        var conn = new Client();
-        conn.on('ready', function() {
-            conn.sftp(function(err, sftp) {
-                if (err) return callback(SFTP._formatSFTPError(err));
-                return callback(null,new SFTP(sftp,conn));
+
+    getSFtp(callback){
+        let baseObj=this;
+        if (baseObj._sftp&&baseObj._connActive)return callback(null,baseObj._sftp);
+
+
+        let retry={
+            times:1,
+            interval:5000
+        }
+        let retryCnt=0;
+        let sftpConfig={
+            host: baseObj.config.host,
+            port: baseObj.config.port?baseObj.config.port:22,
+            username: baseObj.config.username,
+            password: baseObj.config.password,
+            algorithms:baseObj.config.algorithms,
+            privateKey:baseObj.config.privateKey,
+            passphrase:baseObj.config.passphrase
+        }
+
+        if (baseObj.config.keepaliveInterval)sftpConfig.keepaliveInterval=baseObj.config.keepaliveInterval;
+        if (baseObj.config.keepaliveCountMax)sftpConfig.keepaliveCountMax=baseObj.config.keepaliveCountMax;
+        if (baseObj.config.readyTimeout)sftpConfig.readyTimeout=baseObj.config.readyTimeout;
+
+        if (baseObj.config.connectionRetry)retry.times=baseObj.config.connectionRetry;
+
+
+        function connectToSftp(stepCallback){
+            let conn = new Client();
+            retryCnt++;
+            conn.on('ready', function() {
+                conn.sftp(function(err, sftp) {
+                    if (err) return stepCallback(SFTP._formatSFTPError(err));
+                    return stepCallback(null,sftp,conn);
+                });
+            }).on('error',function(err){
+                return stepCallback(SFTP._formatSFTPError(err));
+            }).connect(sftpConfig);
+        }
+
+        async.retry(retry,connectToSftp,function(err,sftp,conn){
+            if (err)return callback(err,null,retryCnt);
+            baseObj._sftp=sftp;
+            baseObj._conn=conn;
+            baseObj._connActive=true;
+
+            conn.on('error',function(err){
+                baseObj._connActive=false;
+                baseObj._conn=null;
+                baseObj._sftp=null;
+                baseObj.emit('error',err);
             });
-        }).on('error',function(err){
-            return callback(SFTP._formatSFTPError(err));
-        }).connect({
-            host: serverConfig.host,
-            port: serverConfig.port?serverConfig.port:22,
-            username: serverConfig.username,
-            password: serverConfig.password,
-            readyTimeout:serverConfig.readyTimeout,
-            algorithms:serverConfig.algorithms,
-            privateKey:serverConfig.privateKey,
-            passphrase:serverConfig.passphrase
+
+            conn.on('end',function(){
+                baseObj._connActive=false;
+                baseObj._conn=null;
+                baseObj._sftp=null;
+                baseObj.emit('end');
+            });
+
+
+            conn.on('close',function(hadErr){
+                baseObj._connActive=false;
+                baseObj._conn=null;
+                baseObj._sftp=null;
+                baseObj.emit('close',hadErr);
+            });
+            baseObj.emit('ready');
+
+            return callback(null,baseObj._sftp,retryCnt);
         });
+
     }
 
+
     close(){
@@ -44,27 +104,30 @@ if (this._conn)this._conn.end();
         let baseObj=this;
-        let reg = /-/gi;
-        baseObj._sftp.readdir(path,{},function(err,list){
-            if (err)return callback(SFTP._formatSFTPError(err));
-            if (list&&list.length>0){
-                return callback(null,list.map(function(doc) {
-                    return {
-                        type: doc.longname.substr(0, 1),
-                        name: doc.filename,
-                        size: doc.attrs.size,
-                        modifyTime: doc.attrs.mtime * 1000,
-                        accessTime: doc.attrs.atime * 1000,
-                        rights: {
-                            user: doc.longname.substr(1, 3).replace(reg, ''),
-                            group: doc.longname.substr(4,3).replace(reg, ''),
-                            other: doc.longname.substr(7, 3).replace(reg, '')
-                        },
-                        owner: doc.attrs.uid,
-                        group: doc.attrs.gid
-                    }
-                }));
-            }else{
-                return callback();
-            }
+        baseObj.getSFtp(function(err,sftp) {
+            if (err)return callback(err);
+
+            let reg = /-/gi;
+            sftp.readdir(path, {}, function (err, list) {
+                if (err)return callback(SFTP._formatSFTPError(err));
+                if (list && list.length > 0) {
+                    return callback(null, list.map(function (doc) {
+                        return {
+                            type: doc.longname.substr(0, 1),
+                            name: doc.filename,
+                            size: doc.attrs.size,
+                            modifyTime: doc.attrs.mtime * 1000,
+                            accessTime: doc.attrs.atime * 1000,
+                            rights: {
+                                user: doc.longname.substr(1, 3).replace(reg, ''),
+                                group: doc.longname.substr(4, 3).replace(reg, ''),
+                                other: doc.longname.substr(7, 3).replace(reg, '')
+                            },
+                            owner: doc.attrs.uid,
+                            group: doc.attrs.gid
+                        }
+                    }));
+                } else {
+                    return callback();
+                }
+            });
         });
-
     }
@@ -74,9 +137,7 @@
         let baseObj=this;
-        baseObj._sftp.stat(path, function(err, stats) {
-            if (err&&err.code===2)
-                return callback(null,false);
-            else if(err)
-                return callback(SFTP._formatSFTPError(err));
-            else
-                return callback(null,true);
+        baseObj.getSFtp(function(err,sftp) {
+            if (err)return callback(err);
+            sftp.exists(path, function(exists) {
+                return callback(null,exists);
+            });
         });
@@ -88,30 +149,33 @@ }
         let baseObj=this;
-        if (!options)options={};
+        baseObj.getSFtp(function(err,sftp) {
+            if (err)return callback(err);
 
-        makeRecursiveDirectory(path,function(err){
-            return callback(err);
-        });
+            if (!options) options = {};
 
-        function makeRecursiveDirectory(curPath,callback){
-            let paths=curPath.split('/');
-            let workingPath="";
-            async.eachSeries(paths,
-                function(item,itemCallback){
-                    if (!item)return itemCallback();
-                    workingPath=nodePath.join(workingPath,item);
-                    baseObj._sftp.stat(workingPath, function(err, stats) {
-                        if (err && err.code !== 2)return itemCallback(SFTP._formatSFTPError(err));
-                        if (!err)return itemCallback();
+            makeRecursiveDirectory(path, function (err) {
+                return callback(err);
+            });
 
-                        baseObj._sftp.mkdir(workingPath, {}, function (err) {
-                            return itemCallback(SFTP._formatSFTPError(err));
+            function makeRecursiveDirectory(curPath, callback) {
+                let paths = curPath.split('/');
+                let workingPath = "";
+                async.eachSeries(paths,
+                    function (item, itemCallback) {
+                        if (!item)return itemCallback();
+                        workingPath = nodePath.join(workingPath, item);
+                        sftp.stat(workingPath, function (err, stats) {
+                            if (err && err.code !== 2)return itemCallback(SFTP._formatSFTPError(err));
+                            if (!err)return itemCallback();
+
+                            sftp.mkdir(workingPath, {}, function (err) {
+                                return itemCallback(SFTP._formatSFTPError(err));
+                            });
                         });
+                    },
+                    function (err) {
+                        if (err)return callback(err);
+                        return callback();
                     });
-                },
-                function(err){
-                    if (err)return callback(err);
-                    return callback();
-                });
-        }
-
+            }
+        });
     }
@@ -121,31 +185,34 @@
         let baseObj=this;
-        recursePath(path,function(err){
-            return callback(err);
-        });
-        function recursePath(curPath,recurseCallback){
-            baseObj.listPath(curPath,function(err,list){
-                if (err)return recurseCallback(err);
-                if (!list||list.length===0){
-                    baseObj._sftp.rmdir(curPath,function(err){
-                        return recurseCallback(SFTP._formatSFTPError(err));
-                    });
-                }else{
-                    async.each(list,function(item,itemCallback){
-                        if (item.type==='d'){
-                            recursePath(nodePath.join(curPath,item.name),itemCallback);
-                        }else {
-                            baseObj._sftp.unlink(nodePath.join(curPath, item.name), function (err) {
-                                return itemCallback(SFTP._formatSFTPError(err));
-                            });
-                        }
-                    },function(err){
-                        if (err)return recurseCallback(err);
-                        baseObj._sftp.rmdir(curPath,function(err){
+        baseObj.getSFtp(function(err,sftp) {
+            if (err)return callback(err);
+            recursePath(path, function (err) {
+                return callback(err);
+            });
+            function recursePath(curPath, recurseCallback) {
+                baseObj.listPath(curPath, function (err, list) {
+                    if (err)return recurseCallback(err);
+                    if (!list || list.length === 0) {
+                       sftp.rmdir(curPath, function (err) {
                             return recurseCallback(SFTP._formatSFTPError(err));
                         });
-                    });
-                }
+                    } else {
+                        async.each(list, function (item, itemCallback) {
+                            if (item.type === 'd') {
+                                recursePath(nodePath.join(curPath, item.name), itemCallback);
+                            } else {
+                                sftp.unlink(nodePath.join(curPath, item.name), function (err) {
+                                    return itemCallback(SFTP._formatSFTPError(err));
+                                });
+                            }
+                        }, function (err) {
+                            if (err)return recurseCallback(err);
+                            sftp.rmdir(curPath, function (err) {
+                                return recurseCallback(SFTP._formatSFTPError(err));
+                            });
+                        });
+                    }
 
-            });
-        }
+                });
+            }
+        });
     }
@@ -156,23 +223,86 @@
         let baseObj=this;
-        let parsedFile=nodePath.parse(fromPath);
-        let toFile=nodePath.parse(toPath);
+        if (!options)options={};
+        baseObj.getSFtp(function(err,sftp) {
+            if (err)return callback(err);
+            let parsedFile = nodePath.parse(fromPath);
+            let toFile = nodePath.parse(toPath);
 
-        if (!toFile.ext)toFile=nodePath.join(toPath,parsedFile.base);
-        else toFile=toPath;
+            if (!toFile.ext) toFile = nodePath.join(toPath, parsedFile.base);
+            else toFile = toPath;
 
-        baseObj._sftp.rename(fromPath,toFile, function(err) {
-            return callback(SFTP._formatSFTPError(err));
+            if (options.overwrite){
+                baseObj.checkPathExists(toFile,function(err,exists){
+                    if (err)return callback(err);
+                    if (exists){
+                        baseObj.deletePath(toFile,null,function(err){
+                            if (err)return callback(err);
+                            else rename();
+                        });
+                    }
+                    else{
+                        rename();
+                    }
+                });
+            }else{
+                rename();
+            }
+
+
+            function rename(){
+                sftp.rename(fromPath, toFile, function (err) {
+                    return callback(SFTP._formatSFTPError(err));
+                });
+            }
+
         });
     }
 
-    get sftp(){
-        return this._sftp;
+
+    createWriteStream(path,callback){
+        let baseObj=this;
+        baseObj.getSFtp(function(err,sftp){
+            if (err)return callback(err);
+            return callback(null,sftp.createWriteStream(path));
+        });
     }
 
-    createWriteStream(path){
-        return this._sftp.createWriteStream(path);
+    createReadStream(path,callback){
+        let baseObj=this;
+        baseObj.getSFtp(function(err,sftp){
+            if (err)return callback(err);
+            return callback(null,sftp.createReadStream(path));
+        });
     }
 
-    createReadStream(path){
-        return this._sftp.createReadStream(path);
+    writeFile(path,data,options,callback){
+        let baseObj=this;
+        if (!options)options={};
+
+        if (options.overwrite){
+            baseObj.checkPathExists(path,function(err,exists){
+                if (err)return callback(err);
+                if (exists){
+                    baseObj.deletePath(path,null,function(err){
+                        if (err)return callback(err);
+                        else write();
+                    });
+                }
+                else{
+                    write();
+                }
+            });
+        }else{
+            write();
+        }
+
+        function write(){
+            baseObj.getSFtp(function(err,sftp){
+                if (err)return callback(err);
+                sftp.writeFile(path,data,{},function(err){
+                    if (err)return callback(SFTP._formatSFTPError(err));
+                    return callback();
+                });
+            });
+        }
+
     }
@@ -179,0 +309,0 @@

package.json

 {
   "name": "@cysonius/sftp-utils",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "sftp utils",
@@ -5,0 +5,0 @@ "author": {

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

11894

increased by59.76%

Lines of code

274

increased by65.06%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes