azure-pipelines-tasks-azurermdeploycommon 3.235.0 → 3.237.0

package/azure-arm-rest/azure-arm-app-service-kudu.d.ts

@@ -31,6 +31,7 @@ export declare class Kudu {
     getKuduStackTrace(): string;
     zipDeploy(webPackage: string, queryParameters?: Array<string>): Promise<any>;
     warDeploy(webPackage: string, queryParameters?: Array<string>): Promise<any>;
+    oneDeploy(webPackage: string, queryParameters?: Array<string>): Promise<any>;
     getDeploymentDetails(deploymentID: string): Promise<any>;
     getDeploymentLogs(log_url: string): Promise<any>;
     deleteFile(physicalPath: string, fileName: string): Promise<void>;

package/azure-arm-rest/azure-arm-app-service-kudu.js

@@ -507,6 +507,43 @@ class Kudu {
             }
         });
     }
+    oneDeploy(webPackage, queryParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let httpRequest = new webClient.WebRequest();
+            httpRequest.method = 'POST';
+            httpRequest.uri = this._client.getRequestUri(`/api/publish`, queryParameters);
+            httpRequest.body = fs.createReadStream(webPackage);
+            let requestOptions = new webClient.WebRequestOptions();
+            //Bydefault webclient.sendRequest retries for  [500, 502, 503, 504]
+            requestOptions.retriableStatusCodes = [500, 502, 503, 504];
+            requestOptions.retryIntervalInSeconds = 5;
+            try {
+                let response = yield this._client.beginRequest(httpRequest, requestOptions, 'application/octet-stream');
+                tl.debug(`OneDeploy response: ${JSON.stringify(response)}`);
+                if (response.statusCode == 200) {
+                    tl.debug('Deployment passed');
+                    return null;
+                }
+                else if (response.statusCode == 202) {
+                    let pollableURL = response.headers.location;
+                    if (!!pollableURL) {
+                        tl.debug(`Polling for OneDeploy URL: ${pollableURL}`);
+                        return yield this._getDeploymentDetailsFromPollURL(pollableURL);
+                    }
+                    else {
+                        tl.debug('OneDeploy returned 202 without pollable URL.');
+                        return null;
+                    }
+                }
+                else {
+                    throw response;
+                }
+            }
+            catch (error) {
+                throw new Error(tl.loc('PackageDeploymentFailed', this._getFormattedError(error)));
+            }
+        });
+    }
     getDeploymentDetails(deploymentID) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/azure-arm-rest/azure-arm-app-service-kudu.ts

@@ -522,6 +522,41 @@ export class Kudu {
         }
     }
 
+        public async oneDeploy(webPackage: string, queryParameters?: Array<string>): Promise<any> {
+        let httpRequest = new webClient.WebRequest();
+        httpRequest.method = 'POST';
+        httpRequest.uri = this._client.getRequestUri(`/api/publish`, queryParameters);
+        httpRequest.body = fs.createReadStream(webPackage);
+        let requestOptions = new webClient.WebRequestOptions();
+        //Bydefault webclient.sendRequest retries for  [500, 502, 503, 504]
+        requestOptions.retriableStatusCodes = [500, 502, 503, 504];
+        requestOptions.retryIntervalInSeconds = 5;
+        try {
+            let response = await this._client.beginRequest(httpRequest, requestOptions, 'application/octet-stream');
+            tl.debug(`OneDeploy response: ${JSON.stringify(response)}`);
+            if (response.statusCode == 200) {
+                tl.debug('Deployment passed');
+                return null;
+            }
+            else if (response.statusCode == 202) {
+                let pollableURL: string = response.headers.location;
+                if (!!pollableURL) {
+                    tl.debug(`Polling for OneDeploy URL: ${pollableURL}`);
+                    return await this._getDeploymentDetailsFromPollURL(pollableURL);
+                }
+                else {
+                    tl.debug('OneDeploy returned 202 without pollable URL.');
+                    return null;
+                }
+            }
+            else {
+                throw response;
+            }
+        }
+        catch (error) {
+            throw new Error(tl.loc('PackageDeploymentFailed', this._getFormattedError(error)));
+        }
+    }
 
     public async getDeploymentDetails(deploymentID: string): Promise<any> {
         try {
@@ -648,4 +683,4 @@ export class Kudu {
         }
         return error;
     }
-}
+}

