public CreateCommand() { this.Name = GlobalConstants.CreateName; this.Description = GlobalConstants.CreateDescription; // list command options CommandOption configFile = this.Option("--configFile <configFile>", "Config YAML file location", CommandOptionType.SingleValue).IsRequired(); CommandOption appInsightsInstrumentationKey = this.Option("--appInsightsInstrumentationKey <appInsightsInstrumentationKey>", "AppInsights intrumentationkey", CommandOptionType.SingleValue); CommandOption appInsightsName = this.Option("--appInsightsName <appInsightsName>", "AppInsights Name", CommandOptionType.SingleValue); // list command options CommandOption backendurlconfigFile = this.Option("--backendurlconfigFile <backendurlconfigFile>", "backend url json file location", CommandOptionType.SingleValue); this.HelpOption(); this.OnExecute(async() => { // convert config file to CreatorConfig class FileReader fileReader = new FileReader(); CreatorConfig creatorConfig = await fileReader.ConvertConfigYAMLToCreatorConfigAsync(configFile.Value()); AppInsightsUpdater appInsightsUpdater = new AppInsightsUpdater(); appInsightsUpdater.UpdateAppInsightNameAndInstrumentationKey(creatorConfig, appInsightsInstrumentationKey, appInsightsName); // validate creator config CreatorConfigurationValidator creatorConfigurationValidator = new CreatorConfigurationValidator(this); //if backendurlfile passed as parameter if (backendurlconfigFile != null && !string.IsNullOrEmpty(backendurlconfigFile.Value())) { CreatorApiBackendUrlUpdater creatorApiBackendUrlUpdater = new CreatorApiBackendUrlUpdater(); creatorConfig = creatorApiBackendUrlUpdater.UpdateBackendServiceUrl(backendurlconfigFile.Value(), creatorConfig); } bool isValidCreatorConfig = creatorConfigurationValidator.ValidateCreatorConfig(creatorConfig); if (isValidCreatorConfig == true) { // required parameters have been supplied // initialize file helper classes FileWriter fileWriter = new FileWriter(); FileNameGenerator fileNameGenerator = new FileNameGenerator(); FileNames fileNames = creatorConfig.baseFileName == null ? fileNameGenerator.GenerateFileNames(creatorConfig.apimServiceName) : fileNameGenerator.GenerateFileNames(creatorConfig.baseFileName); // initialize template creator classes APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator(); LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator(); BackendTemplateCreator backendTemplateCreator = new BackendTemplateCreator(); AuthorizationServerTemplateCreator authorizationServerTemplateCreator = new AuthorizationServerTemplateCreator(); ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator(); TagAPITemplateCreator tagAPITemplateCreator = new TagAPITemplateCreator(); PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader); ProductGroupTemplateCreator productGroupTemplateCreator = new ProductGroupTemplateCreator(); DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator(); ReleaseTemplateCreator releaseTemplateCreator = new ReleaseTemplateCreator(); ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator(policyTemplateCreator, productGroupTemplateCreator); PropertyTemplateCreator propertyTemplateCreator = new PropertyTemplateCreator(); TagTemplateCreator tagTemplateCreator = new TagTemplateCreator(); APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, policyTemplateCreator, productAPITemplateCreator, tagAPITemplateCreator, diagnosticTemplateCreator, releaseTemplateCreator); MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator(); // create templates from provided configuration Console.WriteLine("Creating global service policy template"); Console.WriteLine("------------------------------------------"); Template globalServicePolicyTemplate = creatorConfig.policy != null ? policyTemplateCreator.CreateGlobalServicePolicyTemplate(creatorConfig) : null; Console.WriteLine("Creating API version set template"); Console.WriteLine("------------------------------------------"); Template apiVersionSetsTemplate = creatorConfig.apiVersionSets != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null; Console.WriteLine("Creating product template"); Console.WriteLine("------------------------------------------"); Template productsTemplate = creatorConfig.products != null ? productTemplateCreator.CreateProductTemplate(creatorConfig) : null; Console.WriteLine("Creating named values template"); Console.WriteLine("------------------------------------------"); Template propertyTemplate = creatorConfig.namedValues != null ? propertyTemplateCreator.CreatePropertyTemplate(creatorConfig) : null; Console.WriteLine("Creating logger template"); Console.WriteLine("------------------------------------------"); Template loggersTemplate = creatorConfig.loggers != null ? loggerTemplateCreator.CreateLoggerTemplate(creatorConfig) : null; Console.WriteLine("Creating backend template"); Console.WriteLine("------------------------------------------"); Template backendsTemplate = creatorConfig.backends != null ? backendTemplateCreator.CreateBackendTemplate(creatorConfig) : null; Console.WriteLine("Creating authorization server template"); Console.WriteLine("------------------------------------------"); Template authorizationServersTemplate = creatorConfig.authorizationServers != null ? authorizationServerTemplateCreator.CreateAuthorizationServerTemplate(creatorConfig) : null; // store name and whether the api will depend on the version set template each api necessary to build linked templates List <LinkedMasterTemplateAPIInformation> apiInformation = new List <LinkedMasterTemplateAPIInformation>(); List <Template> apiTemplates = new List <Template>(); Console.WriteLine("Creating API templates"); Console.WriteLine("------------------------------------------"); foreach (APIConfig api in creatorConfig.apis) { // create api templates from provided api config - if the api config contains a supplied apiVersion, split the templates into 2 for metadata and swagger content, otherwise create a unified template List <Template> apiTemplateSet = await apiTemplateCreator.CreateAPITemplatesAsync(api); apiTemplates.AddRange(apiTemplateSet); // create the relevant info that will be needed to properly link to the api template(s) from the master template apiInformation.Add(new LinkedMasterTemplateAPIInformation() { name = api.name, isSplit = apiTemplateCreator.isSplitAPI(api), dependsOnGlobalServicePolicies = creatorConfig.policy != null, dependsOnVersionSets = api.apiVersionSetId != null, dependsOnProducts = api.products != null, dependsOnTags = api.tags != null, dependsOnLoggers = await masterTemplateCreator.DetermineIfAPIDependsOnLoggerAsync(api, fileReader), dependsOnAuthorizationServers = api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null, dependsOnBackends = await masterTemplateCreator.DetermineIfAPIDependsOnBackendAsync(api, fileReader) }); } Console.WriteLine("Creating tag template"); Console.WriteLine("------------------------------------------"); Template tagTemplate = creatorConfig.tags != null ? tagTemplateCreator.CreateTagTemplate(creatorConfig) : null; // create parameters file Template templateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig); // write templates to outputLocation if (creatorConfig.linked == true) { // create linked master template Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(creatorConfig, globalServicePolicyTemplate, apiVersionSetsTemplate, productsTemplate, propertyTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, tagTemplate, apiInformation, fileNames, creatorConfig.apimServiceName, fileNameGenerator); fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, fileNames.linkedMaster)); } foreach (Template apiTemplate in apiTemplates) { APITemplateResource apiResource = apiTemplate.resources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as APITemplateResource; APIConfig providedAPIConfiguration = creatorConfig.apis.FirstOrDefault(api => string.Compare(apiResource.name, APITemplateCreator.MakeResourceName(api), true) == 0); // if the api version is not null the api is split into multiple templates. If the template is split and the content value has been set, then the template is for a subsequent api string apiFileName = fileNameGenerator.GenerateCreatorAPIFileName(providedAPIConfiguration.name, apiTemplateCreator.isSplitAPI(providedAPIConfiguration), apiResource.properties.value != null); fileWriter.WriteJSONToFile(apiTemplate, String.Concat(creatorConfig.outputLocation, apiFileName)); } if (globalServicePolicyTemplate != null) { fileWriter.WriteJSONToFile(globalServicePolicyTemplate, String.Concat(creatorConfig.outputLocation, fileNames.globalServicePolicy)); } if (apiVersionSetsTemplate != null) { fileWriter.WriteJSONToFile(apiVersionSetsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.apiVersionSets)); } if (productsTemplate != null) { fileWriter.WriteJSONToFile(productsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.products)); } if (propertyTemplate != null) { fileWriter.WriteJSONToFile(propertyTemplate, String.Concat(creatorConfig.outputLocation, fileNames.namedValues)); } if (loggersTemplate != null) { fileWriter.WriteJSONToFile(loggersTemplate, String.Concat(creatorConfig.outputLocation, fileNames.loggers)); } if (backendsTemplate != null) { fileWriter.WriteJSONToFile(backendsTemplate, String.Concat(creatorConfig.outputLocation, fileNames.backends)); } if (authorizationServersTemplate != null) { fileWriter.WriteJSONToFile(authorizationServersTemplate, String.Concat(creatorConfig.outputLocation, fileNames.authorizationServers)); } if (tagTemplate != null) { fileWriter.WriteJSONToFile(tagTemplate, String.Concat(creatorConfig.outputLocation, fileNames.tags)); } // write parameters to outputLocation fileWriter.WriteJSONToFile(templateParameters, String.Concat(creatorConfig.outputLocation, fileNames.parameters)); Console.WriteLine("Templates written to output location"); } return(0); }); }
public string GenerateLinkedTemplateUri(CreatorConfig creatorConfig, string fileName) { return(creatorConfig.linkedTemplatesUrlQueryString != null ? $"[concat(parameters('LinkedTemplatesBaseUrl'), '{fileName}', parameters('LinkedTemplatesUrlQueryString'))]" : $"[concat(parameters('LinkedTemplatesBaseUrl'), '{fileName}')]"); }
public Template CreateLinkedMasterTemplate(CreatorConfig creatorConfig, Template globalServicePolicyTemplate, Template apiVersionSetTemplate, Template productsTemplate, Template loggersTemplate, Template backendsTemplate, Template authorizationServersTemplate, Template tagTemplate, List <LinkedMasterTemplateAPIInformation> apiInformation, FileNames fileNames, string apimServiceName, FileNameGenerator fileNameGenerator) { // create empty template Template masterTemplate = CreateEmptyTemplate(); // add parameters masterTemplate.parameters = this.CreateMasterTemplateParameters(creatorConfig); // add deployment resources that links to all resource files List <TemplateResource> resources = new List <TemplateResource>(); // globalServicePolicy if (globalServicePolicyTemplate != null) { string globalServicePolicyUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.globalServicePolicy); resources.Add(this.CreateLinkedMasterTemplateResource("globalServicePolicyTemplate", globalServicePolicyUri, new string[] { })); } // apiVersionSet if (apiVersionSetTemplate != null) { string apiVersionSetUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.apiVersionSets); resources.Add(this.CreateLinkedMasterTemplateResource("versionSetTemplate", apiVersionSetUri, new string[] { })); } // product if (productsTemplate != null) { string productsUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.products); resources.Add(this.CreateLinkedMasterTemplateResource("productsTemplate", productsUri, new string[] { })); } // logger if (loggersTemplate != null) { string loggersUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.loggers); resources.Add(this.CreateLinkedMasterTemplateResource("loggersTemplate", loggersUri, new string[] { })); } // backend if (backendsTemplate != null) { string backendsUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.backends); resources.Add(this.CreateLinkedMasterTemplateResource("backendsTemplate", backendsUri, new string[] { })); } // authorizationServer if (authorizationServersTemplate != null) { string authorizationServersUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.authorizationServers); resources.Add(this.CreateLinkedMasterTemplateResource("authorizationServersTemplate", authorizationServersUri, new string[] { })); } // tag if (tagTemplate != null) { string tagUri = GenerateLinkedTemplateUri(creatorConfig, fileNames.tags); resources.Add(this.CreateLinkedMasterTemplateResource("tagTemplate", tagUri, new string[] { })); } // each api has an associated api info class that determines whether the api is split and its dependencies on other resources foreach (LinkedMasterTemplateAPIInformation apiInfo in apiInformation) { if (apiInfo.isSplit == true) { // add a deployment resource for both api template files string originalAPIName = fileNameGenerator.GenerateOriginalAPIName(apiInfo.name); string initialAPIDeploymentResourceName = $"{originalAPIName}-InitialAPITemplate"; string subsequentAPIDeploymentResourceName = $"{originalAPIName}-SubsequentAPITemplate"; string initialAPIFileName = fileNameGenerator.GenerateCreatorAPIFileName(apiInfo.name, apiInfo.isSplit, true, apimServiceName); string initialAPIUri = GenerateLinkedTemplateUri(creatorConfig, initialAPIFileName); string[] initialAPIDependsOn = CreateAPIResourceDependencies(globalServicePolicyTemplate, apiVersionSetTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, tagTemplate, apiInfo); resources.Add(this.CreateLinkedMasterTemplateResource(initialAPIDeploymentResourceName, initialAPIUri, initialAPIDependsOn)); string subsequentAPIFileName = fileNameGenerator.GenerateCreatorAPIFileName(apiInfo.name, apiInfo.isSplit, false, apimServiceName); string subsequentAPIUri = GenerateLinkedTemplateUri(creatorConfig, subsequentAPIFileName); string[] subsequentAPIDependsOn = new string[] { $"[resourceId('Microsoft.Resources/deployments', '{initialAPIDeploymentResourceName}')]" }; resources.Add(this.CreateLinkedMasterTemplateResource(subsequentAPIDeploymentResourceName, subsequentAPIUri, subsequentAPIDependsOn)); } else { // add a deployment resource for the unified api template file string originalAPIName = fileNameGenerator.GenerateOriginalAPIName(apiInfo.name); string unifiedAPIDeploymentResourceName = $"{originalAPIName}-APITemplate"; string unifiedAPIFileName = fileNameGenerator.GenerateCreatorAPIFileName(apiInfo.name, apiInfo.isSplit, true, apimServiceName); string unifiedAPIUri = GenerateLinkedTemplateUri(creatorConfig, unifiedAPIFileName); string[] unifiedAPIDependsOn = CreateAPIResourceDependencies(globalServicePolicyTemplate, apiVersionSetTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, tagTemplate, apiInfo); resources.Add(this.CreateLinkedMasterTemplateResource(unifiedAPIDeploymentResourceName, unifiedAPIUri, unifiedAPIDependsOn)); } } masterTemplate.resources = resources.ToArray(); return(masterTemplate); }
public Template CreateProductTemplate(CreatorConfig creatorConfig) { // create empty template Template productTemplate = CreateEmptyTemplate(); // add parameters productTemplate.parameters = new Dictionary <string, TemplateParameterProperties> { { ParameterNames.ApimServiceName, new TemplateParameterProperties() { type = "string" } } }; List <TemplateResource> resources = new List <TemplateResource>(); foreach (ProductConfig product in creatorConfig.products) { if (string.IsNullOrEmpty(product.name)) { product.name = product.displayName; } // create product resource with properties ProductsTemplateResource productsTemplateResource = new ProductsTemplateResource() { name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.name}')]", type = ResourceTypeConstants.Product, apiVersion = GlobalConstants.APIVersion, properties = new ProductsTemplateProperties() { description = product.description, terms = product.terms, subscriptionRequired = product.subscriptionRequired, approvalRequired = product.subscriptionRequired ? product.approvalRequired : null, subscriptionsLimit = product.subscriptionRequired ? product.subscriptionsLimit : null, state = product.state, displayName = product.displayName }, dependsOn = new string[] { } }; resources.Add(productsTemplateResource); // create product policy resource that depends on the product, if provided if (product.policy != null) { string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.name}')]" }; PolicyTemplateResource productPolicy = this.policyTemplateCreator.CreateProductPolicyTemplateResource(product, dependsOn); resources.Add(productPolicy); } // create product group resources if provided if (product.groups != null) { string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.name}')]" }; List <ProductGroupsValue> productGroups = this.productGroupTemplateCreator.CreateProductGroupTemplateResources(product, dependsOn); resources.AddRange(productGroups); } } productTemplate.resources = resources.ToArray(); return(productTemplate); }
public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(CreatorConfig creatorConfig) { // used to create the parameter metatadata, etc (not value) for use in file with resources // add parameters with metatdata properties Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>(); TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Name of the API Management" }, type = "string" }; parameters.Add("ApimServiceName", apimServiceNameProperties); // add remote location of template files for linked option if (creatorConfig.linked == true) { TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Base URL of the repository" }, type = "string" }; parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties); if (creatorConfig.linkedTemplatesUrlQueryString != null) { TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Query string for the URL of the repository" }, type = "string" }; parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties); } } return(parameters); }
public CreateCommand() { this.Name = GlobalConstants.CreateName; this.Description = GlobalConstants.CreateDescription; // list command options CommandOption configFile = this.Option("--configFile <configFile>", "Config YAML file location", CommandOptionType.SingleValue).IsRequired(); this.HelpOption(); this.OnExecute(async() => { // convert config file to CreatorConfig class FileReader fileReader = new FileReader(); CreatorConfig creatorConfig = await fileReader.ConvertConfigYAMLToCreatorConfigAsync(configFile.Value()); // validate creator config CreatorConfigurationValidator creatorConfigurationValidator = new CreatorConfigurationValidator(this); bool isValidCreatorConfig = creatorConfigurationValidator.ValidateCreatorConfig(creatorConfig); if (isValidCreatorConfig == true) { // required parameters have been supplied // initialize file helper classes FileWriter fileWriter = new FileWriter(); FileNameGenerator fileNameGenerator = new FileNameGenerator(); CreatorFileNames creatorFileNames = fileNameGenerator.GenerateCreatorLinkedFileNames(); // initialize template creator classes APIVersionSetTemplateCreator apiVersionSetTemplateCreator = new APIVersionSetTemplateCreator(); LoggerTemplateCreator loggerTemplateCreator = new LoggerTemplateCreator(); ProductTemplateCreator productTemplateCreator = new ProductTemplateCreator(); BackendTemplateCreator backendTemplateCreator = new BackendTemplateCreator(); AuthorizationServerTemplateCreator authorizationServerTemplateCreator = new AuthorizationServerTemplateCreator(); ProductAPITemplateCreator productAPITemplateCreator = new ProductAPITemplateCreator(); PolicyTemplateCreator policyTemplateCreator = new PolicyTemplateCreator(fileReader); DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator(); APITemplateCreator apiTemplateCreator = new APITemplateCreator(fileReader, policyTemplateCreator, productAPITemplateCreator, diagnosticTemplateCreator); MasterTemplateCreator masterTemplateCreator = new MasterTemplateCreator(); // create templates from provided configuration Console.WriteLine("Creating API version set template"); Console.WriteLine("------------------------------------------"); Template apiVersionSetsTemplate = creatorConfig.apiVersionSets != null ? apiVersionSetTemplateCreator.CreateAPIVersionSetTemplate(creatorConfig) : null; Console.WriteLine("Creating product template"); Console.WriteLine("------------------------------------------"); Template productsTemplate = creatorConfig.products != null ? productTemplateCreator.CreateProductTemplate(creatorConfig) : null; Console.WriteLine("Creating logger template"); Console.WriteLine("------------------------------------------"); Template loggersTemplate = creatorConfig.loggers != null ? loggerTemplateCreator.CreateLoggerTemplate(creatorConfig) : null; Console.WriteLine("Creating backend template"); Console.WriteLine("------------------------------------------"); Template backendsTemplate = creatorConfig.backends != null ? backendTemplateCreator.CreateBackendTemplate(creatorConfig) : null; Console.WriteLine("Creating authorization server template"); Console.WriteLine("------------------------------------------"); Template authorizationServersTemplate = creatorConfig.authorizationServers != null ? authorizationServerTemplateCreator.CreateAuthorizationServerTemplate(creatorConfig) : null; // store name and whether the api will depend on the version set template each api necessary to build linked templates List <LinkedMasterTemplateAPIInformation> apiInformation = new List <LinkedMasterTemplateAPIInformation>(); List <Template> apiTemplates = new List <Template>(); Console.WriteLine("Creating API templates"); Console.WriteLine("------------------------------------------"); foreach (APIConfig api in creatorConfig.apis) { // create api templates from provided api config - if the api config contains a supplied apiVersion, split the templates into 2 for metadata and swagger content, otherwise create a unified template List <Template> apiTemplateSet = await apiTemplateCreator.CreateAPITemplatesAsync(creatorConfig, api); apiTemplates.AddRange(apiTemplateSet); // create the relevant info that will be needed to properly link to the api template(s) from the master template apiInformation.Add(new LinkedMasterTemplateAPIInformation() { name = api.name, isSplit = apiTemplateCreator.isSplitAPI(api), dependsOnVersionSets = api.apiVersionSetId != null, dependsOnProducts = api.products != null, dependsOnLoggers = await masterTemplateCreator.DetermineIfAPIDependsOnLogger(api, fileReader), dependsOnAuthorizationServers = api.authenticationSettings != null && api.authenticationSettings.oAuth2 != null && api.authenticationSettings.oAuth2.authorizationServerId != null, dependsOnBackends = await masterTemplateCreator.DetermineIfAPIDependsOnBackend(api, fileReader) }); } // create parameters file Template masterTemplateParameters = masterTemplateCreator.CreateMasterTemplateParameterValues(creatorConfig); // write templates to outputLocation if (creatorConfig.linked == true) { // create linked master template Template masterTemplate = masterTemplateCreator.CreateLinkedMasterTemplate(apiVersionSetsTemplate, productsTemplate, loggersTemplate, backendsTemplate, authorizationServersTemplate, apiInformation, creatorFileNames, fileNameGenerator); fileWriter.WriteJSONToFile(masterTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.linkedMaster)); } foreach (Template apiTemplate in apiTemplates) { APITemplateResource apiResource = apiTemplate.resources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as APITemplateResource; APIConfig providedAPIConfiguration = creatorConfig.apis.FirstOrDefault(api => apiResource.name.Contains(api.name)); // if the api version is not null the api is split into multiple templates. If the template is split and the content value has been set, then the template is for a subsequent api string apiFileName = fileNameGenerator.GenerateAPIFileName(providedAPIConfiguration.name, apiTemplateCreator.isSplitAPI(providedAPIConfiguration), apiResource.properties.value == null); fileWriter.WriteJSONToFile(apiTemplate, String.Concat(creatorConfig.outputLocation, apiFileName)); } if (apiVersionSetsTemplate != null) { fileWriter.WriteJSONToFile(apiVersionSetsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.apiVersionSets)); } if (productsTemplate != null) { fileWriter.WriteJSONToFile(productsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.products)); } if (loggersTemplate != null) { fileWriter.WriteJSONToFile(loggersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.loggers)); } if (backendsTemplate != null) { fileWriter.WriteJSONToFile(backendsTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.backends)); } if (authorizationServersTemplate != null) { fileWriter.WriteJSONToFile(authorizationServersTemplate, String.Concat(creatorConfig.outputLocation, creatorFileNames.authorizationServers)); } // write parameters to outputLocation fileWriter.WriteJSONToFile(masterTemplateParameters, String.Concat(creatorConfig.outputLocation, creatorConfig.linked == true ? creatorFileNames.linkedParameters : creatorFileNames.unlinkedParameters)); Console.WriteLine("Templates written to output location"); Console.WriteLine("Press any key to exit process:"); #if DEBUG Console.ReadKey(); #endif } return(0); }); }
public void ShouldCreateDiagnosticTemplateResourceFromCreatorConfig() { // arrange DiagnosticTemplateCreator diagnosticTemplateCreator = new DiagnosticTemplateCreator(); CreatorConfig creatorConfig = new CreatorConfig() { api = new APIConfig() { name = "name" }, diagnostic = new DiagnosticTemplateProperties() { alwaysLog = "alwaysLog", loggerId = "loggerId", sampling = new DiagnosticTemplateSampling() { samplingType = "samplingType", percentage = 100 }, frontend = new DiagnosticTemplateFrontendBackend() { request = new DiagnosticTemplateRequestResponse() { headers = new string[] { "frontendrequestheader" }, body = new DiagnosticTemplateRequestResponseBody() { bytes = 512 } }, response = new DiagnosticTemplateRequestResponse() { headers = new string[] { "frontendresponseheader" }, body = new DiagnosticTemplateRequestResponseBody() { bytes = 512 } } }, backend = new DiagnosticTemplateFrontendBackend() { request = new DiagnosticTemplateRequestResponse() { headers = new string[] { "backendrequestheader" }, body = new DiagnosticTemplateRequestResponseBody() { bytes = 512 } }, response = new DiagnosticTemplateRequestResponse() { headers = new string[] { "backendresponseheader" }, body = new DiagnosticTemplateRequestResponseBody() { bytes = 512 } } }, enableHttpCorrelationHeaders = true } }; // act string[] dependsOn = new string[] { "dependsOn" }; DiagnosticTemplateResource diagnosticTemplateResource = diagnosticTemplateCreator.CreateAPIDiagnosticTemplateResource(creatorConfig, dependsOn); // assert Assert.Equal($"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}/diagnostic')]", diagnosticTemplateResource.name); Assert.Equal(dependsOn, diagnosticTemplateResource.dependsOn); Assert.Equal(creatorConfig.diagnostic.alwaysLog, diagnosticTemplateResource.properties.alwaysLog); Assert.Equal(creatorConfig.diagnostic.loggerId, diagnosticTemplateResource.properties.loggerId); Assert.Equal(creatorConfig.diagnostic.enableHttpCorrelationHeaders, diagnosticTemplateResource.properties.enableHttpCorrelationHeaders); Assert.Equal(creatorConfig.diagnostic.sampling.samplingType, diagnosticTemplateResource.properties.sampling.samplingType); Assert.Equal(creatorConfig.diagnostic.sampling.percentage, diagnosticTemplateResource.properties.sampling.percentage); Assert.Equal(creatorConfig.diagnostic.frontend.request.headers, diagnosticTemplateResource.properties.frontend.request.headers); Assert.Equal(creatorConfig.diagnostic.frontend.request.body.bytes, diagnosticTemplateResource.properties.frontend.request.body.bytes); Assert.Equal(creatorConfig.diagnostic.frontend.response.headers, diagnosticTemplateResource.properties.frontend.response.headers); Assert.Equal(creatorConfig.diagnostic.frontend.response.body.bytes, diagnosticTemplateResource.properties.frontend.response.body.bytes); Assert.Equal(creatorConfig.diagnostic.backend.request.headers, diagnosticTemplateResource.properties.backend.request.headers); Assert.Equal(creatorConfig.diagnostic.backend.request.body.bytes, diagnosticTemplateResource.properties.backend.request.body.bytes); Assert.Equal(creatorConfig.diagnostic.backend.response.headers, diagnosticTemplateResource.properties.backend.response.headers); Assert.Equal(creatorConfig.diagnostic.backend.response.body.bytes, diagnosticTemplateResource.properties.backend.response.body.bytes); }
public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(CreatorConfig creatorConfig) { // used to create the parameter metatadata, etc (not value) for use in file with resources // add parameters with metadata properties Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>(); TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Name of the API Management" }, type = "string" }; parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties); // add remote location of template files for linked option if (creatorConfig.linked == true) { TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Base URL of the repository" }, type = "string" }; parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties); if (creatorConfig.linkedTemplatesUrlQueryString != null) { TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Query string for the URL of the repository" }, type = "string" }; parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties); } } // add serviceUrl parameter for linked option if (creatorConfig.serviceUrlParameters != null && creatorConfig.serviceUrlParameters.Count > 0) { foreach (ServiceUrlProperty serviceUrlProperty in creatorConfig.serviceUrlParameters) { TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "ServiceUrl parameter for API: " + serviceUrlProperty.apiName }, type = "string" }; parameters.Add(serviceUrlProperty.apiName + "-ServiceUrl", serviceUrlParamProperty); } } return(parameters); }
public async Task <APITemplateResource> CreateInitialAPITemplateResourceAsync(CreatorConfig creatorConfig) { // protocols can be pulled by converting the OpenApiSpec into the OpenApiDocument class OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader(); OpenApiDocument doc = await openAPISpecReader.ConvertOpenAPISpecToDoc(creatorConfig.api.openApiSpec); // create api resource with properties APITemplateResource apiTemplateResource = new APITemplateResource() { name = $"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}')]", type = "Microsoft.ApiManagement/service/apis", apiVersion = "2018-01-01", properties = new APITemplateProperties() { // supplied via optional arguments apiVersion = creatorConfig.api.apiVersion, apiRevision = creatorConfig.api.revision, apiRevisionDescription = creatorConfig.api.revisionDescription, apiVersionDescription = creatorConfig.api.apiVersionDescription, authenticationSettings = creatorConfig.api.authenticationSettings, path = creatorConfig.api.suffix, displayName = creatorConfig.api.name, protocols = this.CreateProtocols(doc) }, // if the template is not linked the depends on for the apiVersionSet needs to be inlined here dependsOn = new string[] { } }; string versionSetId = (creatorConfig.apiVersionSet != null && creatorConfig.apiVersionSet.id != null) ? creatorConfig.apiVersionSet.id : "versionset"; // if the template is linked and a version set was created, the initial api depends on it if (creatorConfig.linked == false && creatorConfig.apiVersionSet != null) { apiTemplateResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{versionSetId}')]" }; } // set the version set id if (creatorConfig.apiVersionSet != null) { apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{versionSetId}')]"; } else if (creatorConfig.api.apiVersionSetId != null) { apiTemplateResource.properties.apiVersionSetId = $"{creatorConfig.api.apiVersionSetId}"; } return(apiTemplateResource); }
public async Task <APITemplateResource> CreateInitialAPITemplateResourceAsync(CreatorConfig creatorConfig, APIConfig api) { // protocols can be pulled by converting the OpenApiSpec into the OpenApiDocument class OpenAPISpecReader openAPISpecReader = new OpenAPISpecReader(); OpenApiDocument doc = await openAPISpecReader.ConvertOpenAPISpecToDoc(api.openApiSpec); // create api resource with properties APITemplateResource apiTemplateResource = new APITemplateResource() { name = $"[concat(parameters('ApimServiceName'), '/{api.name}')]", type = ResourceTypeConstants.API, apiVersion = "2018-06-01-preview", properties = new APITemplateProperties() { // supplied via optional arguments apiVersion = api.apiVersion, subscriptionRequired = api.subscriptionRequired, apiRevision = api.revision, apiRevisionDescription = api.revisionDescription, apiVersionDescription = api.apiVersionDescription, authenticationSettings = api.authenticationSettings, path = api.suffix, displayName = api.name, protocols = this.CreateProtocols(doc) }, // if the template is not linked the depends on for the apiVersionSet needs to be inlined here dependsOn = new string[] { } }; // set the version set id if (api.apiVersionSetId != null) { apiTemplateResource.properties.apiVersionSetId = $"[resourceId('Microsoft.ApiManagement/service/api-version-sets', parameters('ApimServiceName'), '{api.apiVersionSetId}')]"; } return(apiTemplateResource); }