public async Task <Template> Create(DeploymentDefinition creatorConfig)
{
var template = EmptyTemplate;
template.Parameters.Add(ApiServiceNameParameter.Key, ApiServiceNameParameter.Value);
var resources = new List <TemplateResource>();
foreach (var tag in creatorConfig.Tags)
{
var tagTemplateResource = new TagTemplateResouce()
{
Name = $"[concat(parameters('ApimServiceName'), '/{tag.Name}')]",
Properties = new TagPropertise()
{
DisplayName = tag.DisplayName
},
DependsOn = new string[0]
};
resources.Add(tagTemplateResource);
}
template.Resources = resources.ToArray();
return(await Task.FromResult(template));
}
private bool ValidateApis(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Apis == null)
{
throw new ArgumentException("API configuration is required");
}
foreach (ApiDeploymentDefinition api in deploymentDefinition.Apis)
{
if (api.Name == null)
{
throw new ArgumentException("API name is required");
}
if (api.OpenApiSpec == null)
{
throw new ArgumentException("Open API Spec is required");
}
if (api.Path == null)
{
throw new ArgumentException("API path is required");
}
if (api.Operations != null)
{
foreach (KeyValuePair <string, OperationsDeploymentDefinition> operation in api.Operations)
{
if (operation.Value == null || operation.Value.Policy == null)
{
throw new ArgumentException("Policy XML is required if an API operation is provided");
}
}
}
}
return(true);
}
private async Task <DeploymentDefinition> AggregateDeploymentDefinitionsAsync(CommandLineOption option)
{
var deploymentDefinition = default(DeploymentDefinition);
if (Directory.Exists(option.YamlConfigPath))
{
var fileDefinitionPaths = Directory.GetFiles(option.YamlConfigPath, "*.yml", new EnumerationOptions
{
RecurseSubdirectories = true
});
deploymentDefinition = new DeploymentDefinition();
foreach (var fileDefinitionPath in fileDefinitionPaths)
{
var individualDefinition = await _fileReader.GetDeploymentDefinitionFromYaml(fileDefinitionPath);
deploymentDefinition = deploymentDefinition.MergeWith(individualDefinition);
}
}
else
{
deploymentDefinition = await _fileReader.GetDeploymentDefinitionFromYaml(option.YamlConfigPath);
}
return(deploymentDefinition);
}
private bool IsCreatorConfigValid(DeploymentDefinition creatorConfig)
{
var creatorConfigurationValidator = new ConfigurationValidator();
bool isValidCreatorConfig = creatorConfigurationValidator.Validate(creatorConfig);
return(isValidCreatorConfig);
}
private IEnumerable <ArmTemplateResource <ApiProperties> > CreateApis(DeploymentDefinition deploymentDefinition)
{
return(new ArmTemplateResourceCreator <ApiDeploymentDefinition, ApiProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Apis)
.WithName(d => d.Name)
.OfType(ResourceType.Api)
.CheckDependencies()
.CreateResources());
}
private bool ValidateBaseProperties(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Version == null)
{
throw new ArgumentException("Version is required");
}
if (deploymentDefinition.ApimServiceName == null)
{
throw new ArgumentException("APIM service name is required");
}
return(true);
}
public bool Validate(DeploymentDefinition deploymentDefinition)
{
// ensure required parameters have been passed in
return(ValidateBaseProperties(deploymentDefinition) &&
ValidateApis(deploymentDefinition) &&
ValidateApiVersionSets(deploymentDefinition) &&
ValidateProducts(deploymentDefinition) &&
ValidateLoggers(deploymentDefinition) &&
ValidateAuthorizationServers(deploymentDefinition) &&
ValidateBackends(deploymentDefinition));
}
private bool ValidateAuthorizationServers(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.AuthorizationServers != null)
{
foreach (var authorizationServer in deploymentDefinition.AuthorizationServers)
{
if (authorizationServer.DisplayName == null)
{
throw new ArgumentException("Display name is required if an Authorization Server is provided");
}
}
}
return(true);
}
private bool ValidateBackends(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Backends != null)
{
foreach (var backend in deploymentDefinition.Backends)
{
if (backend.Title == null)
{
throw new ArgumentException("Title is required if a Backend is provided");
}
}
}
return(true);
}
private bool ValidateLoggers(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Loggers != null)
{
foreach (LoggerDeploymentDefinition logger in deploymentDefinition.Loggers)
{
if (logger.Name == null)
{
throw new ArgumentException("Name is required if an Logger is provided");
}
}
}
return(true);
}
public IEnumerable <ArmTemplateResource> Create(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.AuthorizationServers.Count() == 0)
{
return(Array.Empty <ArmTemplateResource>());
}
Console.WriteLine("Creating authorization servers template");
Console.WriteLine("------------------------------------------");
return(new ArmTemplateResourceCreator <AuthorizationServerDeploymentDefinition, AuthorizationServerProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.AuthorizationServers)
.WithName(d => d.DisplayName)
.OfType(ResourceType.AuthorizationServer)
.CreateResources());
}
public IEnumerable <ArmTemplateResource> Create(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Policy != null)
{
return(Array.Empty <ArmTemplateResource>());
}
Console.WriteLine("Creating global service policy template");
Console.WriteLine("------------------------------------------");
return(new ArmTemplateResourceCreator <DeploymentDefinition, PolicyProperties>(_mapper)
.ForDeploymentDefinition(deploymentDefinition)
.WithName((_) => "/policy")
.OfType(ResourceType.GlobalServicePolicy)
.CreateResourcesIf(d => d.Policy != null));
}
public IEnumerable <ArmTemplateResource> Create(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.NamedValues.Count() == 0)
{
return(Array.Empty <ArmTemplateResource>());
}
Console.WriteLine("Creating named values resources");
Console.WriteLine("------------------------------------------");
return(new ArmTemplateResourceCreator <NamedValueDeploymentDefinition, NamedValueProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.NamedValues)
.WithName(d => d.Name)
.OfType(ResourceType.NamedValue)
.CreateResources());
}
public IEnumerable <ArmTemplateResource> Create(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Tags.Count() == 0)
{
return(Array.Empty <ArmTemplateResource>());
}
Console.WriteLine("Creating tags template");
Console.WriteLine("------------------------------------------");
return(new ArmTemplateResourceCreator <TagDeploymentDefinition, TagProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Tags)
.WithName(d => d.Name)
.OfType(ResourceType.Tag)
.CreateResources());
}
public IEnumerable <ArmTemplateResource> Create(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Subscriptions.Count() == 0)
{
return(Array.Empty <ArmTemplateResource>());
}
Console.WriteLine("Creating subscriptions template");
Console.WriteLine("------------------------------------------");
return(new ArmTemplateResourceCreator <SubscriptionDeploymentDefinition, SubscriptionProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Subscriptions)
.WithName(d => d.Name)
.OfType(ResourceType.Subscription)
.CheckDependencies()
.CreateResources());
}
private bool ValidateApiVersionSets(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.ApiVersionSets != null)
{
foreach (ApiVersionSetDeploymentDefinition apiVersionSet in deploymentDefinition.ApiVersionSets)
{
if (apiVersionSet != null && apiVersionSet.DisplayName == null)
{
throw new ArgumentException("Display name is required if an API Version Set is provided");
}
if (apiVersionSet != null && apiVersionSet.Name == null)
{
throw new ArgumentException("Name is required if an API Version Set is provided");
}
}
}
return(true);
}
private bool ValidateProducts(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Products != null)
{
foreach (var product in deploymentDefinition.Products)
{
if (product.DisplayName == null)
{
throw new ArgumentException("Display name is required if an Product is provided");
}
if (product.Name == null)
{
throw new ArgumentException("Name is required if an Product is provided");
}
}
}
return(true);
}
public IEnumerable <ArmTemplateResource> Create(DeploymentDefinition deploymentDefinition)
{
if (deploymentDefinition.Products.Count() == 0)
{
return(Array.Empty <ArmTemplateResource>());
}
Console.WriteLine("Creating products template");
Console.WriteLine("------------------------------------------");
var resources = new List <ArmTemplateResource>();
resources.AddRange(CreateProducts(deploymentDefinition));
resources.AddRange(CreateProductPolicies(deploymentDefinition));
resources.AddRange(CreateProductTags(deploymentDefinition));
return(resources);
}
public static async Task <DeploymentResult> DeployAndConfigureAsync(DeploymentDefinition deploymentDefinition)
{
var windowsHostNames = new List <string>();
var deployTasks = deploymentDefinition.WindowsTemplates
.Select(s =>
{
var hostName = "win_" + Guid.NewGuid();
windowsHostNames.Add(hostName);
return(PowerShellProxy.ExecuteCommandAsync(CreateWindowsDeploymentScriptBlock(s, hostName), "bajor"));
}).ToList();
var elkHostname = "elk_" + Guid.NewGuid();
deployTasks.Add(
PowerShellProxy.ExecuteCommandAsync(CreateElkDeploymentScriptBlock(deploymentDefinition.ElkTemplate, elkHostname),
"bajor"));
await Task.WhenAll(deployTasks);
var elkIp = await GetIpAddressFromVmName(elkHostname);
var windowsIps = new List <string>();
foreach (var hostname in windowsHostNames)
{
var winIp = await GetIpAddressFromVmName(hostname);
windowsIps.Add(winIp);
// Configure Windows VM
}
return(new DeploymentResult
{
ElkIp = elkIp,
WindowsIps = windowsIps
});
}
private bool ValidateDeploymentDefinition(DeploymentDefinition deploymentDefinition)
{
var DeploymentDefinitionValidator = new DeploymentDefinitionValidator();
return(DeploymentDefinitionValidator.Validate(deploymentDefinition));
}
public ArmTemplateCreator(DeploymentDefinition deploymentDefinition, IMapper mapper)
{
_deploymentDefinition = deploymentDefinition;
_mapper = mapper;
}
private IEnumerable <ArmTemplateResource <ProductPolicyProperties> > CreateProductPolicies(DeploymentDefinition deploymentDefinition)
{
return(new ArmTemplateResourceCreator <ProductDeploymentDefinition, ProductPolicyProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Products)
.WithName(d => $"{d.Name}/policy")
.OfType(ResourceType.ProductPolicy)
.WhichDependsOnResourceOfType(ResourceType.Product)
.WhichDependsOnResourceWithName(d => d.Name)
.CreateResourcesIf(d => d.Policy != null, true));
}
private IEnumerable <ArmTemplateResource <TagProductProperties> > CreateProductTags(DeploymentDefinition deploymentDefinition)
{
return(new ArmTemplateResourceCreator <ProductDeploymentDefinition, TagProductProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Products)
.UseResourceCreator(ProductDeploymentDefinition =>
{
var templateResources = new List <ArmTemplateResource <TagProductProperties> >();
foreach (string tagDisplayName in ProductDeploymentDefinition.TagList)
{
var tagName = ProductDeploymentDefinition.GetTagName(tagDisplayName);
var templateRsource = new ArmTemplateResource <TagProductProperties>(
$"{ProductDeploymentDefinition.Name}/{tagName}",
$"[concat(parameters('ApimServiceName'), '/{ProductDeploymentDefinition.Name}/{tagName}')]",
ResourceType.TagProduct,
new TagProductProperties(),
new string[]
{
$"[resourceId('{ResourceType.Product}', parameters('ApimServiceName'), '{ProductDeploymentDefinition.Name}')]",
$"[resourceId('{ResourceType.Tag}', parameters('ApimServiceName'), '{tagName}')]"
});
templateResources.Add(templateRsource);
}
return templateResources;
})
.CreateResourcesIf(d => d.Tags != null, true));
}
private IEnumerable <ArmTemplateResource <ProductApiProperties> > CreateProductApis(DeploymentDefinition deploymentDefinition)
{
return(new ArmTemplateResourceCreator <ApiDeploymentDefinition, ProductApiProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Apis)
.UseResourceCreator(apiDeploymentDefinition =>
{
var templateResources = new List <ArmTemplateResource <ProductApiProperties> >();
foreach (string productDisplayName in apiDeploymentDefinition.ProductList)
{
var productName = apiDeploymentDefinition.GetProductName(productDisplayName);
var dependencies = new List <string>()
{
$"[resourceId('{ResourceType.Api}', parameters('ApimServiceName'), '{apiDeploymentDefinition.Name}')]",
$"[resourceId('{ResourceType.Product}', parameters('ApimServiceName'), '{productName}')]"
};
var templateResource = new ArmTemplateResource <ProductApiProperties>(
$"{productName}/{apiDeploymentDefinition.Name}",
$"[concat(parameters('ApimServiceName'), '/{productName}/{apiDeploymentDefinition.Name}')]",
ResourceType.ProductApi,
new ProductApiProperties(),
dependencies);
templateResources.Add(templateResource);
}
return templateResources;
})
.CreateResourcesIf(d => d.IsDependentOnProducts(), true));
}
public ArmTemplateCreator(DeploymentDefinition creatorConfig)
{
_creatorConfig = creatorConfig;
_fileWriter = new FileWriter();
_templateFileNames = new TemplateFileName(_creatorConfig.PrefixFileName, _creatorConfig.MasterTemplateName);
}
private IEnumerable <ArmTemplateResource <ApiPolicyProperties> > CreateApiPolicies(DeploymentDefinition deploymentDefinition)
{
return(new ArmTemplateResourceCreator <ApiDeploymentDefinition, ApiPolicyProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Apis)
.WithName(d => $"{d.Name}/policy")
.OfType(ResourceType.ApiPolicy)
.WhichDependsOnResourceOfType(ResourceType.Api)
.WhichDependsOnResourceWithName(d => d.Name)
.CreateResourcesIf(d => d.HasPolicy()));
}
private IEnumerable <ArmTemplateResource <ApiOperationPolicyProperties> > CreateOperationPolicies(DeploymentDefinition deploymentDefinition)
{
return(new ArmTemplateResourceCreator <ApiDeploymentDefinition, ApiOperationPolicyProperties>(_mapper)
.ForDeploymentDefinitions(deploymentDefinition.Apis)
.UseResourceCreator(apiDeploymentDefinition =>
{
var templateResources = new List <ArmTemplateResource <ApiOperationPolicyProperties> >();
var fileReader = new FileReader();
foreach (var pair in apiDeploymentDefinition.Operations)
{
var operationPolicy = pair.Value.Policy;
var operationName = pair.Key;
var isUrl = operationPolicy.IsUri(out _);
var templateResource = new ArmTemplateResource <ApiOperationPolicyProperties>(
$"{apiDeploymentDefinition.Name}/{operationName}/policy",
$"[concat(parameters('ApimServiceName'), '/{apiDeploymentDefinition.Name}/{operationName}/policy')]",
ResourceType.ApiOperationPolicy,
new ApiOperationPolicyProperties()
{
Format = isUrl ? "rawxml-link" : "rawxml",
Value = isUrl ? operationPolicy : fileReader.RetrieveFileContentsAsync(operationPolicy).Result
},
new string[] { $"[resourceId('{ResourceType.Api}', parameters('ApimServiceName'), '{apiDeploymentDefinition.Name}')]" });
templateResources.Add(templateResource);
}
return templateResources;
})
.CreateResourcesIf(d => d.Operations != null, true));
}
public async Task <IActionResult> Deploy([FromBody] DeploymentDefinition deploymentDefinition)
{
var deploymentResult = await DeploymentHelper.DeployAndConfigureAsync(deploymentDefinition);
return(Ok(deploymentResult));
}
private async Task GenerateArmTemplateFile(List <ArmTemplateResource> resources, DeploymentDefinition deploymentDefinition)
{
var fileGenerator = new ArmTemplateFileGenerator(deploymentDefinition.OutputLocation,
deploymentDefinition.MasterTemplateName,
deploymentDefinition.PrefixFileName,
deploymentDefinition.ApimServiceName);
await fileGenerator.Save(resources);
}
