public async Task <HttpResponseMessage> Deploy([FromBody] JObject parameters, string subscriptionId, string templateUrl)
{
CreateDeploymentResponse responseObj = new CreateDeploymentResponse();
HttpResponseMessage response = null;
try
{
var resourceGroupName = GetParamOrDefault(parameters, "siteName", "mySite");
using (var client = GetRMClient(subscriptionId))
{
// For now we just default to East US for the resource group location.
var resourceResult = await client.ResourceGroups.CreateOrUpdateAsync(resourceGroupName, new BasicResourceGroup { Location = "East US" });
var templateParams = parameters.ToString();
var basicDeployment = new BasicDeployment
{
Parameters = templateParams,
TemplateLink = new TemplateLink(new Uri(templateUrl))
};
var deploymentResult = await client.Deployments.CreateOrUpdateAsync(resourceGroupName, resourceGroupName, basicDeployment);
response = Request.CreateResponse(HttpStatusCode.OK, responseObj);
}
}
catch (CloudException ex)
{
responseObj.Error = ex.ErrorMessage;
responseObj.ErrorCode = ex.ErrorCode;
response = Request.CreateResponse(HttpStatusCode.BadRequest, responseObj);
}
return(response);
}
/// <summary>
/// Creates new deployment using the passed template file which can be user customized or
/// from gallery templates.
/// </summary>
/// <param name="parameters">The create deployment parameters</param>
/// <returns>The created deployment instance</returns>
public virtual PSResourceGroupDeployment ExecuteDeployment(CreatePSResourceGroupDeploymentParameters parameters)
{
parameters.DeploymentName = GenerateDeploymentName(parameters);
BasicDeployment deployment = CreateBasicDeployment(parameters);
TemplateValidationInfo validationInfo = CheckBasicDeploymentErrors(parameters.ResourceGroupName, parameters.DeploymentName, deployment);
if (validationInfo.Errors.Count != 0)
{
int counter = 1;
string errorFormat = "Error {0}: Code={1}; Message={2}\r\n";
StringBuilder errorsString = new StringBuilder();
validationInfo.Errors.ForEach(e => errorsString.AppendFormat(errorFormat, counter++, e.Code, e.Message));
throw new ArgumentException(errorsString.ToString());
}
else
{
WriteVerbose(ProjectResources.TemplateValid);
}
if (!string.IsNullOrEmpty(parameters.StorageAccountName))
{
WriteWarning("The StorageAccountName parameter is no longer used and will be removed in a future release. Please update scripts to remove this parameter.");
}
ResourceManagementClient.Deployments.CreateOrUpdate(parameters.ResourceGroupName, parameters.DeploymentName, deployment);
WriteVerbose(string.Format("Create template deployment '{0}'.", parameters.DeploymentName));
Deployment result = ProvisionDeploymentStatus(parameters.ResourceGroupName, parameters.DeploymentName, deployment);
return(result.ToPSResourceGroupDeployment(parameters.ResourceGroupName));
}
/// <summary>
/// Creates new deployment using the passed template file which can be user customized or
/// from gallery templates.
/// </summary>
/// <param name="parameters">The create deployment parameters</param>
/// <returns>The created deployment instance</returns>
public virtual PSResourceGroupDeployment ExecuteDeployment(CreatePSResourceGroupDeploymentParameters parameters)
{
parameters.DeploymentName = GenerateDeploymentName(parameters);
BasicDeployment deployment = CreateBasicDeployment(parameters);
List <ResourceManagementError> errors = CheckBasicDeploymentErrors(parameters.ResourceGroupName, parameters.DeploymentName, deployment);
if (errors.Count != 0)
{
int counter = 1;
string errorFormat = "Error {0}: Code={1}; Message={2}\r\n";
StringBuilder errorsString = new StringBuilder();
errors.ForEach(e => errorsString.AppendFormat(errorFormat, counter++, e.Code, e.Message));
throw new ArgumentException(errorsString.ToString());
}
else
{
WriteVerbose(ProjectResources.TemplateValid);
}
ResourceManagementClient.Deployments.CreateOrUpdate(parameters.ResourceGroupName, parameters.DeploymentName, deployment);
WriteVerbose(string.Format("Create template deployment '{0}' using template {1}.", parameters.DeploymentName, deployment.TemplateLink.Uri));
Deployment result = ProvisionDeploymentStatus(parameters.ResourceGroupName, parameters.DeploymentName, deployment);
return(result.ToPSResourceGroupDeployment(parameters.ResourceGroupName));
}
#pragma warning disable 4014
public async Task <HttpResponseMessage> Preview([FromBody] JObject parameters, string subscriptionId, string templateUrl)
{
JObject responseObj = new JObject();
List <string> providers = new List <string>(32);
HttpResponseMessage response = null;
using (var client = GetRMClient(subscriptionId))
{
ResourceGroupCreateOrUpdateResult resourceResult = null;
string tempRGName = Guid.NewGuid().ToString();
try
{
resourceResult = await client.ResourceGroups.CreateOrUpdateAsync(tempRGName, new BasicResourceGroup { Location = "East US" });
// For now we just default to East US for the resource group location.
var basicDeployment = new BasicDeployment
{
Parameters = parameters.ToString(),
TemplateLink = new TemplateLink(new Uri(templateUrl))
};
var deploymentResult = await client.Deployments.ValidateAsync(tempRGName, tempRGName, basicDeployment);
if (deploymentResult.StatusCode == HttpStatusCode.OK)
{
foreach (var p in deploymentResult.Properties.Providers)
{
if (sm_providerMap.ContainsKey(p.Namespace))
{
providers.Add(sm_providerMap[p.Namespace]);
}
else
{
providers.Add(p.Namespace);
}
}
responseObj["providers"] = JArray.FromObject(providers);
response = Request.CreateResponse(HttpStatusCode.OK, responseObj);
}
else
{
responseObj["error"] = deploymentResult.Error.Message;
response = Request.CreateResponse(deploymentResult.StatusCode, responseObj);
}
}
finally
{
if (resourceResult != null &&
(resourceResult.StatusCode == HttpStatusCode.Created || resourceResult.StatusCode == HttpStatusCode.OK))
{
string token = GetTokenFromHeader();
Task.Run(() => { DeleteResourceGroup(subscriptionId, token, tempRGName); });
}
}
}
return(response);
}
/// <summary>
/// Validates a given deployment.
/// </summary>
/// <param name="parameters">The deployment create options</param>
/// <returns>True if valid, false otherwise.</returns>
public virtual List <PSResourceManagerError> ValidatePSResourceGroupDeployment(ValidatePSResourceGroupDeploymentParameters parameters)
{
BasicDeployment deployment = CreateBasicDeployment(parameters);
TemplateValidationInfo validationInfo = CheckBasicDeploymentErrors(parameters.ResourceGroupName, Guid.NewGuid().ToString(), deployment);
if (validationInfo.Errors.Count == 0)
{
WriteVerbose(ProjectResources.TemplateValid);
}
return(validationInfo.Errors.Select(e => e.ToPSResourceManagerError()).ToList());
}
private BasicDeployment CreateBasicDeployment(ValidatePSResourceGroupDeploymentParameters parameters)
{
BasicDeployment deployment = new BasicDeployment
{
Mode = DeploymentMode.Incremental,
Template = GetTemplate(parameters.TemplateFile, parameters.GalleryTemplateIdentity),
Parameters = GetDeploymentParameters(parameters.TemplateParameterObject)
};
return(deployment);
}
private BasicDeployment CreateBasicDeployment(ValidatePSResourceGroupDeploymentParameters parameters)
{
BasicDeployment deployment = new BasicDeployment()
{
Mode = DeploymentMode.Incremental,
TemplateLink = new TemplateLink()
{
Uri = GetTemplateUri(parameters.TemplateFile, parameters.GalleryTemplateIdentity, parameters.StorageAccountName),
ContentVersion = parameters.TemplateVersion
},
Parameters = GetDeploymentParameters(parameters.TemplateParameterObject)
};
return(deployment);
}
private Deployment WaitDeploymentStatus(
string resourceGroup,
string deploymentName,
BasicDeployment basicDeployment,
Action <string, string, BasicDeployment> job,
params string[] status)
{
Deployment deployment = new Deployment();
do
{
if (job != null)
{
job(resourceGroup, deploymentName, basicDeployment);
}
deployment = ResourceManagementClient.Deployments.Get(resourceGroup, deploymentName).Deployment;
Thread.Sleep(2000);
} while (!status.Any(s => s.Equals(deployment.Properties.ProvisioningState, StringComparison.OrdinalIgnoreCase)));
return(deployment);
}
public async Task <HttpResponseMessage> Deploy(DeployInputs inputs)
{
CreateDeploymentResponse responseObj = new CreateDeploymentResponse();
HttpResponseMessage response = null;
try
{
using (var client = GetRMClient(inputs.subscriptionId))
{
// For now we just default to East US for the resource group location.
var resourceResult = await client.ResourceGroups.CreateOrUpdateAsync(
inputs.resourceGroup.name,
new BasicResourceGroup { Location = inputs.resourceGroup.location });
var templateParams = inputs.parameters.ToString();
var basicDeployment = new BasicDeployment
{
Parameters = templateParams,
TemplateLink = new TemplateLink(new Uri(inputs.templateUrl))
};
var deploymentResult = await client.Deployments.CreateOrUpdateAsync(
inputs.resourceGroup.name,
inputs.resourceGroup.name,
basicDeployment);
response = Request.CreateResponse(HttpStatusCode.OK, responseObj);
}
}
catch (CloudException ex)
{
responseObj.Error = ex.ErrorMessage;
responseObj.ErrorCode = ex.ErrorCode;
response = Request.CreateResponse(HttpStatusCode.BadRequest, responseObj);
}
return(response);
}
private List <ResourceManagementError> CheckBasicDeploymentErrors(string resourceGroup, string deploymentName, BasicDeployment deployment)
{
List <ResourceManagementError> errors = new List <ResourceManagementError>();
DeploymentValidateResponse validationResult = ResourceManagementClient.Deployments.Validate(
resourceGroup,
deploymentName,
deployment);
if (!validationResult.IsValid)
{
if (validationResult.Error != null)
{
errors.Add(validationResult.Error);
if (validationResult.Error.Details != null && validationResult.Error.Details.Count > 0)
{
errors.AddRange(validationResult.Error.Details);
}
}
}
return(errors);
}
private void WriteDeploymentProgress(string resourceGroup, string deploymentName, BasicDeployment deployment)
{
const string normalStatusFormat = "Resource {0} '{1}' provisioning status is {2}";
const string failureStatusFormat = "Resource {0} '{1}' failed with message '{2}'";
List <DeploymentOperation> newOperations = new List <DeploymentOperation>();
DeploymentOperationsListResult result = null;
do
{
result = ResourceManagementClient.DeploymentOperations.List(resourceGroup, deploymentName, null);
newOperations = GetNewOperations(operations, result.Operations);
operations.AddRange(newOperations);
} while (!string.IsNullOrEmpty(result.NextLink));
foreach (DeploymentOperation operation in newOperations)
{
string statusMessage = string.Empty;
if (operation.Properties.ProvisioningState != ProvisioningState.Failed)
{
statusMessage = string.Format(normalStatusFormat,
operation.Properties.TargetResource.ResourceType,
operation.Properties.TargetResource.ResourceName,
operation.Properties.ProvisioningState.ToLower());
WriteVerbose(statusMessage);
}
else
{
string errorMessage = ParseErrorMessage(operation.Properties.StatusMessage);
statusMessage = string.Format(failureStatusFormat,
operation.Properties.TargetResource.ResourceType,
operation.Properties.TargetResource.ResourceName,
errorMessage);
WriteError(statusMessage);
}
}
}
private Deployment ProvisionDeploymentStatus(string resourceGroup, string deploymentName, BasicDeployment deployment)
{
operations = new List <DeploymentOperation>();
return(WaitDeploymentStatus(
resourceGroup,
deploymentName,
deployment,
WriteDeploymentProgress,
ProvisioningState.Canceled,
ProvisioningState.Succeeded,
ProvisioningState.Failed));
}
/// <summary>
/// Validate a deployment template.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.Resources.IDeploymentOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The name of the resource group. The name is case
/// insensitive.
/// </param>
/// <param name='deploymentName'>
/// Required. The name of the deployment.
/// </param>
/// <param name='parameters'>
/// Required. Deployment to validate.
/// </param>
/// <returns>
/// Information from validate template deployment response.
/// </returns>
public static Task <DeploymentValidateResponse> ValidateAsync(this IDeploymentOperations operations, string resourceGroupName, string deploymentName, BasicDeployment parameters)
{
return(operations.ValidateAsync(resourceGroupName, deploymentName, parameters, CancellationToken.None));
}
/// <summary>
/// Validate a deployment template.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.Resources.IDeploymentOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The name of the resource group. The name is case
/// insensitive.
/// </param>
/// <param name='deploymentName'>
/// Required. The name of the deployment.
/// </param>
/// <param name='parameters'>
/// Required. Deployment to validate.
/// </param>
/// <returns>
/// Information from validate template deployment response.
/// </returns>
public static DeploymentValidateResponse Validate(this IDeploymentOperations operations, string resourceGroupName, string deploymentName, BasicDeployment parameters)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IDeploymentOperations)s).ValidateAsync(resourceGroupName, deploymentName, parameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
private TemplateValidationInfo CheckBasicDeploymentErrors(string resourceGroup, string deploymentName, BasicDeployment deployment)
{
DeploymentValidateResponse validationResult = ResourceManagementClient.Deployments.Validate(
resourceGroup,
deploymentName,
deployment);
return(new TemplateValidationInfo(validationResult));
}
