/// <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); }