JenkinsQueueJob: Port recent fixes to releases/m105

Author: David Staheli

Tasks/JenkinsQueueJob/enternals.json

@@ -0,0 +1,9 @@
+{
+    "archivePackages": [
+        {
+            "archiveName": "7zip.zip",
+            "url": "https://vstsagenttools.blob.core.windows.net/tools/7zip/1/7zip.zip",
+            "dest": "./"
+        }
+    ]
+}

Tasks/JenkinsQueueJob/jenkinsqueuejobtask.ts

@@ -20,38 +20,72 @@ import JobQueue = jobqueue.JobQueue;
 import util = require('./util');
 
 export class TaskOptions {
-    serverEndpoint: string = tl.getInput('serverEndpoint', true);
-    serverEndpointUrl: string = tl.getEndpointUrl(this.serverEndpoint, false);
+    serverEndpoint: string;
+    serverEndpointUrl: string;
 
-    serverEndpointAuth: tl.EndpointAuthorization = tl.getEndpointAuthorization(this.serverEndpoint, false);
-    username: string = this.serverEndpointAuth['parameters']['username'];
-    password: string = this.serverEndpointAuth['parameters']['password'];
+    serverEndpointAuth: tl.EndpointAuthorization;
+    username: string;
+    password: string;
 
-    jobName: string = tl.getInput('jobName', true);
+    jobName: string;
 
-    captureConsole: boolean = tl.getBoolInput('captureConsole', true);
+    captureConsole: boolean;
     // capturePipeline is only possible if captureConsole mode is enabled
-    capturePipeline: boolean = this.captureConsole ? tl.getBoolInput('capturePipeline', true) : false;
+    capturePipeline: boolean;
 
-    pollIntervalMillis: number = 5000; // five seconds is what the Jenkins Web UI uses
+    pollIntervalMillis: number;
 
-    parameterizedJob: boolean = tl.getBoolInput('parameterizedJob', true);
+    parameterizedJob: boolean;
     // jobParameters are only possible if parameterizedJob is enabled
-    jobParameters: string[] = this.parameterizedJob ? tl.getDelimitedInput('jobParameters', '\n', false) : [];
+    jobParameters: string[];
 
-    jobQueueUrl: string = util.addUrlSegment(this.serverEndpointUrl, util.convertJobName(this.jobName)) + ((this.parameterizedJob) ? '/buildWithParameters?delay=0sec' : '/build?delay=0sec');
-    teamJobQueueUrl: string = util.addUrlSegment(this.serverEndpointUrl, '/team-build/build/' + this.jobName + '?delay=0sec');
-    teamPluginUrl: string = util.addUrlSegment(this.serverEndpointUrl, '/pluginManager/available');
+    jobQueueUrl: string;
+    teamJobQueueUrl: string;
+    teamPluginUrl: string;
 
-    strictSSL: boolean = ("true" !== tl.getEndpointDataParameter(this.serverEndpoint, "acceptUntrustedCerts", true));
+    teamBuildPluginAvailable: boolean;
+    saveResultsTo: string;
 
-    NO_CRUMB: string = 'NO_CRUMB';
-    crumb: string = this.NO_CRUMB;
+    strictSSL: boolean;
+
+    NO_CRUMB: string;
+    crumb: string;
 
     constructor() {
-        tl.debug('strictSSL=' + this.strictSSL);
+        this.serverEndpoint = tl.getInput('serverEndpoint', true);
+        this.serverEndpointUrl = tl.getEndpointUrl(this.serverEndpoint, false);
         tl.debug('serverEndpointUrl=' + this.serverEndpointUrl);
+        this.serverEndpointAuth = tl.getEndpointAuthorization(this.serverEndpoint, false);
+        this.username = this.serverEndpointAuth['parameters']['username'];
+        this.password = this.serverEndpointAuth['parameters']['password'];
+
+        this.jobName = tl.getInput('jobName', true);
+
+        this.captureConsole = tl.getBoolInput('captureConsole', true);
+        // capturePipeline is only possible if captureConsole mode is enabled
+        this.capturePipeline = this.captureConsole ? tl.getBoolInput('capturePipeline', true) : false;
+
+        this.pollIntervalMillis = 5000; // five seconds is what the Jenkins Web UI uses
+
+        this.parameterizedJob = tl.getBoolInput('parameterizedJob', true);
+        // jobParameters are only possible if parameterizedJob is enabled
+        this.jobParameters = this.parameterizedJob ? tl.getDelimitedInput('jobParameters', '\n', false) : [];
+
+        this.jobQueueUrl = util.addUrlSegment(this.serverEndpointUrl, util.convertJobName(this.jobName)) + ((this.parameterizedJob) ? '/buildWithParameters?delay=0sec' : '/build?delay=0sec');
         tl.debug('jobQueueUrl=' + this.jobQueueUrl);
+        this.teamJobQueueUrl = util.addUrlSegment(this.serverEndpointUrl, '/team-build/build/' + this.jobName + '?delay=0sec');
+        tl.debug('teamJobQueueUrl=' + this.teamJobQueueUrl);
+        this.teamPluginUrl = util.addUrlSegment(this.serverEndpointUrl, '/pluginManager/available');
+        tl.debug('teamPluginUrl=' + this.teamPluginUrl);
+
+        this.teamBuildPluginAvailable = false;
+        this.saveResultsTo = path.join(tl.getVariable('Build.StagingDirectory'), 'jenkinsResults');
+
+        this.strictSSL = ("true" !== tl.getEndpointDataParameter(this.serverEndpoint, "acceptUntrustedCerts", true));
+        tl.debug('strictSSL=' + this.strictSSL);
+
+        this.NO_CRUMB = 'NO_CRUMB';
+        this.crumb = this.NO_CRUMB;
     }
 }
 

