public RequestOrchestration(
IInfrastructure infrastructure,
ARMTemplateHelper templateHelper)
{
this.infrastructure = infrastructure;
this.templateHelper = templateHelper;
}
public AsyncRequestActivity(IOptions <CommunicationWorkerOptions> options,
ARMTemplateHelper templateHelper,
IInfrastructure infrastructure)
{
this.infrastructure = infrastructure;
this.templateHelper = templateHelper;
asyncRequestActivity = new maskx.OrchestrationService.Activity.AsyncRequestActivity(options);
}
public DeploymentOrchestration(
ARMTemplateHelper helper,
IInfrastructure infrastructure,
ARMFunctions aRMFunctions)
{
this._ARMFunctions = aRMFunctions;
this.helper = helper;
this.infrastructure = infrastructure;
}
public WaitDependsOnActivity(IOptions <ARMOrchestrationOptions> options,
ARMTemplateHelper templateHelper,
IInfrastructure infrastructure)
{
this.options = options?.Value;
this.templateHelper = templateHelper;
this.infrastructure = infrastructure;
this.commandText = string.Format(commandTemplate, this.options.Database.WaitDependsOnTableName);
}
/// <summary>
/// Parses and checks the given JSON object to see if any armTemplateParameters were added or removed.
/// If parameters were added then they are created in the db along with a join entry in the armTemplateArmTemplateParameters table.
/// If parameters were removed then the join entry in the armTemplateArmTemplateParameters table is removed.
/// </summary>
/// <param name="offer">The name of the offer the parameters belong to</param>
/// <param name="armTemplateJSON">The JSON object to parse.</param>
/// <param name="armTemplateId">The ID of the armTemplate.</param>
/// <returns></returns>
private async Task UpdateArmTemplateParameters(Offer offer, object armTemplateJSON, long armTemplateId)
{
List <KeyValuePair <string, string> > incompleteParams = ARMTemplateHelper.GetArmTemplateParameters(armTemplateJSON.ToString());
List <ArmTemplateArmTemplateParameter> joinEntries = await _armTemplateArmTemplateParameterService.GetAllJoinEntries(armTemplateId);
Dictionary <string, ArmTemplateParameter> paramsDb = new Dictionary <string, ArmTemplateParameter>();
HashSet <string> usedParamNames = new HashSet <string>();
// Populate paramsDb so that it maps the ArmTemplateParameter name to the ArmTemplateParameter object
foreach (ArmTemplateArmTemplateParameter entry in joinEntries)
{
ArmTemplateParameter armTemplateParameter = await _context.ArmTemplateParameters.FindAsync(entry.ArmTemplateParameterId);
if (!paramsDb.ContainsKey(armTemplateParameter.Name))
{
paramsDb.Add(armTemplateParameter.Name, armTemplateParameter);
}
}
foreach (KeyValuePair <string, string> incompleteParam in incompleteParams)
{
// Check if a param with the same name as the incompleteParam already exists
if (!paramsDb.ContainsKey(incompleteParam.Key))
{
ArmTemplateParameter armParameter = new ArmTemplateParameter
{
OfferId = offer.Id,
Name = incompleteParam.Key,
Type = incompleteParam.Value,
// TODO: do we need to indicate an incomplete parameter?
Value = string.Empty
};
// A param with the same name as the incompleteParam does not exist, so create it
await _armTemplateParameterService.CreateAsync(offer.OfferName, armTemplateId, armParameter);
}
// Keep track of all the new parameters we are using in usedParamNames
if (!usedParamNames.Contains(incompleteParam.Key))
{
usedParamNames.Add(incompleteParam.Key);
}
}
foreach (KeyValuePair <string, ArmTemplateParameter> paramDb in paramsDb)
{
// Check if there is a param in the db that we are no longer using
if (!usedParamNames.Contains(paramDb.Key))
{
ArmTemplateArmTemplateParameter armTemplateArmTemplateParameter = await _context.ArmTemplateArmTemplateParameters.FindAsync(armTemplateId, paramDb.Value.Id);
// Remove the join entry for any unused params
_context.ArmTemplateArmTemplateParameters.Remove(armTemplateArmTemplateParameter);
await _context._SaveChangesAsync();
}
}
}
/// <summary>
/// Parse the ARM template to get the parameter names and build an object containing the parameter names and values
/// </summary>
/// <param name="offer"></param>
/// <param name="plan"></param>
/// <param name="subscriptionAction"></param>
/// <returns>An object containing the parameter names and values</returns>
public async Task <Dictionary <string, object> > GetTemplateParameters(
Offer offer,
Plan plan,
FulfillmentAction subscriptionAction
)
{
ArmTemplate template = null;
switch (subscriptionAction)
{
case FulfillmentAction.Activate:
template = await _lunaClient.GetArmTemplate(offer.OfferName, plan.SubscribeArmTemplateName);
break;
case FulfillmentAction.Update:
template = await _lunaClient.GetArmTemplate(offer.OfferName, plan.SubscribeArmTemplateName);
break;
case FulfillmentAction.Unsubscribe:
template = await _lunaClient.GetArmTemplate(offer.OfferName, plan.UnsubscribeArmTemplateName);
break;
default:
throw new InvalidEnumArgumentException();
}
string templateContent = await _storage.DownloadToTextAsync(template.TemplateFilePath);
var parameters = ARMTemplateHelper.GetArmTemplateParameters(templateContent);
var parameterList = new Dictionary <string, object>();
foreach (var parameter in parameters)
{
ArmTemplateParameter atp = await _lunaClient.GetArmTemplateParameter(offer.OfferName, parameter.Key);
parameterList.Add(
atp.Name,
new { Value = atp.Value }
);
}
return(parameterList);
}
/// <summary>
/// Parses the given JSON object for ArmTemplateParameters then creates them in the db.
/// The join entry is also created in the armTemplateArmTemplateParameters table.
/// </summary>
/// <param name="offer">The name of the offer the parameters belong to.</param>
/// <param name="armTemplateJSON">The JSON to parse.</param>
/// <param name="armTemplateId">The ID of the armTemplate.</param>
/// <returns></returns>
private async Task CreateArmTemplateParameters(Offer offer, object armTemplateJSON, long armTemplateId)
{
var parameters = ARMTemplateHelper.GetArmTemplateParameters(armTemplateJSON.ToString());
foreach (var param in parameters)
{
ArmTemplateParameter armParameter = new ArmTemplateParameter
{
OfferId = offer.Id,
Name = param.Key,
Type = param.Value,
// TODO: do we need to indicate an incomplete parameter?
Value = string.Empty
};
await _armTemplateParameterService.CreateAsync(offer.OfferName, armTemplateId, armParameter);
}
}
public ExpandResourcePropertiesActivity(ARMFunctions functions, IInfrastructure infrastructure, ARMTemplateHelper helper)
{
this.functions = functions;
this.infrastructure = infrastructure;
this.helper = helper;
}
public CopyOrchestration(ARMTemplateHelper helper, IInfrastructure infrastructure)
{
this.helper = helper;
this.infrastructure = infrastructure;
}
public async Task <Subscription> DeployArmTemplateAsync(Guid subscriptionId)
{
Subscription subscription = await _context.Subscriptions.FindAsync(subscriptionId);
ValidateSubscriptionAndInputState(subscription);
try
{
if (subscription.ResourceGroup == null)
{
// If resource group is not created, transit to ProvisioningPending state to create resource group
return(await TransitToNextState(subscription, ProvisioningState.ProvisioningPending));
}
Offer offer = await FindOfferById(subscription.OfferId);
Plan plan = await FindPlanById(subscription.PlanId);
string deploymentName = $"{plan.PlanName}{offer.OfferName}{new Random().Next(0, 9999).ToString("D4")}"; // deployment name cannot exceed 64 characters, otherwise returns 400
string isvSubscriptionId = offer.HostSubscription.ToString();
string templatePath = await GetTemplatePath(plan, subscription.ProvisioningType);
if (templatePath == null)
{
// If template is not specified, do nothing and transit to WebhookPending state
return(await TransitToNextState(subscription, ProvisioningState.WebhookPending));
}
// Reevaluate parameters if not subscribe. If it is subscribe, the parameters are evaluated when creating resource group
if (!subscription.ProvisioningType.Equals(nameof(ProvisioningType.Subscribe)))
{
await EvaluateParameters(offer, plan, subscription);
}
templatePath = await _storageUtility.GetFileReferenceWithSasKeyAsync(templatePath);
JObject parameters = new JObject();
using (WebClient client = new WebClient())
{
string content = client.DownloadString(templatePath);
Context context = await SetContext(offer.OfferName, subscription.Owner, subscriptionId, plan.PlanName, subscription.ProvisioningType);
var paramList = ARMTemplateHelper.GetArmTemplateParameters(content);
foreach (var param in paramList)
{
JProperty value = new JProperty("value", context.Parameters[param.Key]);
parameters.Add(param.Key, new JObject(value));
}
}
_logger.LogInformation(
LoggingUtils.ComposeHttpClientLogMessage(
_provisioningClient.GetType().Name,
nameof(_provisioningClient.PutDeploymentAsync),
subscriptionId));
var result = await _provisioningClient.PutDeploymentAsync(
Guid.NewGuid(),
Guid.NewGuid(),
isvSubscriptionId,
subscription.ResourceGroup,
deploymentName,
parameters : parameters,
templatePath : templatePath);
subscription.DeploymentName = result.Name;
_logger.LogInformation($"Running ARM deployment {deploymentName} for subscription {isvSubscriptionId} in resource group {subscription.ResourceGroup}.");
return(await TransitToNextState(subscription, ProvisioningState.ArmTemplateRunning));
}
catch (Exception e)
{
return(await HandleExceptions(subscription, e));
}
}
public ValidateTemplateActivity(ARMTemplateHelper templateHelper, IInfrastructure infrastructure)
{
this.templateHelper = templateHelper;
this.infrastructure = infrastructure;
}
public DeploymentOperationActivity(ARMTemplateHelper templateHelper)
{
this.templateHelper = templateHelper;
}
