public async postZipDeployOperation(oldDeploymentID: string, activeDeploymentID: string): Promise<void> {
     try {
         tl.debug(`ZIP DEPLOY - Performing post zip-deploy operation: ${oldDeploymentID} => ${activeDeploymentID}`);
         let manifestFileContent = await this._appServiceKuduService.getFileContent(`${deploymentFolder}/${oldDeploymentID}`, manifestFileName);
         if(!!manifestFileContent) {
             let tempManifestFile: string = path.join(tl.getVariable('AGENT.TEMPDIRECTORY'), manifestFileName);
             tl.writeFile(tempManifestFile, manifestFileContent);
             await this._appServiceKuduService.uploadFile(`${deploymentFolder}/${activeDeploymentID}`, manifestFileName, tempManifestFile);
         }
         tl.debug('ZIP DEPLOY - Performed post-zipdeploy operation.');
     }
     catch(error) {
         tl.debug(`Failed to execute post zip-deploy operation: ${JSON.stringify(error)}.`);
     }
 }

    public async installSiteExtensions(extensionList: Array<string>, outputVariables?: Array<string>): Promise<void> {
        outputVariables = outputVariables ? outputVariables : [];
        var outputVariableIterator: number = 0;
        var siteExtensions = await this._appServiceKuduService.getSiteExtensions();
        var allSiteExtensions = await this._appServiceKuduService.getAllSiteExtensions();
        var anyExtensionInstalled: boolean = false;
        var siteExtensionMap = {};
        var allSiteExtensionMap = {};
        var extensionLocalPaths: string = "";
        for(var siteExtension of siteExtensions) {
            siteExtensionMap[siteExtension.id] = siteExtension;
        }
        for(var siteExtension of allSiteExtensions) {
            allSiteExtensionMap[siteExtension.id] = siteExtension;
            allSiteExtensionMap[siteExtension.title] = siteExtension;
        }

        for(var extensionID of extensionList) {
            var siteExtensionDetails = null;
            if(allSiteExtensionMap[extensionID] && allSiteExtensionMap[extensionID].title == extensionID) {
                extensionID = allSiteExtensionMap[extensionID].id;
            }
            // Python extensions are moved to Nuget and the extensions IDs are changed. The belo check ensures that old extensions are mapped to new extension ID.
            if(siteExtensionMap[extensionID] || (extensionID.startsWith('python') && siteExtensionMap[pythonExtensionPrefix + extensionID])) {
                siteExtensionDetails = siteExtensionMap[extensionID] || siteExtensionMap[pythonExtensionPrefix + extensionID];
                console.log(tl.loc('ExtensionAlreadyInstalled', extensionID));
            }
            else {
                siteExtensionDetails = await this._appServiceKuduService.installSiteExtension(extensionID);
                anyExtensionInstalled = true;
            }
            
            var extensionLocalPath: string = this._getExtensionLocalPath(siteExtensionDetails);
            extensionLocalPaths += extensionLocalPath + ",";
            if(outputVariableIterator < outputVariables.length) {
                tl.debug('Set output Variable ' + outputVariables[outputVariableIterator] + ' to value: ' + extensionLocalPath);
                tl.setVariable(outputVariables[outputVariableIterator], extensionLocalPath);
                outputVariableIterator += 1;
            }
        }
        
        tl.debug('Set output Variable LocalPathsForInstalledExtensions to value: ' + extensionLocalPaths.slice(0, -1));
        tl.setVariable("LocalPathsForInstalledExtensions", extensionLocalPaths.slice(0, -1));
        
        if(anyExtensionInstalled) {
            await this.restart();
        }
    }

    private async _pollForFile(physicalPath: string, fileName: string, timeOutInMinutes: number): Promise<void> {
        var attempts: number = 0;
        const retryInterval: number = 10;
        if(tl.getVariable('appservicedeploy.retrytimeout')) {
            timeOutInMinutes = Number(tl.getVariable('appservicedeploy.retrytimeout'));
            tl.debug('Retry timeout in minutes provided by user: ' + timeOutInMinutes);
        }

        var timeOutInSeconds = timeOutInMinutes * 60;
        var noOfRetry = timeOutInSeconds / retryInterval;

        tl.debug(`Polling started for file:  ${fileName} with retry count: ${noOfRetry}`);

        while (attempts < noOfRetry) {
            attempts += 1;
            var fileContent: string = await this._appServiceKuduService.getFileContent(physicalPath, fileName);
            if(fileContent == null) {
                tl.debug('File: ' + fileName + ' not found. retry after 10 seconds. Attempt: ' + attempts);
                await webClient.sleepFor(10);
            }
            else {
                tl.debug('Found file:  ' + fileName);
                return ;
            }
        }

        if(attempts == noOfRetry) {
            throw new Error(tl.loc('ScriptStatusTimeout'));
        }
    }

    public async deployWebPackage(packagePath: string, physicalPath: string, virtualPath: string, appOffline?: boolean): Promise<void> {
        physicalPath = physicalPath ? physicalPath : physicalRootPath;
        try {
            if(appOffline) {
                await this._appOfflineKuduService(physicalPath, true);
                tl.debug('Wait for 10 seconds for app_offline to take effect');
                await webClient.sleepFor(10);
            }

            if(tl.stats(packagePath).isDirectory()) {
                let tempPackagePath = deployUtility.generateTemporaryFolderOrZipPath(tl.getVariable('AGENT.TEMPDIRECTORY'), false);
                packagePath = await zipUtility.archiveFolder(packagePath, "", tempPackagePath);
                tl.debug("Compressed folder " + packagePath + " into zip : " +  packagePath);
            }
            else if(packagePath.toLowerCase().endsWith('.war')) {
                physicalPath = await this._warFileDeployment(packagePath, physicalPath, virtualPath);
            }

            await this._appServiceKuduService.extractZIP(packagePath, physicalPath);
            if(appOffline) {
                await this._appOfflineKuduService(physicalPath, false);
            }

            console.log(tl.loc("Successfullydeployedpackageusingkuduserviceat", packagePath, physicalPath));
        }
        catch(error) {
            tl.error(tl.loc('PackageDeploymentFailed'));
            throw Error(error);
        }
    }

    public async deployUsingWarDeploy(packagePath: string, customMessage?: any, targetFolderName?: any): Promise<string> {
        try {
            console.log(tl.loc('WarPackageDeploymentInitiated'));

            let queryParameters: Array<string> = [
                'isAsync=true'
            ];
            
            if(targetFolderName) {
                queryParameters.push('name=' + encodeURIComponent(targetFolderName));
            }

            var deploymentMessage = this._getUpdateHistoryRequest(null, null, customMessage).message;
            queryParameters.push('message=' + encodeURIComponent(deploymentMessage));
            let deploymentDetails = await this._appServiceKuduService.warDeploy(packagePath, queryParameters);
            await this._processDeploymentResponse(deploymentDetails);
            console.log(tl.loc('PackageDeploymentSuccess'));

            return deploymentDetails.id;
        }
        catch(error) {
            tl.error(tl.loc('PackageDeploymentFailed'));
            throw Error(error);
        }
    }

    public async deployUsingZipDeploy(packagePath: string, appOffline?: boolean, customMessage?: any): Promise<string> {
        try {
            console.log(tl.loc('PackageDeploymentInitiated'));

            if(appOffline) {
                await this._appOfflineKuduService(physicalRootPath, true);
                tl.debug('Wait for 5 seconds for app_offline to take effect');
                await webClient.sleepFor(5);
            }

            let queryParameters: Array<string> = [
                'isAsync=true',
                'deployer=' + VSTS_ZIP_DEPLOY
            ];

            let deploymentDetails = await this._appServiceKuduService.zipDeploy(packagePath, queryParameters);
            await this._processDeploymentResponse(deploymentDetails);
            if(appOffline) {
                await this._appOfflineKuduService(physicalRootPath, false);
            }

            console.log(tl.loc('PackageDeploymentSuccess'));
            return deploymentDetails.id;
        }
        catch(error) {
            tl.error(tl.loc('PackageDeploymentFailed'));
            throw Error(error);
        }
    }