Tasks/JenkinsQueueJob/job.ts

@@ -16,6 +16,8 @@ import JobSearch = jobsearch.JobSearch;
 import jobqueue = require('./jobqueue');
 import JobQueue = jobqueue.JobQueue;
 
+import unzip = require('./unzip');
+
 import * as Util from './util';
 
 export enum JobState {
@@ -26,7 +28,8 @@ export enum JobState {
     Done,      // 4
     Joined,    // 5
     Queued,    // 6
-    Cut        // 7
+    Cut,       // 7
+    Downloading// 8
 }
 
 export class Job {
@@ -98,6 +101,8 @@ export class Job {
             } else if (oldState == JobState.Streaming) {
                 validStateChange = (newState == JobState.Finishing);
             } else if (oldState == JobState.Finishing) {
+                validStateChange = (newState == JobState.Downloading || newState == JobState.Done);
+            } else if (oldState == JobState.Downloading) {
                 validStateChange = (newState == JobState.Done);
             } else if (oldState == JobState.Done || oldState == JobState.Joined || oldState == JobState.Cut) {
                 validStateChange = false; // these are terminal states
@@ -118,6 +123,8 @@ export class Job {
                     this.initialize();
                 } else if (this.state == JobState.Streaming) {
                     this.streamConsole();
+                } else if (this.state == JobState.Downloading) {
+                    this.downloadResults();
                 } else if (this.state == JobState.Finishing) {
                     this.finish();
                 } else {
@@ -143,6 +150,7 @@ export class Job {
         return this.state == JobState.New ||
             this.state == JobState.Locating ||
             this.state == JobState.Streaming ||
+            this.state == JobState.Downloading ||
             this.state == JobState.Finishing
     }
 
@@ -299,7 +307,11 @@ export class Job {
                     thisJob.debug("parsedBody for: " + resultUrl + ": " + JSON.stringify(parsedBody));
                     if (parsedBody.result) {
                         thisJob.setParsedExecutionResult(parsedBody);
-                        thisJob.stopWork(0, JobState.Done);
+                        if (thisJob.queue.taskOptions.teamBuildPluginAvailable) {
+                            thisJob.stopWork(0, JobState.Downloading);
+                        } else {
+                            thisJob.stopWork(0, JobState.Done);
+                        }
                     } else {
                         // result not updated yet -- keep trying
                         thisJob.stopWork(thisJob.queue.taskOptions.pollIntervalMillis, thisJob.state);
@@ -308,6 +320,81 @@ export class Job {
             }).auth(thisJob.queue.taskOptions.username, thisJob.queue.taskOptions.password, true);
         }
     }
+
+    downloadResults(): void {
+        var thisJob: Job = this;
+        var downloadUrl: string = Util.addUrlSegment(thisJob.executableUrl, 'team-results/zip');
+        tl.debug('downloadResults(), url:' + downloadUrl);
+
+        var downloadRequest = request.get({ url: downloadUrl, strictSSL: thisJob.queue.taskOptions.strictSSL })
+            .auth(thisJob.queue.taskOptions.username, thisJob.queue.taskOptions.password, true)
+            .on("error", err => {
+                Util.handleConnectionResetError(err); // something went bad
+                thisJob.stopWork(thisJob.queue.taskOptions.pollIntervalMillis, thisJob.state);
+            })
+            .on("response", response => {
+                tl.debug('downloadResults(), url:' + downloadUrl + ' , response.statusCode: ' + response.statusCode + ', response.statusMessage: ' + response.statusMessage);
+                if (response.statusCode == 404) { // expected if there are no results
+                    tl.debug('no results to download');
+                    thisJob.stopWork(0, JobState.Done);
+                } else if (response.statusCode == 200) { // successfully found results
+                    var destinationFolder: string = path.join(thisJob.queue.taskOptions.saveResultsTo, thisJob.name + '/')
+                    var fileName = path.join(destinationFolder, 'team-results.zip');
+
+                    try {
+                        // Create the destination folder if it doesn't exist
+                        if (!tl.exist(destinationFolder)) {
+                            tl.debug('creating results destination folder: ' + destinationFolder);
+                            tl.mkdirP(destinationFolder);
+                        }
+
+                        tl.debug('downloading results file: ' + fileName);
+
+                        let file = fs.createWriteStream(fileName);
+                        downloadRequest.pipe(file)
+                            .on("error", err => { throw err; })
+                            .on("finish", function fileFinished() {
+                                tl.debug('successfully downloaded results to: ' + fileName);
+                                try {
+                                    unzip.unzip(fileName, destinationFolder);
+                                    thisJob.stopWork(0, JobState.Done);
+                                } catch (e) {
+                                    tl.warning('unable to extract results file')
+                                    tl.debug(e.message);
+                                    tl._writeError(e);
+                                    thisJob.stopWork(0, JobState.Done);
+                                }
+                            });
+                    } catch (e) {
+                        // don't fail the job if the results can not be downloaded successfully
+                        tl.warning('unable to download results to file: ' + fileName + ' for Jenkins Job: ' + thisJob.executableUrl);
+                        tl.warning(e.message);
+                        tl._writeError(e);
+                        thisJob.stopWork(0, JobState.Done);
+                    }
+                } else { // an unexepected error with results
+                    try {
+                        var warningMessage: string = (response.statusCode >= 500) ?
+                            'A Jenkins error occurred while retrieving results. Results could not be downloaded.' : // Jenkins server error
+                            'Jenkins results could not be downloaded.'; // Any other error
+                        tl.warning(warningMessage);
+                        var warningStream: any = new Util.StringWritable({ decodeStrings: false });
+                        downloadRequest.pipe(warningStream)
+                            .on("error", err => { throw err; })
+                            .on("finish", function finsished() {
+                                tl.warning(warningStream);
+                                thisJob.stopWork(0, JobState.Done);
+                            });
+                    } catch (e) {
+                        // don't fail the job if the results can not be downloaded successfully
+                        tl.warning(e.message);
+                        tl._writeError(e);
+                        thisJob.stopWork(0, JobState.Done);
+                    }
+                }
+            });
+    }
+
     /**
      * Streams the Jenkins console.
      * 

Tasks/JenkinsQueueJob/jobqueue.ts

@@ -83,7 +83,7 @@ export class JobQueue {
         var running = [];
         for (var i in this.allJobs) {
             var job = this.allJobs[i];
-            if (job.state == JobState.Streaming || job.state == JobState.Finishing) {
+            if (job.state == JobState.Streaming || job.state==JobState.Downloading || job.state == JobState.Finishing) {
                 running.push(job);
             }
         }

Tasks/JenkinsQueueJob/package.json

@@ -2,6 +2,6 @@
   "name": "vsts-tasks-jenkinsqueuejob",
   "dependencies": {
     "request": "^2.65.0",
-    "vsts-task-lib": "0.8.3"
+    "vsts-task-lib": "0.8.5"
   }
 }

Tasks/JenkinsQueueJob/task.json

@@ -14,7 +14,7 @@
     "version": {
         "Major": 1,
         "Minor": 0,
-        "Patch": 8
+        "Patch": 9
     },
     "groups": [
         {

Tasks/JenkinsQueueJob/task.loc.json

@@ -14,7 +14,7 @@
   "version": {
     "Major": 1,
     "Minor": 0,
-    "Patch": 8
+    "Patch": 9
   },
   "groups": [
     {

Tasks/JenkinsQueueJob/unzip.ts

@@ -0,0 +1,71 @@
+
+import tl = require('vsts-task-lib/task');
+import tr = require('vsts-task-lib/toolrunner');
+
+import path = require('path');
+
+import unzip = require('./unzip');
+
+import * as Util from './util';
+
+
+var win = tl.osType().match(/^Win/);
+tl.debug('win: ' + win);
+
+// extractors
+var xpUnzipLocation: string = win ? null : xpUnzipLocation = tl.which('unzip', false);
+var winSevenZipLocation: string = path.join(__dirname, '7zip/7z.exe');
+
+export function unzip(file: string, destinationFolder: string) {
+    if (win) {
+        sevenZipExtract(file, destinationFolder);
+    } else {
+        unzipExtract(file, destinationFolder);
+    }
+}
+
+function unzipExtract(file: string, destinationFolder: string) {
+    tl.debug('Extracting file: ' + file);
+    if (typeof xpUnzipLocation == "undefined") {
+        xpUnzipLocation = tl.which('unzip', true);
+    }
+    var unzip = tl.createToolRunner(xpUnzipLocation);
+    unzip.arg(file);
+    unzip.arg('-d');
+    unzip.arg(destinationFolder);
+
+    return handleExecResult(unzip.execSync(getOptions()), file);
+}
+
+function sevenZipExtract(file: string, destinationFolder: string) {
+    tl.debug('Extracting file: ' + file);
+    var sevenZip = tl.createToolRunner(winSevenZipLocation);
+    sevenZip.arg('x');
+    sevenZip.arg('-o' + destinationFolder);
+    sevenZip.arg(file);
+    return handleExecResult(sevenZip.execSync(getOptions()), file);
+}
+
+function handleExecResult(execResult: tr.IExecResult, file: string) {
+    if (execResult.code != tl.TaskResult.Succeeded) {
+        tl.debug('execResult: ' + JSON.stringify(execResult));
+        var message = 'Extraction failed for file: ' + file +
+            '\ncode: ' + execResult.code +
+            '\nstdout: ' + execResult.stdout +
+            '\nstderr: ' + execResult.stderr +
+            '\nerror: ' + execResult.error;
+        throw new UnzipError(message);
+    }
+}
+
+function getOptions(): tr.IExecOptions {
+    var execOptions: tr.IExecOptions = {
+        silent: true,
+        outStream: new Util.StringWritable({ decodeStrings: false }),
+        errStream: new Util.StringWritable({ decodeStrings: false }),
+    };
+    return execOptions;
+}
+
+export class UnzipError extends Error {
+}