package/operations/KuduServiceUtility.d.ts

@@ -12,6 +12,7 @@ export declare class KuduServiceUtility {
     deployUsingWarDeploy(packagePath: string, customMessage?: any, targetFolderName?: any): Promise<string>;
     postZipDeployOperation(oldDeploymentID: string, activeDeploymentID: string): Promise<void>;
     warmpUp(): Promise<void>;
+    deployUsingOneDeploy(packagePath: string, customMessage?: any, targetPath?: any, type?: any, clean?: any, restart?: any): Promise<string>;
     private _processDeploymentResponse;
     private _printZipDeployLogs;
     private _printPostDeploymentLogs;

package/operations/KuduServiceUtility.js

@@ -21,6 +21,7 @@ const physicalRootPath = '/site/wwwroot';
 const deploymentFolder = 'site/deployments';
 const manifestFileName = 'manifest';
 const VSTS_ZIP_DEPLOY = 'VSTS_ZIP_DEPLOY';
+const VSTS_ONE_DEPLOY = 'VSTS_ONE_DEPLOY';
 const VSTS_DEPLOY = 'VSTS';
 class KuduServiceUtility {
     constructor(kuduService) {
@@ -190,6 +191,40 @@ class KuduServiceUtility {
             }
         });
     }
+    deployUsingOneDeploy(packagePath, customMessage, targetPath, type, clean, restart) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log(tl.loc('Package deployment using OneDeploy initiated.'));
+                let queryParameters = [
+                    'async=true',
+                    'deployer=' + VSTS_ONE_DEPLOY
+                ];
+                if (type) {
+                    queryParameters.push('type=' + encodeURIComponent(type));
+                }
+                if (targetPath) {
+                    queryParameters.push('path=' + encodeURIComponent(targetPath));
+                }
+                if (clean) {
+                    queryParameters.push('clean=' + encodeURIComponent(clean));
+                }
+                if (restart) {
+                    queryParameters.push('restart=' + encodeURIComponent(restart));
+                }
+                var deploymentMessage = this._getUpdateHistoryRequest(null, null, customMessage).message;
+                queryParameters.push('message=' + encodeURIComponent(deploymentMessage));
+                let deploymentDetails = yield this._appServiceKuduService.oneDeploy(packagePath, queryParameters);
+                console.log(tl.loc(deploymentDetails));
+                yield this._processDeploymentResponse(deploymentDetails);
+                console.log(tl.loc('Successfully deployed web package to App Service.'));
+                return deploymentDetails.id;
+            }
+            catch (error) {
+                tl.error(tl.loc('PackageDeploymentFailed'));
+                throw error;
+            }
+        });
+    }
     _processDeploymentResponse(deploymentDetails) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/operations/KuduServiceUtility.ts

@@ -14,6 +14,7 @@ const physicalRootPath: string = '/site/wwwroot';
 const deploymentFolder: string = 'site/deployments';
 const manifestFileName: string = 'manifest';
 const VSTS_ZIP_DEPLOY: string = 'VSTS_ZIP_DEPLOY';
+const VSTS_ONE_DEPLOY: string = 'VSTS_ONE_DEPLOY';
 const VSTS_DEPLOY: string = 'VSTS';
 
 export class KuduServiceUtility {
@@ -196,6 +197,45 @@ export class KuduServiceUtility {
         }
     }
 