export async function enableContinuousMonitoring(endpoint: AzureEndpoint, appService: AzureAppService, appInsights: AzureApplicationInsights, testName?: string) {
    try {
        console.log(tl.loc('EnablingContinousMonitoring', appService.getName()));
        var appDetails = await appService.get();
        var appServiceUtils = new AzureAppServiceUtils(appService);
        var appInsightsResource = await appInsights.get();
        var appInsightsWebTests = new ApplicationInsightsWebTests(endpoint, appInsights.getResourceGroupName());
        var webDeployPublishingProfile = await appServiceUtils.getWebDeployPublishingProfile();
        var applicationUrl = webDeployPublishingProfile.destinationAppUrl;
        if(appDetails.kind.indexOf("linux") == -1) {
            var appKuduService: Kudu = await appServiceUtils.getKuduService();
            await appKuduService.installSiteExtension(APPLICATION_INSIGHTS_EXTENSION_NAME);
        }

        appInsightsResource.tags["hidden-link:" + appDetails.id] = "Resource";
        tl.debug('Link app insights with app service via tag');
        await appInsights.update(appInsightsResource);
        tl.debug('Link app service with app insights via instrumentation key');
        await appService.patchApplicationSettings({
            "APPINSIGHTS_INSTRUMENTATIONKEY": appInsightsResource.properties['InstrumentationKey']
        });

        try {
            tl.debug('Enable alwaysOn property for app service.');
            await appService.patchConfiguration({ "properties" :{"alwaysOn": true}});    
        }
        catch(error) {
            tl.warning(error);
        }
        
        try {
            tl.debug('add web test for app service - app insights');
            var appInsightsWebTestsUtils: AzureApplicationInsightsWebTestsUtils = new AzureApplicationInsightsWebTestsUtils(appInsightsWebTests);
            await appInsightsWebTestsUtils.addWebTest(appInsightsResource,applicationUrl, testName);
        }
        catch(error) {
            tl.warning(error);
        }

        console.log(tl.loc("ContinousMonitoringEnabled", appService.getName()));
    }
    catch(error) {
        throw new Error(tl.loc('FailedToEnableContinuousMonitoring', error));
    }
}

 public async updateDeploymentStatus(taskResult: boolean, DeploymentID: string, customMessage: any): Promise<string> {
     try {
         let requestBody = this._getUpdateHistoryRequest(taskResult, DeploymentID, customMessage);
         return await this._appServiceKuduService.updateDeployment(requestBody);
     }
     catch(error) {
         tl.warning(error);
     }
 }

 public async warmpUp() {
     try {
         tl.debug('warming up Kudu Service');
         await this._appServiceKuduService.getAppSettings();
         tl.debug('warmed up Kudu Service');
     }
     catch(error) {
         tl.debug('Failed to warm-up Kudu: ' + error.toString());
     }
 }

    private async _printZipDeployLogs(log_url: string): Promise<void> {
        if(!log_url) {
            return;
        }

        var deploymentLogs = await this._appServiceKuduService.getDeploymentLogs(log_url);
        for(var deploymentLog of deploymentLogs) {
            console.log(`${deploymentLog.message}`);
            if(deploymentLog.details_url) {
                await this._printZipDeployLogs(deploymentLog.details_url);
            }
        }
    }