/// <summary>
/// Generates parameters template in the desired folder
/// </summary>
/// <param name="baseFilesGenerationDirectory">name of base folder where to save output files</param>
/// <returns>generated parameters template</returns>
public async Task <Template> GenerateParametersTemplateAsync(
List <string> apisToExtract,
LoggerTemplateResources loggerResources,
BackendTemplateResources backendResources,
NamedValuesResources namedValuesResources,
string baseFilesGenerationDirectory)
{
this.logger.LogInformation("Started generation of parameters template...");
var templateParameters = await this.parametersExtractor.CreateMasterTemplateParameterValues(
apisToExtract,
this.loggerExtractor.Cache,
loggerResources,
backendResources,
namedValuesResources,
this.extractorParameters);
if (!templateParameters.Parameters.IsNullOrEmpty())
{
await FileWriter.SaveAsJsonAsync(
templateParameters,
directory : baseFilesGenerationDirectory,
fileName : this.extractorParameters.FileNames.Parameters);
}
this.logger.LogInformation("Finished generation of parameters template...");
return(templateParameters);
}
public async Task <Template <MasterTemplateResources> > GenerateMasterTemplateAsync(
string baseFilesGenerationDirectory,
ApiTemplateResources apiTemplateResources = null,
PolicyTemplateResources policyTemplateResources = null,
ApiVersionSetTemplateResources apiVersionSetTemplateResources = null,
ProductTemplateResources productsTemplateResources = null,
ProductApiTemplateResources productApisTemplateResources = null,
TagApiTemplateResources apiTagsTemplateResources = null,
LoggerTemplateResources loggersTemplateResources = null,
BackendTemplateResources backendsTemplateResources = null,
AuthorizationServerTemplateResources authorizationServersTemplateResources = null,
NamedValuesResources namedValuesTemplateResources = null,
TagTemplateResources tagTemplateResources = null)
{
if (string.IsNullOrEmpty(this.extractorParameters.LinkedTemplatesBaseUrl))
{
this.logger.LogInformation("'{0}' is not passed. Skipping master-template generation.", nameof(this.extractorParameters.LinkedTemplatesBaseUrl));
return(null);
}
this.logger.LogInformation("Started generation of master template...");
var masterTemplate = this.masterTemplateExtractor.GenerateLinkedMasterTemplate(
this.extractorParameters, apiTemplateResources, policyTemplateResources, apiVersionSetTemplateResources,
productsTemplateResources, productApisTemplateResources, apiTagsTemplateResources, loggersTemplateResources,
backendsTemplateResources, authorizationServersTemplateResources, namedValuesTemplateResources, tagTemplateResources);
if (masterTemplate?.HasResources() == true)
{
await FileWriter.SaveAsJsonAsync(
masterTemplate,
directory : baseFilesGenerationDirectory,
fileName : this.extractorParameters.FileNames.LinkedMaster);
}
this.logger.LogInformation("Finished generation of master template...");
return(masterTemplate);
}
public async Task <Template> CreateMasterTemplateParameterValues(
List <string> apisToExtract,
LoggersCache loggersCache,
LoggerTemplateResources loggerTemplateResources,
BackendTemplateResources backendResources,
NamedValuesResources namedValuesResources,
ExtractorParameters extractorParameters)
{
// used to create the parameter values for use in parameters file
// create empty template
var parametersTemplate = this.templateBuilder
.GenerateEmptyTemplate()
.Build();
parametersTemplate.Parameters = new();
var parameters = parametersTemplate.Parameters;
parameters.Add(ParameterNames.ApimServiceName, new() { Value = extractorParameters.DestinationApimName });
AddLinkedUrlParameters();
AddPolicyParameters();
AddNamedValuesParameters();
await AddServiceUrlParameterAsync();
void AddLinkedUrlParameters()
{
if (string.IsNullOrEmpty(extractorParameters.LinkedTemplatesBaseUrl))
{
return;
}
parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, new() { Value = extractorParameters.LinkedTemplatesBaseUrl });
if (!string.IsNullOrEmpty(extractorParameters.LinkedTemplatesSasToken))
{
parameters.Add(ParameterNames.LinkedTemplatesSasToken, new() { Value = extractorParameters.LinkedTemplatesSasToken });
}
if (!string.IsNullOrEmpty(extractorParameters.LinkedTemplatesUrlQueryString))
{
parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, new() { Value = extractorParameters.LinkedTemplatesUrlQueryString });
}
}
void AddPolicyParameters()
{
if (string.IsNullOrEmpty(extractorParameters.PolicyXMLBaseUrl))
{
return;
}
parameters.Add(ParameterNames.PolicyXMLBaseUrl, new() { Value = extractorParameters.PolicyXMLBaseUrl });
if (!string.IsNullOrEmpty(extractorParameters.PolicyXMLSasToken))
{
parameters.Add(ParameterNames.PolicyXMLSasToken, new() { Value = extractorParameters.PolicyXMLSasToken });
}
}
async Task AddServiceUrlParameterAsync()
{
if (!extractorParameters.ParameterizeServiceUrl)
{
return;
}
var serviceUrls = new Dictionary <string, string>();
foreach (var apiName in apisToExtract)
{
var validApiName = ParameterNamingHelper.GenerateValidParameterName(apiName, ParameterPrefix.Api);
string serviceUrl;
if (extractorParameters.ServiceUrlParameters is null)
{
var apiDetails = await this.apisClient.GetSingleAsync(apiName, extractorParameters);
serviceUrl = apiDetails.Properties.ServiceUrl;
}
else
{
serviceUrl = extractorParameters.ServiceUrlParameters.FirstOrDefault(x => x.ApiName.Equals(apiName))?.ServiceUrl;
}
serviceUrls.Add(validApiName, serviceUrl);
}
parameters.Add(ParameterNames.ServiceUrl, new TemplateObjectParameterProperties()
{
Value = serviceUrls
});
}
void AddNamedValuesParameters()
{
if (!extractorParameters.ParameterizeNamedValue &&
!extractorParameters.ParamNamedValuesKeyVaultSecrets)
{
return;
}
var namedValuesParameters = new Dictionary <string, string>();
var keyVaultNamedValues = new Dictionary <string, string>();
foreach (var namedValue in namedValuesResources.NamedValues)
{
if (extractorParameters.ParameterizeNamedValue && namedValue?.Properties.KeyVault == null)
{
var propertyValue = namedValue.Properties.Value;
var validPName = ParameterNamingHelper.GenerateValidParameterName(namedValue.OriginalName, ParameterPrefix.Property);
namedValuesParameters.Add(validPName, propertyValue);
}
if (extractorParameters.ParamNamedValuesKeyVaultSecrets && namedValue?.Properties.KeyVault is not null)
{
var propertyValue = namedValue.Properties.KeyVault.SecretIdentifier;
var validPName = ParameterNamingHelper.GenerateValidParameterName(namedValue.OriginalName, ParameterPrefix.Property);
keyVaultNamedValues.Add(validPName, propertyValue);
}
}
parameters.Add(ParameterNames.NamedValues, new TemplateObjectParameterProperties()
{
Value = namedValuesParameters
});
parameters.Add(ParameterNames.NamedValueKeyVaultSecrets, new TemplateObjectParameterProperties()
{
Value = keyVaultNamedValues
});
}
if (extractorParameters.ParameterizeApiLoggerId)
{
parameters.Add(ParameterNames.ApiLoggerId, new TemplateObjectParameterProperties()
{
Value = loggersCache.CreateResultingMap()
});
}
if (extractorParameters.ParameterizeLogResourceId)
{
parameters.Add(ParameterNames.LoggerResourceId, new TemplateObjectParameterProperties()
{
Value = loggerTemplateResources.LoggerResourceIds
});
}
if (extractorParameters.ParameterizeBackend)
{
parameters.Add(ParameterNames.BackendSettings, new TemplateObjectParameterProperties()
{
Value = backendResources.BackendNameParametersCache
});
}
return(parametersTemplate);
}
public Template <MasterTemplateResources> GenerateLinkedMasterTemplate(
ExtractorParameters extractorParameters,
ApiTemplateResources apiTemplateResources = null,
PolicyTemplateResources policyTemplateResources = null,
ApiVersionSetTemplateResources apiVersionSetTemplateResources = null,
ProductTemplateResources productsTemplateResources = null,
ProductApiTemplateResources productAPIsTemplateResources = null,
TagApiTemplateResources apiTagsTemplateResources = null,
LoggerTemplateResources loggersTemplateResources = null,
BackendTemplateResources backendsTemplateResources = null,
AuthorizationServerTemplateResources authorizationServersTemplateResources = null,
NamedValuesResources namedValuesTemplateResources = null,
TagTemplateResources tagTemplateResources = null)
{
var masterTemplate = this.templateBuilder
.GenerateEmptyTemplate()
.Build <MasterTemplateResources>();
masterTemplate.Parameters = this.CreateMasterTemplateParameters(extractorParameters);
var masterResources = masterTemplate.TypedResources;
var fileNames = extractorParameters.FileNames;
// all other deployment resources will depend on named values
var dependsOnNamedValues = Array.Empty <string>();
// api dependsOn
var apiDependsOn = new List <string>();
var productApiDependsOn = new List <string>();
var apiTagDependsOn = new List <string>();
if (namedValuesTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding named-values to master template");
const string NamedValuesTemplateName = "namedValuesTemplate";
dependsOnNamedValues = new string[] { $"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{NamedValuesTemplateName}')]" };
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{NamedValuesTemplateName}')]");
var namedValuesUri = this.GenerateLinkedTemplateUri(fileNames.NamedValues, extractorParameters);
var namedValuesDeployment = CreateLinkedMasterTemplateResourceForPropertyTemplate(
NamedValuesTemplateName,
namedValuesUri,
Array.Empty <string>(),
extractorParameters);
masterResources.DeploymentResources.Add(namedValuesDeployment);
}
if (policyTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding policy to master template");
const string GlobalServicePolicyTemplate = "globalServicePolicyTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{GlobalServicePolicyTemplate}')]");
var globalServicePolicyUri = this.GenerateLinkedTemplateUri(fileNames.GlobalServicePolicy, extractorParameters);
var policyDeployment = CreateLinkedMasterTemplateResourceWithPolicyToken(
GlobalServicePolicyTemplate,
globalServicePolicyUri,
dependsOnNamedValues,
extractorParameters);
masterResources.DeploymentResources.Add(policyDeployment);
}
if (apiVersionSetTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding api-version-set to master template");
const string VersionSetTemplate = "versionSetTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{VersionSetTemplate}')]");
string apiVersionSetUri = this.GenerateLinkedTemplateUri(fileNames.ApiVersionSets, extractorParameters);
var apiVersionSetDeployment = CreateLinkedMasterTemplateResource(VersionSetTemplate, apiVersionSetUri, dependsOnNamedValues);
masterResources.DeploymentResources.Add(apiVersionSetDeployment);
}
if (productsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding products to master template");
const string ProductsTemplate = "productsTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ProductsTemplate}')]");
productApiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ProductsTemplate}')]");
var productsUri = this.GenerateLinkedTemplateUri(fileNames.Products, extractorParameters);
var productDeployment = CreateLinkedMasterTemplateResource(ProductsTemplate, productsUri, dependsOnNamedValues);
if (!string.IsNullOrEmpty(extractorParameters.PolicyXMLBaseUrl))
{
productDeployment.Properties.Parameters.Add(ParameterNames.PolicyXMLBaseUrl, new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.PolicyXMLBaseUrl}')]"
});
}
if (!string.IsNullOrEmpty(extractorParameters.PolicyXMLSasToken))
{
productDeployment.Properties.Parameters.Add(ParameterNames.PolicyXMLSasToken, new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.PolicyXMLSasToken}')]"
});
}
masterResources.DeploymentResources.Add(productDeployment);
}
if (tagTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding tags to master template");
const string TagTemplate = "tagTemplate";
apiTagDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{TagTemplate}')]");
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{TagTemplate}')]");
var tagUri = this.GenerateLinkedTemplateUri(fileNames.Tags, extractorParameters);
var tagDeployment = CreateLinkedMasterTemplateResource(TagTemplate, tagUri, dependsOnNamedValues);
masterResources.DeploymentResources.Add(tagDeployment);
}
if (loggersTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding loggers to master template");
const string LoggersTemplate = "loggersTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{LoggersTemplate}')]");
string loggersUri = this.GenerateLinkedTemplateUri(fileNames.Loggers, extractorParameters);
var loggersDeployment = CreateLinkedMasterTemplateResourceForLoggerTemplate(LoggersTemplate, loggersUri, dependsOnNamedValues, extractorParameters);
masterResources.DeploymentResources.Add(loggersDeployment);
}
if (backendsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding backends to master template");
const string BackendsTemplate = "backendsTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{BackendsTemplate}')]");
string backendsUri = this.GenerateLinkedTemplateUri(fileNames.Backends, extractorParameters);
var backendsDeployment = CreateLinkedMasterTemplateResource(BackendsTemplate, backendsUri, dependsOnNamedValues);
if (extractorParameters.ParameterizeBackend)
{
backendsDeployment.Properties.Parameters.Add(ParameterNames.BackendSettings,
new TemplateParameterProperties()
{
Value = $"[parameters('{ParameterNames.BackendSettings}')]"
});
}
masterResources.DeploymentResources.Add(backendsDeployment);
}
if (authorizationServersTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding authorizationServers to master template");
const string AuthorizationServersTemplate = "authorizationServersTemplate";
apiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{AuthorizationServersTemplate}')]");
var authorizationServersUri = this.GenerateLinkedTemplateUri(fileNames.AuthorizationServers, extractorParameters);
var authorizationServersDeployment = CreateLinkedMasterTemplateResource(AuthorizationServersTemplate, authorizationServersUri, dependsOnNamedValues);
masterResources.DeploymentResources.Add(authorizationServersDeployment);
}
if (apiTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding apis to master template");
const string ApisTemplate = "apisTemplate";
apiTagDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ApisTemplate}')]");
productApiDependsOn.Add($"[resourceId('{ResourceTypeConstants.ArmDeployments}', '{ApisTemplate}')]");
var apisUri = this.GenerateLinkedTemplateUri(apiTemplateResources.FileName, extractorParameters);
var apisDeployment = CreateLinkedMasterTemplateResourceForApiTemplate(ApisTemplate, apisUri, apiDependsOn.ToArray(), extractorParameters);
masterResources.DeploymentResources.Add(apisDeployment);
}
if (productAPIsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding productApis to master template");
const string ProductApisTemplate = "productAPIsTemplate";
var productApisUri = this.GenerateLinkedTemplateUri(fileNames.ProductAPIs, extractorParameters);
var productApisDeployment = CreateLinkedMasterTemplateResource(ProductApisTemplate, productApisUri, productApiDependsOn.ToArray());
masterResources.DeploymentResources.Add(productApisDeployment);
}
if (apiTagsTemplateResources?.HasContent() == true)
{
this.logger.LogDebug("Adding apiTags to master template");
const string ApiTagsTemplate = "apiTagsTemplate";
var apiTagsUri = this.GenerateLinkedTemplateUri(fileNames.TagApi, extractorParameters);
var apiTagsDeployment = CreateLinkedMasterTemplateResource(ApiTagsTemplate, apiTagsUri, apiTagDependsOn.ToArray());
masterResources.DeploymentResources.Add(apiTagsDeployment);
}
return(masterTemplate);
}