+    public async deployUsingOneDeploy(packagePath: string, customMessage?: any, targetPath?: any, type?: any, clean?: any, restart?: any): Promise<string> {
+        try {
+            console.log(tl.loc('Package deployment using OneDeploy initiated.'));
+            let queryParameters: Array<string> = [
+                'async=true',
+                'deployer=' + VSTS_ONE_DEPLOY
+            ];
+
+            if (type) {
+                queryParameters.push('type=' + encodeURIComponent(type));
+            }
+
+            if (targetPath) {
+                queryParameters.push('path=' + encodeURIComponent(targetPath));
+            }
+
+            if (clean) {
+                queryParameters.push('clean=' + encodeURIComponent(clean));
+            }
+
+            if (restart) {
+                queryParameters.push('restart=' + encodeURIComponent(restart));
+            }
+
+            var deploymentMessage = this._getUpdateHistoryRequest(null, null, customMessage).message;
+            queryParameters.push('message=' + encodeURIComponent(deploymentMessage));
+            let deploymentDetails = await this._appServiceKuduService.oneDeploy(packagePath, queryParameters);
+            console.log(tl.loc(deploymentDetails));
+            await this._processDeploymentResponse(deploymentDetails);
+            console.log(tl.loc('Successfully deployed web package to App Service.'));
+
+            return deploymentDetails.id;
+        }
+        catch (error) {
+            tl.error(tl.loc('PackageDeploymentFailed'));
+            throw error;
+        }
+    }
+
     private async _processDeploymentResponse(deploymentDetails: any): Promise<void> {
         try {
             var kuduDeploymentDetails = await this._appServiceKuduService.getDeploymentDetails(deploymentDetails.id);
@@ -456,4 +496,4 @@ export class KuduServiceUtility {
             deployer : 'VSTS'
         };
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "azure-pipelines-tasks-azurermdeploycommon",
-    "version": "3.235.0",
+    "version": "3.237.0",
     "description": "Common Lib for Azure ARM REST apis",
     "repository": {
         "type": "git",
@@ -21,7 +21,6 @@
         "@types/q": "1.0.7",
         "archiver": "2.1.1",
         "azure-pipelines-task-lib": "^3.1.0",
-        "decompress-zip": "^0.3.3",
         "jsonwebtoken": "^8.5.1",
         "ltx": "2.6.2",
         "node-stream-zip": "1.7.0",

package/webdeployment-common/ziputility.d.ts

@@ -1,5 +1,5 @@
 import Q = require('q');
-export declare function unzip(zipLocation: any, unzipLocation: any): Promise<unknown>;
+export declare function unzip(zipLocation: any, unzipLocation: any): Promise<void>;
 export declare function archiveFolder(folderPath: any, targetPath: any, zipName: any): Promise<unknown>;
 /**
  *  Returns array of files present in archived package

package/webdeployment-common/ziputility.js

@@ -14,8 +14,7 @@ const tl = require("azure-pipelines-task-lib/task");
 const path = require("path");
 const Q = require("q");
 const fs = require("fs");
-const StreamZip = require("node-stream-zip");
-var DecompressZip = require('decompress-zip');
+const node_stream_zip_1 = require("node-stream-zip");
 var archiver = require('archiver');
 function unzip(zipLocation, unzipLocation) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23,19 +22,15 @@ function unzip(zipLocation, unzipLocation) {
         if (tl.exist(unzipLocation)) {
             tl.rmRF(unzipLocation);
         }
-        var unzipper = new DecompressZip(zipLocation);
-        tl.debug('extracting ' + zipLocation + ' to ' + unzipLocation);
-        unzipper.on('error', function (error) {
+        tl.mkdirP(unzipLocation);
+        const zip = new node_stream_zip_1.default.async({ file: zipLocation });
+        zip.extract(null, unzipLocation).then(() => {
+            zip.close();
+            defer.resolve();
+        }).catch((error) => {
+            console.log(`error extracting ${zipLocation}: ${error}`);
             defer.reject(error);
         });
-        unzipper.on('extract', function (log) {
-            tl.debug('extracted ' + zipLocation + ' to ' + unzipLocation + ' Successfully');
-            defer.resolve(unzipLocation);
-        });
-        unzipper.extract({
-            path: unzipLocation
-        });
-        return defer.promise;
     });
 }
 exports.unzip = unzip;
@@ -66,17 +61,16 @@ exports.archiveFolder = archiveFolder;
 function getArchivedEntries(archivedPackage) {
     return __awaiter(this, void 0, void 0, function* () {
         var deferred = Q.defer();
-        var unzipper = new DecompressZip(archivedPackage);
-        unzipper.on('error', function (error) {
-            deferred.reject(error);
-        });
-        unzipper.on('list', function (files) {
-            var packageComponent = {
-                "entries": files
+        const zip = new node_stream_zip_1.default.async({ file: archivedPackage });
+        zip.entries().then(entries => {
+            var packageConmponent = {
+                'entries': Object.keys(entries)
             };
-            deferred.resolve(packageComponent);
+            zip.close();
+            deferred.resolve(packageConmponent);
+        }).catch(error => {
+            deferred.reject(error);
         });
-        unzipper.list();
         return deferred.promise;
     });
 }
@@ -86,7 +80,7 @@ function checkIfFilesExistsInZip(archivedPackage, files) {
     for (let i = 0; i < files.length; i++) {
         files[i] = files[i].toLowerCase();
     }
-    const zip = new StreamZip({
+    const zip = new node_stream_zip_1.default({
         file: archivedPackage,
         storeEntries: true,
         skipEntryNameValidation: true

package/webdeployment-common/ziputility.ts

@@ -2,8 +2,7 @@ import tl = require('azure-pipelines-task-lib/task');
 import path = require('path');
 import Q = require('q');
 import fs = require('fs');
-import StreamZip = require('node-stream-zip');
-var DecompressZip = require('decompress-zip');
+import StreamZip from 'node-stream-zip';
 var archiver = require('archiver');
 
 export async function unzip(zipLocation, unzipLocation) {
@@ -11,19 +10,15 @@ export async function unzip(zipLocation, unzipLocation) {
     if(tl.exist(unzipLocation)) {
       tl.rmRF(unzipLocation);
     }
-    var unzipper = new DecompressZip(zipLocation);
-    tl.debug('extracting ' + zipLocation + ' to ' + unzipLocation);
-    unzipper.on('error', function (error) {
-        defer.reject(error);
-    });
-    unzipper.on('extract', function (log) {
-        tl.debug('extracted ' + zipLocation + ' to ' + unzipLocation + ' Successfully');
-        defer.resolve(unzipLocation);
-    });
-    unzipper.extract({
-      path: unzipLocation
-    });
-    return defer.promise;
+    tl.mkdirP(unzipLocation);
+    const zip = new StreamZip.async({ file: zipLocation});
+        zip.extract(null, unzipLocation).then(() => {
+            zip.close();
+            defer.resolve();
+        }).catch((error) => {
+            console.log(`error extracting ${zipLocation}: ${error}`);
+            defer.reject(error);
+        })
 }
 
 export async function archiveFolder(folderPath, targetPath, zipName) {
@@ -53,17 +48,16 @@ export async function archiveFolder(folderPath, targetPath, zipName) {
  */
 export async function getArchivedEntries(archivedPackage: string)  {
     var deferred = Q.defer();
-    var unzipper = new DecompressZip(archivedPackage);
-    unzipper.on('error', function (error) {
+    const zip = new StreamZip.async({file: archivedPackage});
+    zip.entries().then(entries => {
+        var packageConmponent = {
+            'entries': Object.keys(entries)
+        }
+        zip.close();
+        deferred.resolve(packageConmponent);
+    }).catch(error => {
         deferred.reject(error);
-    });
-    unzipper.on('list', function (files) {
-        var packageComponent = {
-            "entries":files
-        };
-        deferred.resolve(packageComponent); 
-    });
-    unzipper.list();
+    })
     return deferred.promise;
 }