async function run()
{
try
{
tl.setResourcePath(path.join( __dirname, 'task.json'));
var webSiteName: string = tl.getInput('WebSiteName', true);
var virtualApplication: string = tl.getInput('VirtualApplication', false);
var webDeployPkg: string = tl.getPathInput('Package', true);
var setParametersFile: string = tl.getPathInput('SetParametersFile', false);
var removeAdditionalFilesFlag: boolean = tl.getBoolInput('RemoveAdditionalFilesFlag', false);
var excludeFilesFromAppDataFlag: boolean = tl.getBoolInput('ExcludeFilesFromAppDataFlag', false);
var takeAppOfflineFlag: boolean = tl.getBoolInput('TakeAppOfflineFlag', false);
var additionalArguments: string = tl.getInput('AdditionalArguments', false);
var xmlTransformation: boolean = tl.getBoolInput('XmlTransformation', false);
var JSONFiles = tl.getDelimitedInput('JSONFiles', '\n', false);
var xmlVariableSubstitution: boolean = tl.getBoolInput('XmlVariableSubstitution', false);
var availableWebPackages = utility.findfiles(webDeployPkg);
var tempPackagePath = null;
if(availableWebPackages.length == 0)
{
throw new Error(tl.loc('Nopackagefoundwithspecifiedpattern'));
}
if(availableWebPackages.length > 1)
{
throw new Error(tl.loc('MorethanonepackagematchedwithspecifiedpatternPleaserestrainthesearchpattern'));
}
webDeployPkg = availableWebPackages[0];
var isFolderBasedDeployment = await utility.isInputPkgIsFolder(webDeployPkg);
if ( JSONFiles.length != 0 || xmlTransformation || xmlVariableSubstitution ) {
var folderPath = await utility.generateTemporaryFolderForDeployment(isFolderBasedDeployment, webDeployPkg);
var isMSBuildPackage = !isFolderBasedDeployment && await utility.isMSDeployPackage(webDeployPkg);
fileTransformationsUtility.fileTransformations(isFolderBasedDeployment, JSONFiles, xmlTransformation, xmlVariableSubstitution, folderPath, isMSBuildPackage);
var output = await utility.archiveFolderForDeployment(isFolderBasedDeployment, folderPath);
tempPackagePath = output.tempPackagePath;
webDeployPkg = output.webDeployPkg;
}
await msDeploy.DeployUsingMSDeploy(webDeployPkg, webSiteName, null, removeAdditionalFilesFlag,
excludeFilesFromAppDataFlag, takeAppOfflineFlag, virtualApplication, setParametersFile,
additionalArguments, isFolderBasedDeployment, true);
}
catch(error)
{
tl.setResult(tl.TaskResult.Failed,error);
}
}
export async function fileTransformations(isFolderBasedDeployment: boolean, JSONFiles: any, xmlTransformation: boolean, xmlVariableSubstitution: boolean, webDeployPkg: string) {
var tempPackagePath;
var folderPath = utility.generateTemporaryFolderOrZipPath(tl.getVariable('System.DefaultWorkingDirectory'), true);
if(isFolderBasedDeployment) {
tl.cp(path.join(webDeployPkg, '/*'), folderPath, '-rf', false);
}
else {
await zipUtility.unzip(webDeployPkg, folderPath);
}
if(xmlTransformation) {
var environmentName = tl.getVariable('Release.EnvironmentName');
if(tl.osType().match(/^Win/)) {
var transformConfigs = ["Release.config"];
if(environmentName) {
transformConfigs.push(environmentName + ".config");
}
xdtTransformationUtility.basicXdtTransformation(folderPath, transformConfigs);
console.log(tl.loc("XDTTransformationsappliedsuccessfully"));
}
else {
throw new Error(tl.loc("CannotPerformXdtTransformationOnNonWindowsPlatform"));
}
}
if(xmlVariableSubstitution) {
await xmlSubstitutionUtility.substituteAppSettingsVariables(folderPath);
console.log(tl.loc('XMLvariablesubstitutionappliedsuccessfully'));
}
if(JSONFiles.length != 0) {
jsonSubstitutionUtility.jsonVariableSubstitution(folderPath, JSONFiles);
console.log(tl.loc('JSONvariablesubstitutionappliedsuccessfully'));
}
if(isFolderBasedDeployment) {
tempPackagePath = folderPath;
webDeployPkg = folderPath;
}
else {
var tempWebPackageZip = utility.generateTemporaryFolderOrZipPath(tl.getVariable('System.DefaultWorkingDirectory'), false);
webDeployPkg = await zipUtility.archiveFolder(folderPath, "", tempWebPackageZip);
tempPackagePath = webDeployPkg;
tl.rmRF(folderPath, true);
}
return {
"webDeployPkg": webDeployPkg,
"tempPackagePath": tempPackagePath
};
}
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 DeployWebAppStep() {
var webPackage = packageUtility.PackageUtility.getPackagePath(this.taskParams.Package);
var isFolderBasedDeployment = deployUtility.isInputPkgIsFolder(webPackage);
var physicalPath: string = Constant.SiteRoot;
if(this.taskParams.VirtualApplication) {
physicalPath = await this.appServiceUtility.getPhysicalPath(this.taskParams.VirtualApplication);
await this.kuduServiceUtility.createPathIfRequired(physicalPath);
this.virtualApplicationPath = physicalPath;
}
webPackage = await FileTransformsUtility.applyTransformations(webPackage, this.taskParams);
if(deployUtility.canUseWebDeploy(this.taskParams.UseWebDeploy)) {
tl.debug("Performing the deployment of webapp.");
if(!tl.osType().match(/^Win/)){
throw Error(tl.loc("PublishusingwebdeployoptionsaresupportedonlywhenusingWindowsagent"));
}
if(this.taskParams.RenameFilesFlag) {
await this.appServiceUtility.enableRenameLockedFiles();
}
var msDeployPublishingProfile = await this.appServiceUtility.getWebDeployPublishingProfile();
if (webPackage.toString().toLowerCase().endsWith('.war')) {
await DeployWar(webPackage, this.taskParams, msDeployPublishingProfile, this.kuduService, this.appServiceUtility);
}
else {
await msDeploy.DeployUsingMSDeploy(webPackage, this.taskParams.WebAppName, msDeployPublishingProfile,
this.taskParams.RemoveAdditionalFilesFlag, this.taskParams.ExcludeFilesFromAppDataFlag, this.taskParams.TakeAppOfflineFlag,
this.taskParams.VirtualApplication, this.taskParams.SetParametersFile, this.taskParams.AdditionalArguments,
isFolderBasedDeployment, this.taskParams.UseWebDeploy);
}
}
else {
tl.debug("Initiated deployment via kudu service for webapp package : ");
await this.kuduServiceUtility.deployWebPackage(webPackage, physicalPath, this.taskParams.VirtualApplication, this.taskParams.TakeAppOfflineFlag);
}
await this.PostDeploymentStep();
}
public async DeployWebAppStep() {
tl.debug("Initiated deployment via kudu service for webapp war package : "+ this.taskParams.Package.getPath());
await this.kuduServiceUtility.warmpUp();
var warName = webCommonUtility.getFileNameFromPath(this.taskParams.Package.getPath(), ".war");
this.zipDeploymentID = await this.kuduServiceUtility.deployUsingWarDeploy(this.taskParams.Package.getPath(),
{ slotName: this.appService.getSlot() }, warName);
await this.PostDeploymentStep();
}
/**
* Deploys website using Kudu REST API
*
* @param webDeployPkg Web deploy package
* @param webAppName Web App Name
* @param publishingProfile Azure RM Connection Details
* @param virtualApplication Virtual Application Name
* @param isFolderBasedDeployment Input is folder or not
*
*/
async function DeployUsingKuduDeploy(webDeployPkg, azureWebAppDetails, publishingProfile, virtualApplication, isFolderBasedDeployment, takeAppOfflineFlag) {
var tempPackagePath = null;
try {
var virtualApplicationMappings = azureWebAppDetails.properties.virtualApplications;
var webAppZipFile = webDeployPkg;
if(isFolderBasedDeployment) {
tempPackagePath = deployUtility.generateTemporaryFolderOrZipPath(tl.getVariable('System.DefaultWorkingDirectory'), false);
webAppZipFile = await zipUtility.archiveFolder(webDeployPkg, "", tempPackagePath);
tl.debug("Compressed folder " + webDeployPkg + " into zip : " + webAppZipFile);
} else {
if (await deployUtility.isMSDeployPackage(webAppZipFile)) {
throw new Error(tl.loc("MSDeploygeneratedpackageareonlysupportedforWindowsplatform"));
}
}
var physicalPath = "/site/wwwroot";
var virtualPath = "/";
if(virtualApplication) {
var pathMappings = kuduUtility.getVirtualAndPhysicalPaths(virtualApplication, virtualApplicationMappings);
if(pathMappings[1] != null) {
virtualPath = pathMappings[0];
physicalPath = pathMappings[1];
} else {
throw Error(tl.loc("VirtualApplicationDoesNotExist", virtualApplication));
}
}
await kuduUtility.deployWebAppPackage(webAppZipFile, publishingProfile, virtualPath, physicalPath, takeAppOfflineFlag);
console.log(tl.loc('PackageDeploymentSuccess'));
}
catch(error) {
tl.error(tl.loc('PackageDeploymentFailed'));
throw Error(error);
}
finally {
if(tempPackagePath) {
tl.rmRF(tempPackagePath, true);
}
}
}
public async zipDeploy(packagePath: string, appOffline?: boolean, customMessage?: any): Promise<string> {
try {
console.log(tl.loc('PackageDeploymentInitiated'));
await this._preZipDeployOperation();
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);
}
if(appOffline) {
await this._appOfflineKuduService(physicalRootPath, true);
tl.debug('Wait for 10 seconds for app_offline to take effect');
await webClient.sleepFor(10);
}
let queryParameters: Array<string> = [
'isAsync=true',
'deployer=' + VSTS_ZIP_DEPLOY
];
let deploymentDetails = await this._appServiceKuduService.zipDeploy(packagePath, queryParameters);
try {
var kuduDeploymentDetails = await this._appServiceKuduService.getDeploymentDetails(deploymentDetails.id);
tl.debug(`logs from ZIP deploy: ${kuduDeploymentDetails.log_url}`);
await this._printZipDeployLogs(kuduDeploymentDetails.log_url);
}
catch(error) {
tl.debug(`Unable to fetch logs for kudu ZIP Deploy: ${JSON.stringify(error)}`)
}
if(deploymentDetails.status == KUDU_DEPLOYMENT_CONSTANTS.FAILED) {
throw tl.loc('PackageDeploymentUsingZipDeployFailed');
}
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);
}
}
public async DeployWebAppStep() {
let deploymentMethodtelemetry = '{"deploymentMethod":"War Deploy"}';
console.log("##vso[telemetry.publish area=TaskDeploymentMethod;feature=AzureWebAppDeployment]" + deploymentMethodtelemetry);
tl.debug("Initiated deployment via kudu service for webapp war package : "+ this.taskParams.Package.getPath());
await this.kuduServiceUtility.warmpUp();
var warName = webCommonUtility.getFileNameFromPath(this.taskParams.Package.getPath(), ".war");
this.zipDeploymentID = await this.kuduServiceUtility.deployUsingWarDeploy(this.taskParams.Package.getPath(),
{ slotName: this.appService.getSlot() }, warName);
await this.PostDeploymentStep();
}
public async DeployWebAppStep() {
var physicalPath: string = Constant.SiteRoot;
var webPackage = this.taskParams.Package.getPath();
if(this.taskParams.VirtualApplication) {
physicalPath = await this.appServiceUtility.getPhysicalPath(this.taskParams.VirtualApplication);
await this.kuduServiceUtility.createPathIfRequired(physicalPath);
this.virtualApplicationPath = physicalPath;
}
webPackage = await FileTransformsUtility.applyTransformations(webPackage, this.taskParams);
this.taskParams.Package = new Package(webPackage);
var updateApplicationSetting = ParameterParser.parse(removeRunFromZipAppSetting)
var deleteApplicationSetting = ParameterParser.parse(deleteOldRunFromZipAppSetting)
await this.appServiceUtility.updateAndMonitorAppSettings(updateApplicationSetting, deleteApplicationSetting);
if(deployUtility.canUseWebDeploy(this.taskParams.UseWebDeploy)) {
let deploymentMethodtelemetry = '{"deploymentMethod":"Web Deploy"}';
console.log("##vso[telemetry.publish area=TaskDeploymentMethod;feature=AzureWebAppDeployment]" + deploymentMethodtelemetry);
tl.debug("Performing the deployment of webapp.");
if(!tl.osType().match(/^Win/)) {
throw Error(tl.loc("PublishusingwebdeployoptionsaresupportedonlywhenusingWindowsagent"));
}
var msDeployPublishingProfile = await this.appServiceUtility.getWebDeployPublishingProfile();
await WebDeployUtility.publishUsingWebDeploy(this.taskParams,
WebDeployUtility.constructWebDeployArguments(this.taskParams, msDeployPublishingProfile), this.appServiceUtility
);
}
else {
let deploymentMethodtelemetry = '{"deploymentMethod":"Zip API"}';
console.log("##vso[telemetry.publish area=TaskDeploymentMethod;feature=AzureWebAppDeployment]" + deploymentMethodtelemetry);
tl.debug("Initiated deployment via kudu service for webapp package : ");
await this.kuduServiceUtility.deployWebPackage(webPackage, physicalPath, this.taskParams.VirtualApplication, this.taskParams.TakeAppOfflineFlag);
}
await this.PostDeploymentStep();
}
public async DeployWebAppStep() {
let deploymentMethodtelemetry = '{"deploymentMethod":"Zip Deploy"}';
console.log("##vso[telemetry.publish area=TaskDeploymentMethod;feature=AzureWebAppDeployment]" + deploymentMethodtelemetry);
var webPackage = await FileTransformsUtility.applyTransformations(this.taskParams.Package.getPath(), this.taskParams);
if(this.taskParams.UseWebDeploy && this.taskParams.DeploymentType === DeploymentType.zipDeploy) {
var _isMSBuildPackage = await this.taskParams.Package.isMSBuildPackage();
if(_isMSBuildPackage) {
throw Error(tl.loc("Publishusingzipdeploynotsupportedformsbuildpackage"));
}
else if(this.taskParams.VirtualApplication) {
throw Error(tl.loc("Publishusingzipdeploynotsupportedforvirtualapplication"));
}
else if(this.taskParams.Package.getPackageType() === PackageType.war) {
throw Error(tl.loc("Publishusingzipdeploydoesnotsupportwarfile"));
}
}
if(tl.stats(webPackage).isDirectory()) {
let tempPackagePath = deployUtility.generateTemporaryFolderOrZipPath(tl.getVariable('AGENT.TEMPDIRECTORY'), false);
webPackage = await zipUtility.archiveFolder(webPackage, "", tempPackagePath);
tl.debug("Compressed folder into zip " + webPackage);
}
tl.debug("Initiated deployment via kudu service for webapp package : ");
var updateApplicationSetting = ParameterParser.parse(removeRunFromZipAppSetting)
var deleteApplicationSetting = ParameterParser.parse(deleteOldRunFromZipAppSetting)
var isNewValueUpdated: boolean = await this.appServiceUtility.updateAndMonitorAppSettings(updateApplicationSetting, deleteApplicationSetting);
if(!isNewValueUpdated) {
await this.kuduServiceUtility.warmpUp();
}
this.zipDeploymentID = await this.kuduServiceUtility.deployUsingZipDeploy(webPackage, this.taskParams.TakeAppOfflineFlag,
{ slotName: this.appService.getSlot() });
await this.PostDeploymentStep();
}
