Add uploadFolder method

Rework Q to native Promise
Add returns after rejects

Author: Ivan Duplenskikh

Tasks/CopyFilesOverSSHV0/copyfilesoverssh.ts

@@ -225,66 +225,76 @@ async function run() {
             }
         }
 
-        // identify the files to copy
-        const filesToCopy: string[] = getFilesToCopy(sourceFolder, contents);
-
-        // copy files to remote machine
-        if (filesToCopy) {
-            tl.debug('Number of files to copy = ' + filesToCopy.length);
-            tl.debug('filesToCopy = ' + filesToCopy);
-
-            console.log(tl.loc('CopyingFiles', filesToCopy.length));
-            createRemoteFolders(filesToCopy, targetFolder, sourceFolder, flattenFolders);
-            
-            const results = await Promise.allSettled(filesToCopy.map(async (fileToCopy) => {
-                tl.debug('fileToCopy = ' + fileToCopy);
-
-                let relativePath;
-
-                if (flattenFolders) {
-                    relativePath = path.basename(fileToCopy);
-                } else {
-                    relativePath = fileToCopy.substring(sourceFolder.length)
-                        .replace(/^\\/g, "")
-                        .replace(/^\//g, "");
-                }
+        if (contents.length === 1 && contents[0] === "**") {
+            tl.debug("Upload all files to a remote machine");
+
+            try {
+                const completedDirectory = await sshHelper.uploadFolder(sourceFolder, targetFolder);
+                console.log(tl.loc('CopyDirectoryCompleted', completedDirectory));
+            } catch (err) {
+                throw tl.loc("CopyDirectoryFailed", sourceFolder, err);
+            }
+        } else {
+            // identify the files to copy
+            const filesToCopy: string[] = getFilesToCopy(sourceFolder, contents);
 
-                tl.debug('relativePath = ' + relativePath);
-                let targetPath = path.posix.join(targetFolder, relativePath);
+            // copy files to remote machine
+            if (filesToCopy) {
+                tl.debug('Number of files to copy = ' + filesToCopy.length);
+                tl.debug('filesToCopy = ' + filesToCopy);
 
-                if (!path.isAbsolute(targetPath) && !utils.pathIsUNC(targetPath)) {
-                    targetPath = `./${targetPath}`;
-                }
+                console.log(tl.loc('CopyingFiles', filesToCopy.length));
+                createRemoteFolders(filesToCopy, targetFolder, sourceFolder, flattenFolders);
 
-                console.log(tl.loc('StartedFileCopy', fileToCopy, targetPath));
+                const results = await Promise.allSettled(filesToCopy.map(async (fileToCopy) => {
+                    tl.debug('fileToCopy = ' + fileToCopy);
 
-                if (!overwrite) {
-                    const fileExists: boolean = await sshHelper.checkRemotePathExists(targetPath);
+                    let relativePath;
 
-                    if (fileExists) {
-                        throw tl.loc('FileExists', targetPath);
+                    if (flattenFolders) {
+                        relativePath = path.basename(fileToCopy);
+                    } else {
+                        relativePath = fileToCopy.substring(sourceFolder.length)
+                            .replace(/^\\/g, "")
+                            .replace(/^\//g, "");
                     }
-                }
 
-                targetPath = utils.unixyPath(targetPath);
-                // looks like scp can only handle one file at a time reliably
-                const uploadResult = await sshHelper.uploadFile(fileToCopy, targetPath);
-                return uploadResult;
-            }));
+                    tl.debug('relativePath = ' + relativePath);
+                    let targetPath = path.posix.join(targetFolder, relativePath);
 
-            var errors = results.filter(p => p.status === 'rejected') as PromiseRejectedResult[];
+                    if (!path.isAbsolute(targetPath) && !utils.pathIsUNC(targetPath)) {
+                        targetPath = `./${targetPath}`;
+                    }
 
-            if (errors.length > 0) {
-                errors.forEach(x => tl.error(x.reason));
-                tl.setResult(tl.TaskResult.Failed, tl.loc('NumberFailed', errors.length));
-            }
+                    console.log(tl.loc('StartedFileCopy', fileToCopy, targetPath));
 
-            var successedFiles = results.filter(p => p.status === 'fulfilled');
-            console.log(tl.loc('CopyCompleted', successedFiles.length));
-        } else if (failOnEmptySource) {
-            throw tl.loc('NothingToCopy');
-        } else {
-            tl.warning(tl.loc('NothingToCopy'));
+                    if (!overwrite) {
+                        const fileExists: boolean = await sshHelper.checkRemotePathExists(targetPath);
+
+                        if (fileExists) {
+                            throw tl.loc('FileExists', targetPath);
+                        }
+                    }
+
+                    targetPath = utils.unixyPath(targetPath);
+                    // looks like scp can only handle one file at a time reliably
+                    return sshHelper.uploadFile(fileToCopy, targetPath);
+                }));
+
+                var errors = results.filter(p => p.status === 'rejected') as PromiseRejectedResult[];
+
+                if (errors.length > 0) {
+                    errors.forEach(x => tl.error(x.reason));
+                    tl.setResult(tl.TaskResult.Failed, tl.loc('NumberFailed', errors.length));
+                }
+
+                var successedFiles = results.filter(p => p.status === 'fulfilled');
+                console.log(tl.loc('CopyCompleted', successedFiles.length));
+            } else if (failOnEmptySource) {
+                throw tl.loc('NothingToCopy');
+            } else {
+                tl.warning(tl.loc('NothingToCopy'));
+            }
         }
     } catch (err) {
         tl.setResult(tl.TaskResult.Failed, err);

Tasks/CopyFilesOverSSHV0/sshhelper.ts

@@ -1,6 +1,4 @@
-import Q = require('q');
 import tl = require('azure-pipelines-task-lib/task');
-const path = require('path');
 var Ssh2Client = require('ssh2').Client;
 var SftpClient = require('ssh2-sftp-client');
 
@@ -30,27 +28,27 @@ export class SshHelper {
     }
 
     private async setupSshClientConnection() : Promise<void> {
-        const defer = Q.defer<void>();
-        this.sshClient = new Ssh2Client();
-        this.sshClient.once('ready', () => {
-            defer.resolve();
-        }).once('error', (err) => {
-            defer.reject(tl.loc('ConnectionFailed', err));
-        }).connect(this.sshConfig);
-        await defer.promise;
+        return new Promise((resolve, reject) => {
+            this.sshClient = new Ssh2Client();
+            this.sshClient.once('ready', () => {
+                resolve();
+            }).once('error', (err) => {
+                reject(tl.loc('ConnectionFailed', err));
+            }).connect(this.sshConfig);
+        });
     }
 
     private async setupSftpConnection() : Promise<void> {
-        const defer = Q.defer<void>();
-        try {
-            this.sftpClient = new SftpClient();
-            await this.sftpClient.connect(this.sshConfig);
-            defer.resolve();
-        } catch (err) {
-            this.sftpClient = null;
-            defer.reject(tl.loc('ConnectionFailed', err));
-        }
-        await defer.promise;
+        return new Promise(async (resolve, reject) => {
+            try {
+                this.sftpClient = new SftpClient();
+                await this.sftpClient.connect(this.sshConfig);
+                resolve();
+            } catch (err) {
+                this.sftpClient = null;
+                reject(tl.loc('ConnectionFailed', err));
+            }
+        });
     }
 
     /**
@@ -106,16 +104,7 @@ export class SshHelper {
         return new Promise(async (resolve, reject) => {
             if (!this.sftpClient) {
                 reject(tl.loc('ConnectionNotSetup'));
-            }
-
-            const remotePath = path.dirname(dest);
-            
-            try {
-                if (!await this.sftpClient.exists(remotePath)) {
-                    await this.sftpClient.mkdir(remotePath, true);
-                }
-            } catch (error) {
-                reject(tl.loc('TargetNotCreated', remotePath));
+                return;
             }
 
             try {
@@ -124,36 +113,55 @@ export class SshHelper {
                 } else {
                     await this.sftpClient.put(sourceFile, dest);
                 }
+
                 resolve(dest);
             } catch (err) {
                 reject(tl.loc('UploadFileFailed', sourceFile, dest, err));
             }
         });
     }
 
+    async uploadFolder(sourceFolder: string, destFolder: string) : Promise<string> {
+        tl.debug('Upload ' + sourceFolder + ' to ' + destFolder + ' on remote machine.');
+
+        return new Promise(async (resolve, reject) => {
+            if (!this.sftpClient) {
+                reject(tl.loc('ConnectionNotSetup'));
+                return;
+            }
+
+            try {
+                await this.sftpClient.uploadDir(sourceFolder, destFolder);
+            } catch (err) {
+                reject(tl.loc('UploadFolderFailed', sourceFolder, destFolder, err));
+            }
+        });
+    }
+
     /**
      * Returns true if the path exists on remote machine, false if it does not exist
      * @param path
      * @returns {Promise<boolean>}
      */
     async checkRemotePathExists(path: string) : Promise<boolean> {
-        var defer = Q.defer<boolean>();
+        return new Promise(async (resolve, reject) => {
+            tl.debug(tl.loc('CheckingPathExistance', path));
 
-        tl.debug(tl.loc('CheckingPathExistance', path));
-        if(!this.sftpClient) {
-            defer.reject(tl.loc('ConnectionNotSetup'));
-        }
-        if (await this.sftpClient.exists(path)) {
-            //path exists
-            tl.debug(tl.loc('PathExists', path));
-            defer.resolve(true);
-        } else {
-            //path does not exist
-            tl.debug(tl.loc('PathNotExists', path));
-            defer.resolve(false);
-        }
+            if (!this.sftpClient) {
+                reject(tl.loc('ConnectionNotSetup'));
+                return;
+            }
 
-        return defer.promise;
+            if (await this.sftpClient.exists(path)) {
+                //path exists
+                tl.debug(tl.loc('PathExists', path));
+                resolve(true);
+            } else {
+                //path does not exist
+                tl.debug(tl.loc('PathNotExists', path));
+                resolve(false);
+            }
+        });
     }
 
     /**
@@ -162,58 +170,64 @@ export class SshHelper {
      * @param options
      * @returns {Promise<string>}
      */
-    runCommandOnRemoteMachine(command: string, options: RemoteCommandOptions) : Q.Promise<string> {
-        var defer = Q.defer<string>();
-        var stdErrWritten:boolean = false;
+    runCommandOnRemoteMachine(command: string, options: RemoteCommandOptions) : Promise<string> {
+        return new Promise((resolve, reject) => {
+            let stdErrWritten = false;
 
-        if(!this.sshClient) {
-            defer.reject(tl.loc('ConnectionNotSetup'));
-        }
+            if (!this.sshClient) {
+                reject(tl.loc('ConnectionNotSetup'));
+                return;
+            }
 
-        if(!options) {
-            tl.debug('Options not passed to runCommandOnRemoteMachine, setting defaults.');
-            var options = new RemoteCommandOptions();
-            options.failOnStdErr = true;
-        }
+            if (!options) {
+                tl.debug('Options not passed to runCommandOnRemoteMachine, setting defaults.');
+                const options = new RemoteCommandOptions();
+                options.failOnStdErr = true;
+            }
 
-        var cmdToRun = command;
-        if(cmdToRun.indexOf(';') > 0) {
-            //multiple commands were passed separated by ;
-            cmdToRun = cmdToRun.replace(/;/g, '\n');
-        }
-        tl.debug('cmdToRun = ' + cmdToRun);
+            let cmdToRun = command;
 
-        this.sshClient.exec(cmdToRun, (err, stream) => {
-            if(err) {
-                defer.reject(tl.loc('RemoteCmdExecutionErr', cmdToRun, err))
+            if (cmdToRun.indexOf(';') > 0) {
+                //multiple commands were passed separated by ;
+                cmdToRun = cmdToRun.replace(/;/g, '\n');
             }
-            stream.on('close', (code, signal) => {
-                tl.debug('code = ' + code + ', signal = ' + signal);
-                if(code && code != 0) {
-                    //non zero exit code - fail
-                    defer.reject(tl.loc('RemoteCmdNonZeroExitCode', cmdToRun, code));
-                } else {
-                    //no exit code or exit code of 0
 
-                    //based on the options decide whether to fail the build or not if data was written to STDERR
-                    if(stdErrWritten === true && options.failOnStdErr === true) {
-                        //stderr written - fail the build
-                        defer.reject(tl.loc('RemoteCmdExecutionErr', cmdToRun, tl.loc('CheckLogForStdErr')));
+            tl.debug('cmdToRun = ' + cmdToRun);
+
+            this.sshClient.exec(cmdToRun, (err, stream) => {
+                if (err) {
+                    reject(tl.loc('RemoteCmdExecutionErr', cmdToRun, err));
+                    return;
+                }
+
+                stream.on('close', (code, signal) => {
+                    tl.debug('code = ' + code + ', signal = ' + signal);
+
+                    if (code && code != 0) {
+                        //non zero exit code - fail
+                        reject(tl.loc('RemoteCmdNonZeroExitCode', cmdToRun, code));
                     } else {
-                        //success
-                        defer.resolve('0');
+                        //no exit code or exit code of 0
+
+                        //based on the options decide whether to fail the build or not if data was written to STDERR
+                        if (stdErrWritten === true && options.failOnStdErr === true) {
+                            //stderr written - fail the build
+                            reject(tl.loc('RemoteCmdExecutionErr', cmdToRun, tl.loc('CheckLogForStdErr')));
+                        } else {
+                            //success
+                            resolve('0');
+                        }
                     }
-                }
-            }).on('data', (data) => {
-                console.log(data);
-            }).stderr.on('data', (data) => {
+                }).on('data', (data) => {
+                    console.log(data);
+                }).stderr.on('data', (data) => {
                     stdErrWritten = true;
                     tl.debug('stderr = ' + data);
-                    if(data && data.toString().trim() !== '') {
+                    if (data && data.toString().trim() !== '') {
                         tl.error(data);
                     }
                 });
+            });
         });
-        return defer.promise;
     }
 }

Tasks/CopyFilesOverSSHV0/task.json

@@ -153,6 +153,8 @@
         "ConnectionFailed": "Failed to connect to remote machine. Verify the SSH service connection details. %s.",
         "ConnectionNotSetup": "SSH service connection is not set up.",
         "CopyCompleted": "Completed copying %s files to the remote machine.",
+        "CopyDirectoryCompleted": "Completed copying %s directory to the remote machine.",
+        "CopyDirectoryFailed": "Failed to copy %s directory to the remote machine. %s",
         "CopyingFiles": "Found %s files to copy to the remote machine.",
         "FailedOnFile": "Failed to copy %s. %s",
         "FileExists": "File %s cannot be copied to the remote machine because it already exists and the 'Overwrite' option is disabled.",
@@ -168,6 +170,7 @@
         "TargetNotCreated": "Unable to create target folder %s.",
         "CheckingPathExistance": "Checking if %s on the remote machine exists.",
         "PathExists": "%s exists on the remote machine",
-        "PathNotExists": "%s doesn't exist on the remote machine"
+        "PathNotExists": "%s doesn't exist on the remote machine",
+        "UploadFolderFailed": "Failed to upload folder %s to %s on remote machine. %s."
     }
 }