public Template GenerateEmptyPropertyTemplateWithParameters(Extractor exc) { Template armTemplate = GenerateEmptyTemplate(); armTemplate.parameters = new Dictionary <string, TemplateParameterProperties> { { ParameterNames.ApimServiceName, new TemplateParameterProperties() { type = "string" } } }; if (exc.policyXMLBaseUrl != null && exc.policyXMLSasToken != null) { TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties() { type = "string" }; armTemplate.parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties); } if (exc.policyXMLBaseUrl != null) { TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties() { type = "string" }; armTemplate.parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties); } if (exc.paramNamedValue) { TemplateParameterProperties namedValueParameterProperties = new TemplateParameterProperties() { type = "object" }; armTemplate.parameters.Add(ParameterNames.NamedValues, namedValueParameterProperties); } return(armTemplate); }
public Template GenerateEmptyApiTemplateWithParameters(Extractor exc) { Template armTemplate = GenerateEmptyTemplate(); armTemplate.parameters = new Dictionary <string, TemplateParameterProperties> { { "ApimServiceName", new TemplateParameterProperties() { type = "string" } } }; if (exc.policyXMLBaseUrl != null && exc.policyXMLSasToken != null) { TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties() { type = "string" }; armTemplate.parameters.Add("PolicyXMLSasToken", policyTemplateSasTokenParameterProperties); } if (exc.policyXMLBaseUrl != null) { TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties() { type = "string" }; armTemplate.parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlParameterProperties); } if (exc.paramServiceUrl || (exc.serviceUrlParameters != null && exc.serviceUrlParameters.Length > 0)) { TemplateParameterProperties serviceUrlParamProperty = new TemplateParameterProperties() { type = "object" }; armTemplate.parameters.Add("serviceUrl", serviceUrlParamProperty); } return(armTemplate); }
public MasterTemplateResource CreateLinkedMasterTemplateResourceForPropertyTemplate(string name, string uriLink, string[] dependsOn, Extractor exc) { MasterTemplateResource masterResourceTemplate = this.CreateLinkedMasterTemplateResource(name, uriLink, dependsOn); if (exc.paramNamedValue) { masterResourceTemplate.properties.parameters.Add(ParameterNames.NamedValues, new TemplateParameterProperties() { value = $"[parameters('{ParameterNames.NamedValues}')]" }); } if (exc.paramNamedValuesKeyVaultSecrets) { masterResourceTemplate.properties.parameters.Add(ParameterNames.NamedValueKeyVaultSecrets, new TemplateParameterProperties() { value = $"[parameters('{ParameterNames.NamedValueKeyVaultSecrets}')]" }); } return(masterResourceTemplate); }
public async Task <Template> GenerateNamedValuesTemplateAsync(string singleApiName, List <TemplateResource> apiTemplateResources, Extractor exc) { Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting named values from service"); Template armTemplate = GenerateEmptyPropertyTemplateWithParameters(exc); List <TemplateResource> templateResources = new List <TemplateResource>(); // pull all named values (properties) for service string properties = await GetPropertiesAsync(exc.sourceApimName, exc.resourceGroup); JObject oProperties = JObject.Parse(properties); foreach (var extractedProperty in oProperties["value"]) { string propertyName = ((JValue)extractedProperty["name"]).Value.ToString(); string fullPropertyResource = await GetPropertyDetailsAsync(exc.sourceApimName, exc.resourceGroup, propertyName); // convert returned named value to template resource class PropertyTemplateResource propertyTemplateResource = JsonConvert.DeserializeObject <PropertyTemplateResource>(fullPropertyResource); propertyTemplateResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{propertyName}')]"; propertyTemplateResource.type = ResourceTypeConstants.Property; propertyTemplateResource.apiVersion = GlobalConstants.ServicePropertyAPIVersion; propertyTemplateResource.scale = null; if (exc.paramNamedValue) { propertyTemplateResource.properties.value = $"[parameters('{ParameterNames.NamedValues}').{ExtractorUtils.GenValidParamName(propertyName, ParameterPrefix.Property)}]"; } if (singleApiName == null) { // if the user is executing a full extraction, extract all the loggers Console.WriteLine("'{0}' Named value found", propertyName); templateResources.Add(propertyTemplateResource); } else { // TODO - if the user is executing a single api, extract all the named values used in the template resources Console.WriteLine("'{0}' Named value found", propertyName); templateResources.Add(propertyTemplateResource); } } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }
public async Task <Template> GenerateAPITagsARMTemplateAsync(string singleApiName, List <string> multipleApiNames, Extractor exc) { // initialize arm template Template armTemplate = GenerateEmptyApiTemplateWithParameters(exc); List <TemplateResource> templateResources = new List <TemplateResource>(); // when extract single API if (singleApiName != null) { // check if this api exist try { string apiDetails = await GetAPIDetailsAsync(exc.sourceApimName, exc.resourceGroup, singleApiName); Console.WriteLine("{0} API found ...", singleApiName); templateResources.AddRange(await GenerateSingleAPITagResourceAsync(singleApiName, exc, new string[] {})); } catch (Exception) { throw new Exception($"{singleApiName} API not found!"); } } // when extract multiple APIs and generate one master template else if (multipleApiNames != null) { Console.WriteLine("{0} APIs found ...", multipleApiNames.Count().ToString()); string[] dependsOn = new string[] {}; foreach (string apiName in multipleApiNames) { templateResources.AddRange(await GenerateSingleAPITagResourceAsync(apiName, exc, dependsOn)); // Extract the tag name from the last resource string[] lastTagName = templateResources.Last().name.Replace("')]", "").Split('/'); if (lastTagName.Length > 3) { // Operations tag dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations/tags', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{lastTagName[2]}', '{lastTagName[3]}')]" }; } else { // API tag dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/tags', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{lastTagName[2]}')]" }; } } } // when extract all APIs and generate one master template else { JToken[] oApis = await GetAllAPIObjsAsync(exc.sourceApimName, exc.resourceGroup); Console.WriteLine("{0} APIs found ...", (oApis.Count().ToString())); string[] dependsOn = new string[] {}; foreach (JToken oApi in oApis) { string apiName = ((JValue)oApi["name"]).Value.ToString(); templateResources.AddRange(await GenerateSingleAPITagResourceAsync(apiName, exc, dependsOn)); if (templateResources.Count > 0) { // Extract the tag name from the last resource string[] lastTagName = templateResources.Last().name.Replace("')]", "").Split('/'); if (lastTagName.Length > 3) { // Operations tag dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations/tags', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{lastTagName[2]}', '{lastTagName[3]}')]" }; } else { // API tag dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/tags', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{lastTagName[2]}')]" }; } } } } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }
// this function will get the current revision of this api and will remove "isCurrent" paramter public async Task <List <TemplateResource> > GenerateCurrentRevisionAPIResourceAsync(string apiName, Extractor exc) { List <TemplateResource> templateResources = new List <TemplateResource>(); string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup, fileFolder = exc.fileFolder, policyXMLBaseUrl = exc.policyXMLBaseUrl, policyXMLSasToken = exc.policyXMLSasToken; string apiDetails = await GetAPIDetailsAsync(apimname, resourceGroup, apiName); Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting resources from {0} API:", apiName); // convert returned api to template resource class JObject oApiDetails = JObject.Parse(apiDetails); APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails); apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString(); apiResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}')]"; apiResource.apiVersion = GlobalConstants.APIVersion; apiResource.scale = null; apiResource.properties.isCurrent = null; if (exc.paramServiceUrl) { apiResource.properties.serviceUrl = $"[parameters('{ParameterNames.ServiceUrl}').{ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api)}]"; } if (apiResource.properties.apiVersionSetId != null) { apiResource.dependsOn = new string[] { }; string versionSetName = apiResource.properties.apiVersionSetId; int versionSetPosition = versionSetName.IndexOf("apiVersionSets/"); versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition)); apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('{ParameterNames.ApimServiceName}')), '/{versionSetName}')]"; } else { apiResource.dependsOn = new string[] { }; } templateResources.Add(apiResource); #region Schemas // add schema resources to api template List <TemplateResource> schemaResources = await GenerateSchemasARMTemplate(apimname, apiName, resourceGroup, fileFolder); templateResources.AddRange(schemaResources); #endregion #region Operations // pull api operations for service string[] operationNames = await GetAllOperationNames(apimname, resourceGroup, apiName); foreach (string operationName in operationNames) { string operationDetails = await GetAPIOperationDetailsAsync(apimname, resourceGroup, apiName, operationName); Console.WriteLine("'{0}' Operation found", operationName); // convert returned operation to template resource class OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails); string operationResourceName = operationResource.name; operationResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}')]"; operationResource.apiVersion = GlobalConstants.APIVersion; operationResource.scale = null; // add operation dependencies and fix sample value if necessary List <string> operationDependsOn = new List <string>() { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationResource.properties.request.representations) { AddSchemaDependencyToOperationIfNecessary(apiName, operationDependsOn, operationTemplateRepresentation); ArmEscapeSampleValueIfNecessary(operationTemplateRepresentation); } foreach (OperationsTemplateResponse operationTemplateResponse in operationResource.properties.responses) { foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationTemplateResponse.representations) { AddSchemaDependencyToOperationIfNecessary(apiName, operationDependsOn, operationTemplateRepresentation); ArmEscapeSampleValueIfNecessary(operationTemplateRepresentation); } } operationResource.dependsOn = operationDependsOn.ToArray(); templateResources.Add(operationResource); // add operation policy resource to api template try { string operationPolicy = await GetOperationPolicyAsync(apimname, resourceGroup, apiName, operationName); Console.WriteLine($" - Operation policy found for {operationName} operation"); PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy); operationPolicyResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}/policy')]"; operationPolicyResource.apiVersion = GlobalConstants.APIVersion; operationPolicyResource.scale = null; operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{operationResourceName}')]" }; // write policy xml content to file and point to it if policyXMLBaseUrl is provided if (policyXMLBaseUrl != null) { string policyXMLContent = operationPolicyResource.properties.value; string policyFolder = String.Concat(fileFolder, $@"/policies"); string operationPolicyFileName = $@"/{apiName}-{operationName}-operationPolicy.xml"; this.fileWriter.CreateFolderIfNotExists(policyFolder); this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, operationPolicyFileName)); operationPolicyResource.properties.format = "rawxml-link"; if (policyXMLSasToken != null) { operationPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{operationPolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]"; } else { operationPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{operationPolicyFileName}')]"; } } templateResources.Add(operationPolicyResource); } catch (Exception) { } // add tags associated with the operation to template try { // pull tags associated with the operation string apiOperationTags = await GetOperationTagsAsync(apimname, resourceGroup, apiName, operationName); JObject oApiOperationTags = JObject.Parse(apiOperationTags); foreach (var tag in oApiOperationTags["value"]) { string apiOperationTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine(" - '{0}' Tag association found for {1} operation", apiOperationTagName, operationResourceName); // convert operation tag association to template resource class TagTemplateResource operationTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); operationTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}/{apiOperationTagName}')]"; operationTagResource.apiVersion = GlobalConstants.APIVersion; operationTagResource.scale = null; operationTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{operationResourceName}')]" }; templateResources.Add(operationTagResource); } } catch (Exception) { } } #endregion #region API Policies // add api policy resource to api template try { string apiPolicies = await GetAPIPolicyAsync(apimname, resourceGroup, apiName); Console.WriteLine("API policy found"); PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies); apiPoliciesResource.apiVersion = GlobalConstants.APIVersion; apiPoliciesResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{apiPoliciesResource.name}')]"; apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; // write policy xml content to file and point to it if policyXMLBaseUrl is provided if (policyXMLBaseUrl != null) { string policyXMLContent = apiPoliciesResource.properties.value; string policyFolder = String.Concat(fileFolder, $@"/policies"); string apiPolicyFileName = $@"/{apiName}-apiPolicy.xml"; this.fileWriter.CreateFolderIfNotExists(policyFolder); this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, apiPolicyFileName)); apiPoliciesResource.properties.format = "rawxml-link"; if (policyXMLSasToken != null) { apiPoliciesResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{apiPolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]"; } else { apiPoliciesResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{apiPolicyFileName}')]"; } } templateResources.Add(apiPoliciesResource); } catch (Exception) { } #endregion // add tags associated with the api to template try { // pull tags associated with the api string apiTags = await GetAPITagsAsync(apimname, resourceGroup, apiName); JObject oApiTags = JObject.Parse(apiTags); foreach (var tag in oApiTags["value"]) { string apiTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine("'{0}' Tag association found", apiTagName); // convert associations between api and tags to template resource class TagTemplateResource apiTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); apiTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{apiTagName}')]"; apiTagResource.apiVersion = GlobalConstants.APIVersion; apiTagResource.scale = null; apiTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; templateResources.Add(apiTagResource); } } catch (Exception) { } // add product api associations to template #region API Products try { // pull product api associations string apiProducts = await GetAPIProductsAsync(apimname, resourceGroup, apiName); JObject oApiProducts = JObject.Parse(apiProducts); foreach (var item in oApiProducts["value"]) { string apiProductName = ((JValue)item["name"]).Value.ToString(); Console.WriteLine("'{0}' Product association found", apiProductName); // convert returned api product associations to template resource class ProductAPITemplateResource productAPIResource = JsonConvert.DeserializeObject <ProductAPITemplateResource>(item.ToString()); productAPIResource.type = ResourceTypeConstants.ProductAPI; productAPIResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiProductName}/{apiName}')]"; productAPIResource.apiVersion = GlobalConstants.APIVersion; productAPIResource.scale = null; productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; templateResources.Add(productAPIResource); } } catch (Exception) { } #endregion #region Diagnostics // add diagnostics to template // pull diagnostics for api string diagnostics = await GetAPIDiagnosticsAsync(apimname, resourceGroup, apiName); JObject oDiagnostics = JObject.Parse(diagnostics); foreach (var diagnostic in oDiagnostics["value"]) { string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString(); Console.WriteLine("'{0}' Diagnostic found", diagnosticName); // convert returned diagnostic to template resource class DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>(); diagnosticResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{diagnosticName}')]"; diagnosticResource.type = ResourceTypeConstants.APIDiagnostic; diagnosticResource.apiVersion = GlobalConstants.APIVersion; diagnosticResource.scale = null; diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; if (exc.paramApiLoggerId) { diagnosticResource.properties.loggerId = $"[parameters('{ParameterNames.ApiLoggerId}').{ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api)}.{ExtractorUtils.GenValidParamName(diagnosticName, ParameterPrefix.Diagnostic)}]"; } if (!diagnosticName.Contains("applicationinsights")) { // enableHttpCorrelationHeaders only works for application insights, causes errors otherwise diagnosticResource.properties.enableHttpCorrelationHeaders = null; } templateResources.Add(diagnosticResource); } #endregion return(templateResources); }
// this function generate all reference loggers in all extracted apis public static async Task <Dictionary <string, Dictionary <string, string> > > GetAllReferencedLoggers(List <string> apisToExtract, Extractor exc) { Dictionary <string, Dictionary <string, string> > ApiLoggerId = new Dictionary <string, Dictionary <string, string> >(); APIExtractor apiExc = new APIExtractor(new FileWriter()); foreach (string curApiName in apisToExtract) { Dictionary <string, string> loggerIds = new Dictionary <string, string>(); string diagnostics = await apiExc.GetAPIDiagnosticsAsync(exc.sourceApimName, exc.resourceGroup, curApiName); JObject oDiagnostics = JObject.Parse(diagnostics); foreach (var diagnostic in oDiagnostics["value"]) { string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString(); string loggerId = ((JValue)diagnostic["properties"]["loggerId"]).Value.ToString(); loggerIds.Add(ExtractorUtils.GenValidParamName(diagnosticName, ParameterPrefix.Diagnostic), loggerId); } if (loggerIds.Count != 0) { ApiLoggerId.Add(ExtractorUtils.GenValidParamName(curApiName, ParameterPrefix.Api), loggerIds); } } return(ApiLoggerId); }
// this function will get the current revision of this api and will remove "isCurrent" paramter public async Task <List <TemplateResource> > GenerateCurrentRevisionAPIResourceAsync(string apiName, Extractor exc) { List <TemplateResource> templateResources = new List <TemplateResource>(); string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup, fileFolder = exc.fileFolder, policyXMLBaseUrl = exc.policyXMLBaseUrl, policyXMLSasToken = exc.policyXMLSasToken; string apiDetails = await GetAPIDetailsAsync(apimname, resourceGroup, apiName); Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting resources from {0} API:", apiName); // convert returned api to template resource class JObject oApiDetails = JObject.Parse(apiDetails); APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails); apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString(); apiResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}')]"; apiResource.apiVersion = GlobalConstants.APIVersion; apiResource.scale = null; apiResource.properties.isCurrent = null; if (exc.paramServiceUrl) { apiResource.properties.serviceUrl = $"[parameters('{ParameterNames.ServiceUrl}').{ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api)}]"; } if (apiResource.properties.apiVersionSetId != null) { apiResource.dependsOn = new string[] { }; string versionSetName = apiResource.properties.apiVersionSetId; int versionSetPosition = versionSetName.IndexOf("apiVersionSets/"); versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition)); apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('{ParameterNames.ApimServiceName}')), '/{versionSetName}')]"; } else { apiResource.dependsOn = new string[] { }; } templateResources.Add(apiResource); templateResources.AddRange(await GetRelatedTemplateResourcesAsync(apiName, exc)); return(templateResources); }
public async Task <bool> IsNamedValueUsedInBackends(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, Extractor exc, string propertyName, string propertyDisplayName) { // isolate api and operation policy resources in the case of a single api extraction, as they may reference backends var policyResources = apiTemplateResources.Where(resource => (resource.type == ResourceTypeConstants.APIPolicy || resource.type == ResourceTypeConstants.APIOperationPolicy || resource.type == ResourceTypeConstants.ProductPolicy)); var emptyNamedValueResources = new List <TemplateResource>(); // pull all backends for service JObject oBackends = new JObject(); int skipNumberOfBackends = 0; do { string backends = await GetBackendsAsync(apimname, resourceGroup, skipNumberOfBackends); oBackends = JObject.Parse(backends); foreach (var item in oBackends["value"]) { var content = item.ToString(); // check if backend references the named value, credentials for example if (content.Contains(string.Concat("{{", propertyName, "}}")) || content.Contains(string.Concat("{{", propertyDisplayName, "}}"))) { //only true if this is a full extraction, or in the case of a single api, if it is referenced by one of the API policies if (singleApiName == null) { return(true); } else { // is this backend related to the single api? // is backend used in the extracted policies for this API // if backend id is referenced in policy // or a named value is referenced in policy to a backend, we have already checked the policy for named value. // check if this backend is used by any of the policies extracted string backendName = ((JValue)item["name"]).Value.ToString(); string backend = await GetBackendDetailsAsync(apimname, resourceGroup, backendName); // convert returned backend to template resource class BackendTemplateResource backendTemplateResource = JsonConvert.DeserializeObject <BackendTemplateResource>(backend); // we have already checked if the named value is used in a policy, we just need to confirm if the backend is referenced by this single api within the policy file // this is why an empty named values must be passed to this method for validation foreach (PolicyTemplateResource policyTemplateResource in policyResources) { string policyContent = ExtractorUtils.GetPolicyContent(exc, policyTemplateResource); if (DoesPolicyReferenceBackend(policyContent, emptyNamedValueResources, backendName, backendTemplateResource)) { // dont need to go through all policies and backends if the named values has already been found return(true); } } } } } skipNumberOfBackends += GlobalConstants.NumOfRecords; }while (oBackends["nextLink"] != null); return(false); }
/// <summary> /// Generate the ARM assets for the backend resources /// </summary> /// <param name="apimname"></param> /// <param name="resourceGroup"></param> /// <param name="singleApiName"></param> /// <param name="apiTemplateResources"></param> /// <param name="propertyResources"></param> /// <param name="policyXMLBaseUrl"></param> /// <param name="policyXMLSasToken"></param> /// <param name="extractBackendParameters"></param> /// <returns>a combination of a Template and the value for the BackendSettings parameter</returns> public async Task <Tuple <Template, Dictionary <string, BackendApiParameters> > > GenerateBackendsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, List <TemplateResource> propertyResources, Extractor exc) { Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting backends from service"); Template armTemplate = GenerateEmptyPropertyTemplateWithParameters(); if (exc.paramBackend) { TemplateParameterProperties extractBackendParametersProperties = new TemplateParameterProperties() { type = "object" }; armTemplate.parameters.Add(ParameterNames.BackendSettings, extractBackendParametersProperties); } List <TemplateResource> templateResources = new List <TemplateResource>(); // isolate api and operation policy resources in the case of a single api extraction, as they may reference backends var policyResources = apiTemplateResources.Where(resource => (resource.type == ResourceTypeConstants.APIPolicy || resource.type == ResourceTypeConstants.APIOperationPolicy || resource.type == ResourceTypeConstants.ProductPolicy)); var namedValueResources = propertyResources.Where(resource => (resource.type == ResourceTypeConstants.Property)); // pull all backends for service JObject oBackends = new JObject(); var oBackendParameters = new Dictionary <string, BackendApiParameters>(); int skipNumberOfBackends = 0; do { string backends = await GetBackendsAsync(apimname, resourceGroup, skipNumberOfBackends); oBackends = JObject.Parse(backends); foreach (var item in oBackends["value"]) { string backendName = ((JValue)item["name"]).Value.ToString(); string backend = await GetBackendDetailsAsync(apimname, resourceGroup, backendName); // convert returned backend to template resource class BackendTemplateResource backendTemplateResource = JsonConvert.DeserializeObject <BackendTemplateResource>(backend); backendTemplateResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{backendName}')]"; backendTemplateResource.apiVersion = GlobalConstants.APIVersion; bool includeBackend = false; ////only extract the backend if this is a full extraction, or in the case of a single api, if it is referenced by one of the policies if (singleApiName == null) { // if the user is extracting all apis, extract all the backends includeBackend = true; } else { // check extracted policies to see if the backend is referenced. foreach (PolicyTemplateResource policyTemplateResource in policyResources) { string policyContent = ExtractorUtils.GetPolicyContent(exc, policyTemplateResource); if (DoesPolicyReferenceBackend(policyContent, namedValueResources, backendName, backendTemplateResource)) { // backend was used in policy, extract it includeBackend = true; // dont need to go through all policies if the back end has already been found break; } } } if (includeBackend) { if (exc.paramBackend) { var apiToken = new BackendApiParameters(); string validApiParamName = ExtractorUtils.GenValidParamName(backendName, ParameterPrefix.Diagnostic).ToLower(); if (!string.IsNullOrEmpty(backendTemplateResource.properties.resourceId)) { apiToken.resourceId = backendTemplateResource.properties.resourceId; backendTemplateResource.properties.resourceId = $"[parameters('{ParameterNames.BackendSettings}').{validApiParamName}.resourceId]"; } if (!string.IsNullOrEmpty(backendTemplateResource.properties.url)) { apiToken.url = backendTemplateResource.properties.url; backendTemplateResource.properties.url = $"[parameters('{ParameterNames.BackendSettings}').{validApiParamName}.url]"; } if (!string.IsNullOrEmpty(backendTemplateResource.properties.protocol)) { apiToken.protocol = backendTemplateResource.properties.protocol; backendTemplateResource.properties.protocol = $"[parameters('{ParameterNames.BackendSettings}').{validApiParamName}.protocol]"; } oBackendParameters.Add(validApiParamName, apiToken); } Console.WriteLine("'{0}' Backend found", backendName); templateResources.Add(backendTemplateResource); } } skipNumberOfBackends += GlobalConstants.NumOfRecords; }while (oBackends["nextLink"] != null); armTemplate.resources = templateResources.ToArray(); return(new Tuple <Template, Dictionary <string, BackendApiParameters> >(armTemplate, oBackendParameters)); }
public async Task <Template> CreateMasterTemplateParameterValues(string singleApiName, List <string> multipleApiNames, Extractor exc) { // used to create the parameter values for use in parameters file // create empty template Template masterTemplate = GenerateEmptyTemplate(); // add parameters with value property Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>(); TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties() { value = exc.destinationApimName }; parameters.Add("ApimServiceName", apimServiceNameProperties); if (exc.linkedTemplatesBaseUrl != null) { TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties() { value = exc.linkedTemplatesBaseUrl }; parameters.Add("LinkedTemplatesBaseUrl", linkedTemplatesBaseUrlProperties); // add linkedTemplatesSasToken parameter if provided and if the user has provided a linkedTemplatesBaseUrl if (exc.linkedTemplatesSasToken != null) { TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties() { value = exc.linkedTemplatesSasToken }; parameters.Add("LinkedTemplatesSasToken", linkedTemplatesSasTokenProperties); } // add linkedTemplatesUrlQueryString parameter if provided and if the user has provided a linkedTemplatesBaseUrl if (exc.linkedTemplatesUrlQueryString != null) { TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties() { value = exc.linkedTemplatesUrlQueryString }; parameters.Add("LinkedTemplatesUrlQueryString", linkedTemplatesUrlQueryStringProperties); } } if (exc.policyXMLBaseUrl != null) { TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties() { value = exc.policyXMLBaseUrl }; parameters.Add("PolicyXMLBaseUrl", policyTemplateBaseUrlProperties); // add policyXMLSasToken parameter if provided and if the user has provided a policyXMLBaseUrl if (exc.policyXMLSasToken != null) { TemplateParameterProperties policyTemplateSasTokenProperties = new TemplateParameterProperties() { value = exc.policyXMLSasToken }; parameters.Add("PolicyXMLSasToken", policyTemplateSasTokenProperties); } } if (exc.paramServiceUrl) { Dictionary <string, string> serviceUrls = new Dictionary <string, string>(); APIExtractor apiExc = new APIExtractor(new FileWriter()); if (singleApiName != null) { string validApiName = ExtractorUtils.GenValidApiParamName(singleApiName); string serviceUrl = GetApiServiceUrlFromParameters(singleApiName, exc.serviceUrlParameters); if (serviceUrl == null) { serviceUrl = await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, singleApiName); } serviceUrls.Add(validApiName, serviceUrl); } else if (multipleApiNames != null) { foreach (string apiName in multipleApiNames) { string validApiName = ExtractorUtils.GenValidApiParamName(apiName); string serviceUrl = GetApiServiceUrlFromParameters(apiName, exc.serviceUrlParameters); if (serviceUrl == null) { serviceUrl = await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, apiName); } serviceUrls.Add(validApiName, serviceUrl); } } else { JToken[] oApis = await apiExc.GetAllAPIObjsAsync(exc.sourceApimName, exc.resourceGroup); foreach (JToken oApi in oApis) { string apiName = ((JValue)oApi["name"]).Value.ToString(); string validApiName = ExtractorUtils.GenValidApiParamName(apiName); string serviceUrl = GetApiServiceUrlFromParameters(apiName, exc.serviceUrlParameters); if (serviceUrl == null) { serviceUrl = await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, apiName); } serviceUrls.Add(validApiName, serviceUrl); } } TemplateServiceUrlProperties serviceUrlProperties = new TemplateServiceUrlProperties() { value = serviceUrls }; parameters.Add("serviceUrl", serviceUrlProperties); } masterTemplate.parameters = parameters; return(masterTemplate); }
public MasterTemplateResource CreateLinkedMasterTemplateResourceForApiTemplate(string name, string uriLink, string[] dependsOn, Extractor exc) { MasterTemplateResource masterResourceTemplate = this.CreateLinkedMasterTemplateResource(name, uriLink, dependsOn); if (exc.policyXMLSasToken != null) { masterResourceTemplate.properties.parameters.Add("PolicyXMLSasToken", new TemplateParameterProperties() { value = "[parameters('PolicyXMLSasToken')]" }); } if (exc.paramServiceUrl) { masterResourceTemplate.properties.parameters.Add("serviceUrl", new TemplateParameterProperties() { value = "[parameters('serviceUrl')]" }); } return(masterResourceTemplate); }
public async Task <Template> GenerateProductsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, string fileFolder, Extractor exc) { Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting products from service"); Template armTemplate = GenerateEmptyPropertyTemplateWithParameters(); if (exc.policyXMLBaseUrl != null && exc.policyXMLSasToken != null) { TemplateParameterProperties policyTemplateSasTokenParameterProperties = new TemplateParameterProperties() { type = "string" }; armTemplate.parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenParameterProperties); } if (exc.policyXMLBaseUrl != null) { TemplateParameterProperties policyTemplateBaseUrlParameterProperties = new TemplateParameterProperties() { type = "string" }; armTemplate.parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlParameterProperties); } // isolate product api associations in the case of a single api extraction var productAPIResources = apiTemplateResources.Where(resource => resource.type == ResourceTypeConstants.ProductAPI); List <TemplateResource> templateResources = new List <TemplateResource>(); // pull all products for service string products = await GetProductsAsync(apimname, resourceGroup); JObject oProducts = JObject.Parse(products); foreach (var item in oProducts["value"]) { string productName = ((JValue)item["name"]).Value.ToString(); string productDetails = await GetProductDetailsAsync(apimname, resourceGroup, productName); // convert returned product to template resource class JsonSerializerSettings settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, MissingMemberHandling = MissingMemberHandling.Ignore }; ProductsTemplateResource productsTemplateResource = JsonConvert.DeserializeObject <ProductsTemplateResource>(productDetails, settings); productsTemplateResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}')]"; productsTemplateResource.apiVersion = GlobalConstants.APIVersion; string productGroupDetails = await GetProductGroupsAsync(apimname, resourceGroup, productName); ProductGroupsTemplateResource productGroupsDetails = JsonConvert.DeserializeObject <ProductGroupsTemplateResource>(productGroupDetails, settings); // only extract the product if this is a full extraction, or in the case of a single api, if it is found in products associated with the api if (singleApiName == null || productAPIResources.SingleOrDefault(p => p.name.Contains($"/{productName}/")) != null) { Console.WriteLine("'{0}' Product found", productName); templateResources.Add(productsTemplateResource); // add product policy resource to template try { var productResourceId = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{productName}')]" }; foreach (ProductGroupsValue ProductGroup in productGroupsDetails.value) { ProductGroup.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/{ProductGroup.name}')]"; ProductGroup.apiVersion = GlobalConstants.APIVersion; ProductGroup.dependsOn = productResourceId; templateResources.Add(ProductGroup); } string productPolicy = await GetProductPolicyAsync(apimname, resourceGroup, productName); Console.WriteLine($" - Product policy found for {productName} product"); PolicyTemplateResource productPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(productPolicy); productPolicyResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/policy')]"; productPolicyResource.apiVersion = GlobalConstants.APIVersion; productPolicyResource.scale = null; productPolicyResource.dependsOn = productResourceId; // write policy xml content to file and point to it if policyXMLBaseUrl is provided if (exc.policyXMLBaseUrl != null) { string policyXMLContent = productPolicyResource.properties.value; string policyFolder = String.Concat(fileFolder, $@"/policies"); string productPolicyFileName = $@"/{productName}-productPolicy.xml"; this.fileWriter.CreateFolderIfNotExists(policyFolder); this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, productPolicyFileName)); productPolicyResource.properties.format = "rawxml-link"; if (exc.policyXMLSasToken != null) { productPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{productPolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]"; } else { productPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{productPolicyFileName}')]"; } } templateResources.Add(productPolicyResource); } catch (Exception) { } // add tags associated with the product to template try { // pull tags associated with the product string productTags = await GetProductTagsAsync(apimname, resourceGroup, productName); JObject oProductTags = JObject.Parse(productTags); foreach (var tag in oProductTags["value"]) { string productTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine(" - '{0}' Tag association found for {1} product", productTagName, productName); // convert associations between product and tags to template resource class TagTemplateResource productTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); productTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{productName}/{productTagName}')]"; productTagResource.apiVersion = GlobalConstants.APIVersion; productTagResource.scale = null; productTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{productName}')]" }; templateResources.Add(productTagResource); } } catch (Exception) { } } } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }
/// <summary> /// Adds related API Template resources like schemas, operations, products, tags etc. /// </summary> /// <param name="apiName">The name of the API.</param> /// <param name="exc">The extractor.</param> /// <returns></returns> private async Task <IEnumerable <TemplateResource> > GetRelatedTemplateResourcesAsync(string apiName, Extractor exc) { List <TemplateResource> templateResources = new List <TemplateResource>(); string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup, fileFolder = exc.fileFolder, policyXMLBaseUrl = exc.policyXMLBaseUrl, policyXMLSasToken = exc.policyXMLSasToken; #region Schemas // add schema resources to api template List <TemplateResource> schemaResources = await GenerateSchemasARMTemplate(apimname, apiName, resourceGroup, fileFolder); templateResources.AddRange(schemaResources); #endregion #region Operations // pull api operations for service string[] operationNames = await GetAllOperationNames(apimname, resourceGroup, apiName); int numBatches = 0; // create empty array for the batch operation owners List <string> batchOwners = new List <string>(); // if a batch size is specified if (exc.operationBatchSize > 0) { // store the number of batches required based on exc.operationBatchSize numBatches = (int)Math.Ceiling((double)operationNames.Length / (double)exc.operationBatchSize); //Console.WriteLine ("Number of batches: {0}", numBatches); } foreach (string operationName in operationNames) { int opIndex = Array.IndexOf(operationNames, operationName); //add batch owners into array // ensure each owner is linked to the one before if (exc.operationBatchSize > 0 && opIndex < numBatches) { batchOwners.Add(operationName); //Console.WriteLine("Adding operation {0} to owner list", operationName); } string operationDetails = await GetAPIOperationDetailsAsync(apimname, resourceGroup, apiName, operationName); Console.WriteLine("'{0}' Operation found", operationName); // convert returned operation to template resource class OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails); string operationResourceName = operationResource.name; operationResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}')]"; operationResource.apiVersion = GlobalConstants.APIVersion; operationResource.scale = null; // add operation dependencies and fix sample value if necessary List <string> operationDependsOn = new List <string>() { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationResource.properties.request.representations) { AddSchemaDependencyToOperationIfNecessary(apiName, operationDependsOn, operationTemplateRepresentation); ArmEscapeSampleValueIfNecessary(operationTemplateRepresentation); } foreach (OperationsTemplateResponse operationTemplateResponse in operationResource.properties.responses) { foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationTemplateResponse.representations) { AddSchemaDependencyToOperationIfNecessary(apiName, operationDependsOn, operationTemplateRepresentation); ArmEscapeSampleValueIfNecessary(operationTemplateRepresentation); } } // add to batch if flagged string batchdependsOn; if (exc.operationBatchSize > 0 && opIndex > 0) { if (opIndex >= 1 && opIndex <= numBatches - 1) { // chain the owners to each other batchdependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{batchOwners[opIndex - 1]}')]"; //Console.WriteLine("Owner chaining: this request {0} to previous {1}", operationName, batchOwners[opIndex-1]); } else { // chain the operation to respective owner int ownerIndex = (int)Math.Floor((opIndex - numBatches) / ((double)exc.operationBatchSize - 1)); batchdependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{batchOwners[ownerIndex]}')]"; //Console.WriteLine("Operation {0} chained to owner {1}", operationName, batchOwners[ownerIndex]); } operationDependsOn.Add(batchdependsOn); } operationResource.dependsOn = operationDependsOn.ToArray(); templateResources.Add(operationResource); // add operation policy resource to api template try { string operationPolicy = await GetOperationPolicyAsync(apimname, resourceGroup, apiName, operationName); Console.WriteLine($" - Operation policy found for {operationName} operation"); PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy); operationPolicyResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}/policy')]"; operationPolicyResource.apiVersion = GlobalConstants.APIVersion; operationPolicyResource.scale = null; operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{operationResourceName}')]" }; // write policy xml content to file and point to it if policyXMLBaseUrl is provided if (policyXMLBaseUrl != null) { string policyXMLContent = operationPolicyResource.properties.value; string policyFolder = String.Concat(fileFolder, $@"/policies"); string operationPolicyFileName = $@"/{apiName}-{operationName}-operationPolicy.xml"; this.fileWriter.CreateFolderIfNotExists(policyFolder); this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, operationPolicyFileName)); operationPolicyResource.properties.format = "rawxml-link"; if (policyXMLSasToken != null) { operationPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{operationPolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]"; } else { operationPolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{operationPolicyFileName}')]"; } } templateResources.Add(operationPolicyResource); } catch (Exception) { } // add tags associated with the operation to template try { // pull tags associated with the operation string apiOperationTags = await GetOperationTagsAsync(apimname, resourceGroup, apiName, operationName); JObject oApiOperationTags = JObject.Parse(apiOperationTags); foreach (var tag in oApiOperationTags["value"]) { string apiOperationTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine(" - '{0}' Tag association found for {1} operation", apiOperationTagName, operationResourceName); // convert operation tag association to template resource class TagTemplateResource operationTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); operationTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}/{apiOperationTagName}')]"; operationTagResource.apiVersion = GlobalConstants.APIVersion; operationTagResource.scale = null; operationTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{operationResourceName}')]" }; templateResources.Add(operationTagResource); } } catch (Exception) { } } #endregion #region API Policies // add api policy resource to api template try { string apiPolicies = await GetAPIPolicyAsync(apimname, resourceGroup, apiName); Console.WriteLine("API policy found"); PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies); apiPoliciesResource.apiVersion = GlobalConstants.APIVersion; apiPoliciesResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{apiPoliciesResource.name}')]"; apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; // write policy xml content to file and point to it if policyXMLBaseUrl is provided if (policyXMLBaseUrl != null) { string policyXMLContent = apiPoliciesResource.properties.value; string policyFolder = String.Concat(fileFolder, $@"/policies"); string apiPolicyFileName = $@"/{apiName}-apiPolicy.xml"; this.fileWriter.CreateFolderIfNotExists(policyFolder); this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, apiPolicyFileName)); apiPoliciesResource.properties.format = "rawxml-link"; if (policyXMLSasToken != null) { apiPoliciesResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{apiPolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]"; } else { apiPoliciesResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{apiPolicyFileName}')]"; } } templateResources.Add(apiPoliciesResource); } catch (Exception) { } #endregion #region API Tags // add tags associated with the api to template try { // pull tags associated with the api string apiTags = await GetAPITagsAsync(apimname, resourceGroup, apiName); JObject oApiTags = JObject.Parse(apiTags); foreach (var tag in oApiTags["value"]) { string apiTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine("'{0}' Tag association found", apiTagName); // convert associations between api and tags to template resource class TagTemplateResource apiTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); apiTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{apiTagName}')]"; apiTagResource.apiVersion = GlobalConstants.APIVersion; apiTagResource.scale = null; apiTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; templateResources.Add(apiTagResource); } } catch (Exception) { } #endregion // add product api associations to template #region API Products try { // pull product api associations string apiProducts = await GetAPIProductsAsync(apimname, resourceGroup, apiName); JObject oApiProducts = JObject.Parse(apiProducts); foreach (var item in oApiProducts["value"]) { string apiProductName = ((JValue)item["name"]).Value.ToString(); Console.WriteLine("'{0}' Product association found", apiProductName); // convert returned api product associations to template resource class ProductAPITemplateResource productAPIResource = JsonConvert.DeserializeObject <ProductAPITemplateResource>(item.ToString()); productAPIResource.type = ResourceTypeConstants.ProductAPI; productAPIResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiProductName}/{apiName}')]"; productAPIResource.apiVersion = GlobalConstants.APIVersion; productAPIResource.scale = null; productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; templateResources.Add(productAPIResource); } } catch (Exception) { } #endregion #region Diagnostics // add diagnostics to template // pull diagnostics for api string diagnostics = await GetAPIDiagnosticsAsync(apimname, resourceGroup, apiName); JObject oDiagnostics = JObject.Parse(diagnostics); foreach (var diagnostic in oDiagnostics["value"]) { string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString(); Console.WriteLine("'{0}' Diagnostic found", diagnosticName); // convert returned diagnostic to template resource class DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>(); diagnosticResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{diagnosticName}')]"; diagnosticResource.type = ResourceTypeConstants.APIDiagnostic; diagnosticResource.apiVersion = GlobalConstants.APIVersion; diagnosticResource.scale = null; diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiName}')]" }; if (exc.paramApiLoggerId) { diagnosticResource.properties.loggerId = $"[parameters('{ParameterNames.ApiLoggerId}').{ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api)}.{ExtractorUtils.GenValidParamName(diagnosticName, ParameterPrefix.Diagnostic)}]"; } if (!diagnosticName.Contains("applicationinsights")) { // enableHttpCorrelationHeaders only works for application insights, causes errors otherwise diagnosticResource.properties.enableHttpCorrelationHeaders = null; } templateResources.Add(diagnosticResource); } #endregion return(templateResources); }
/* three condistions to use this function: * 1. singleApiName is null, then generate one master template for the multipleAPIs in multipleApiNams * 2. multipleApiNams is null, then generate separate folder and master template for each API * 3. when both singleApiName and multipleApiNams is null, then generate one master template to link all apis in the sourceapim */ public static async Task GenerateTemplates( Extractor exc, string singleApiName, List <string> multipleAPINames, FileNameGenerator fileNameGenerator, FileNames fileNames, FileWriter fileWriter, Template apiTemplate) { if (singleApiName != null && multipleAPINames != null) { throw new Exception("can't specify single API and multiple APIs to extract at the same time"); } // initialize entity extractor classes APIExtractor apiExtractor = new APIExtractor(fileWriter); APIVersionSetExtractor apiVersionSetExtractor = new APIVersionSetExtractor(); AuthorizationServerExtractor authorizationServerExtractor = new AuthorizationServerExtractor(); BackendExtractor backendExtractor = new BackendExtractor(); LoggerExtractor loggerExtractor = new LoggerExtractor(); PolicyExtractor policyExtractor = new PolicyExtractor(fileWriter); PropertyExtractor propertyExtractor = new PropertyExtractor(); TagExtractor tagExtractor = new TagExtractor(); ProductAPIExtractor productAPIExtractor = new ProductAPIExtractor(fileWriter); APITagExtractor apiTagExtractor = new APITagExtractor(fileWriter); ProductExtractor productExtractor = new ProductExtractor(fileWriter); MasterTemplateExtractor masterTemplateExtractor = new MasterTemplateExtractor(); // read parameters string sourceApim = exc.sourceApimName; string resourceGroup = exc.resourceGroup; string destinationApim = exc.destinationApimName; string linkedBaseUrl = exc.linkedTemplatesBaseUrl; string linkedSasToken = exc.linkedTemplatesSasToken; string policyXMLBaseUrl = exc.policyXMLBaseUrl; string policyXMLSasToken = exc.policyXMLSasToken; string dirName = exc.fileFolder; List <string> multipleApiNames = multipleAPINames; string linkedUrlQueryString = exc.linkedTemplatesUrlQueryString; // Get all Apis that will be extracted List <string> apisToExtract = new List <string>(); if (singleApiName != null) { apisToExtract.Add(singleApiName); } else if (multipleApiNames != null) { apisToExtract.AddRange(multipleApiNames); } else { List <string> allApis = await apiExtractor.GetAllAPINamesAsync(exc.sourceApimName, exc.resourceGroup); apisToExtract.AddRange(allApis); } Dictionary <string, object> apiLoggerId = null; if (exc.paramApiLoggerId) { apiLoggerId = await GetAllReferencedLoggers(apisToExtract, exc); } // extract templates from apim service Template globalServicePolicyTemplate = await policyExtractor.GenerateGlobalServicePolicyTemplateAsync(sourceApim, resourceGroup, policyXMLBaseUrl, policyXMLSasToken, dirName); if (apiTemplate == null) { apiTemplate = await apiExtractor.GenerateAPIsARMTemplateAsync(singleApiName, multipleApiNames, exc); } List <TemplateResource> apiTemplateResources = apiTemplate.resources.ToList(); Template apiVersionSetTemplate = await apiVersionSetExtractor.GenerateAPIVersionSetsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources); Template authorizationServerTemplate = await authorizationServerExtractor.GenerateAuthorizationServersARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources); Template loggerTemplate = await loggerExtractor.GenerateLoggerTemplateAsync(exc, singleApiName, apiTemplateResources, apiLoggerId); Template productTemplate = await productExtractor.GenerateProductsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, dirName, exc); Template productAPITemplate = await productAPIExtractor.GenerateAPIProductsARMTemplateAsync(singleApiName, multipleApiNames, exc); Template apiTagTemplate = await apiTagExtractor.GenerateAPITagsARMTemplateAsync(singleApiName, multipleApiNames, exc); List <TemplateResource> productTemplateResources = productTemplate.resources.ToList(); List <TemplateResource> loggerResources = loggerTemplate.resources.ToList(); Template namedValueTemplate = await propertyExtractor.GenerateNamedValuesTemplateAsync(singleApiName, apiTemplateResources, exc, backendExtractor, loggerResources); Template tagTemplate = await tagExtractor.GenerateTagsTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, productTemplateResources, policyXMLBaseUrl, policyXMLSasToken); List <TemplateResource> namedValueResources = namedValueTemplate.resources.ToList(); Tuple <Template, Dictionary <string, BackendApiParameters> > backendResult = await backendExtractor.GenerateBackendsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, namedValueResources, exc); Dictionary <string, string> loggerResourceIds = null; if (exc.paramLogResourceId) { loggerResourceIds = loggerExtractor.GetAllLoggerResourceIds(loggerResources); loggerTemplate = loggerExtractor.SetLoggerResourceId(loggerTemplate); } // create parameters file Template templateParameters = await masterTemplateExtractor.CreateMasterTemplateParameterValues(apisToExtract, exc, apiLoggerId, loggerResourceIds, backendResult.Item2, namedValueResources); // write templates to output file location string apiFileName = fileNameGenerator.GenerateExtractorAPIFileName(singleApiName, fileNames.baseFileName); fileWriter.WriteJSONToFile(apiTemplate, String.Concat(@dirName, apiFileName)); // won't generate template when there is no resources if (apiVersionSetTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(apiVersionSetTemplate, String.Concat(@dirName, fileNames.apiVersionSets)); } if (backendResult.Item1.resources.Count() != 0) { fileWriter.WriteJSONToFile(backendResult.Item1, String.Concat(@dirName, fileNames.backends)); } if (loggerTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(loggerTemplate, String.Concat(@dirName, fileNames.loggers)); } if (authorizationServerTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(authorizationServerTemplate, String.Concat(@dirName, fileNames.authorizationServers)); } if (productTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(productTemplate, String.Concat(@dirName, fileNames.products)); } if (productAPITemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(productAPITemplate, String.Concat(@dirName, fileNames.productAPIs)); } if (apiTagTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(apiTagTemplate, String.Concat(@dirName, fileNames.apiTags)); } if (tagTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(tagTemplate, String.Concat(@dirName, fileNames.tags)); } if (namedValueTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(namedValueTemplate, String.Concat(@dirName, fileNames.namedValues)); } if (globalServicePolicyTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(globalServicePolicyTemplate, String.Concat(@dirName, fileNames.globalServicePolicy)); } if (linkedBaseUrl != null) { // create a master template that links to all other templates Template masterTemplate = masterTemplateExtractor.GenerateLinkedMasterTemplate( apiTemplate, globalServicePolicyTemplate, apiVersionSetTemplate, productTemplate, productAPITemplate, apiTagTemplate, loggerTemplate, backendResult.Item1, authorizationServerTemplate, namedValueTemplate, tagTemplate, fileNames, apiFileName, exc); fileWriter.WriteJSONToFile(masterTemplate, String.Concat(@dirName, fileNames.linkedMaster)); } // write parameters to outputLocation fileWriter.WriteJSONToFile(templateParameters, String.Concat(dirName, fileNames.parameters)); }
/// <summary> /// Gets the "All API" level diagnostic resources, these are common to all APIs. /// </summary> /// <param name="exc">The extractor.</param> /// <returns>a list of DiagnosticTemplateResources</returns> private async Task <IEnumerable <TemplateResource> > GetServiceDiagnosticsTemplateResourcesAsync(Extractor exc) { List <TemplateResource> templateResources = new List <TemplateResource>(); string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup; string serviceDiagnostics = await GetServiceDiagnosticsAsync(apimname, resourceGroup); JObject oServiceDiagnostics = JObject.Parse(serviceDiagnostics); foreach (var serviceDiagnostic in oServiceDiagnostics["value"]) { string serviceDiagnosticName = ((JValue)serviceDiagnostic["name"]).Value.ToString(); Console.WriteLine("'{0}' Diagnostic found", serviceDiagnosticName); // convert returned diagnostic to template resource class DiagnosticTemplateResource serviceDiagnosticResource = serviceDiagnostic.ToObject <DiagnosticTemplateResource>(); serviceDiagnosticResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{serviceDiagnosticName}')]"; serviceDiagnosticResource.type = ResourceTypeConstants.APIServiceDiagnostic; serviceDiagnosticResource.apiVersion = GlobalConstants.APIVersion; serviceDiagnosticResource.scale = null; serviceDiagnosticResource.dependsOn = new string[] { }; if (exc.paramApiLoggerId) { serviceDiagnosticResource.properties.loggerId = $"[parameters('{ParameterNames.ApiLoggerId}').{ExtractorUtils.GenValidParamName(serviceDiagnosticName, ParameterPrefix.Diagnostic)}]"; } if (!serviceDiagnosticName.Contains("applicationinsights")) { // enableHttpCorrelationHeaders only works for application insights, causes errors otherwise //TODO: Check this settings still valid? serviceDiagnosticResource.properties.enableHttpCorrelationHeaders = null; } templateResources.Add(serviceDiagnosticResource); } return(templateResources.ToArray()); }
public Template GenerateLinkedMasterTemplate(Template apiTemplate, Template globalServicePolicyTemplate, Template apiVersionSetTemplate, Template productsTemplate, Template productAPIsTemplate, Template apiTagsTemplate, Template loggersTemplate, Template backendsTemplate, Template authorizationServersTemplate, Template namedValuesTemplate, Template tagTemplate, FileNames fileNames, string apiFileName, Extractor exc) { Console.WriteLine("------------------------------------------"); Console.WriteLine("Generating master template"); // create empty template Template masterTemplate = GenerateEmptyTemplate(); // add parameters masterTemplate.parameters = this.CreateMasterTemplateParameters(true, exc); // add deployment resources that links to all resource files List <TemplateResource> resources = new List <TemplateResource>(); // namedValue string namedValueDeploymentResourceName = "namedValuesTemplate"; // all other deployment resources will depend on named values string[] dependsOnNamedValues = new string[] { }; // api dependsOn List <string> apiDependsOn = new List <string>(); List <string> productAPIDependsOn = new List <string>(); List <string> apiTagDependsOn = new List <string>(); if (namedValuesTemplate != null && namedValuesTemplate.resources.Count() != 0) { dependsOnNamedValues = new string[] { $"[resourceId('Microsoft.Resources/deployments', '{namedValueDeploymentResourceName}')]" }; apiDependsOn.Add($"[resourceId('Microsoft.Resources/deployments', '{namedValueDeploymentResourceName}')]"); string namedValuesUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.namedValues); resources.Add(this.CreateLinkedMasterTemplateResourceForPropertyTemplate(namedValueDeploymentResourceName, namedValuesUri, new string[] { }, exc)); } // globalServicePolicy if (globalServicePolicyTemplate != null && globalServicePolicyTemplate.resources.Count() != 0) { apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'globalServicePolicyTemplate')]"); string globalServicePolicyUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.globalServicePolicy); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("globalServicePolicyTemplate", globalServicePolicyUri, dependsOnNamedValues, exc)); } // apiVersionSet if (apiVersionSetTemplate != null && apiVersionSetTemplate.resources.Count() != 0) { apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'versionSetTemplate')]"); string apiVersionSetUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.apiVersionSets); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("versionSetTemplate", apiVersionSetUri, dependsOnNamedValues, exc)); } // product if (productsTemplate != null && productsTemplate.resources.Count() != 0) { apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'productsTemplate')]"); productAPIDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'productsTemplate')]"); string productsUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.products); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("productsTemplate", productsUri, dependsOnNamedValues, exc)); } if (tagTemplate != null && tagTemplate.resources.Count() != 0) { apiTagDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'tagTemplate')]"); apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'tagTemplate')]"); string tagUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.tags); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("tagTemplate", tagUri, dependsOnNamedValues, exc)); } // logger if (loggersTemplate != null && loggersTemplate.resources.Count() != 0) { apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'loggersTemplate')]"); string loggersUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.loggers); resources.Add(this.CreateLinkedMasterTemplateResourceForLoggerTemplate("loggersTemplate", loggersUri, dependsOnNamedValues, exc)); } // backend if (backendsTemplate != null && backendsTemplate.resources.Count() != 0) { apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'backendsTemplate')]"); string backendsUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.backends); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("backendsTemplate", backendsUri, dependsOnNamedValues, exc)); } // authorizationServer if (authorizationServersTemplate != null && authorizationServersTemplate.resources.Count() != 0) { apiDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'authorizationServersTemplate')]"); string authorizationServersUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.authorizationServers); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("authorizationServersTemplate", authorizationServersUri, dependsOnNamedValues, exc)); } // api if (apiTemplate != null && apiTemplate.resources.Count() != 0) { apiTagDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'apisTemplate')]"); productAPIDependsOn.Add("[resourceId('Microsoft.Resources/deployments', 'apisTemplate')]"); string apisUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, apiFileName); resources.Add(this.CreateLinkedMasterTemplateResourceForApiTemplate("apisTemplate", apisUri, apiDependsOn.ToArray(), exc)); } // productAPIs if (productAPIsTemplate != null && productAPIsTemplate.resources.Count() != 0) { string productAPIsUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.productAPIs); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("productAPIsTemplate", productAPIsUri, productAPIDependsOn.ToArray(), exc)); } // apiTags if (apiTagsTemplate != null && apiTagsTemplate.resources.Count() != 0) { string apiTagsUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, fileNames.apiTags); resources.Add(this.CreateLinkedMasterTemplateResourceWithPolicyToken("apiTagsTemplate", apiTagsUri, apiTagDependsOn.ToArray(), exc)); } Console.WriteLine("Master template generated"); masterTemplate.resources = resources.ToArray(); return(masterTemplate); }
public async Task <List <TemplateResource> > GenerateSingleProductAPIResourceAsync(string apiName, Extractor exc, string[] dependsOn) { List <TemplateResource> templateResources = new List <TemplateResource>(); string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup, fileFolder = exc.fileFolder, policyXMLBaseUrl = exc.policyXMLBaseUrl, policyXMLSasToken = exc.policyXMLSasToken; Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting products from {0} API:", apiName); // add product api associations to template #region API Products try { // pull product api associations string apiProducts = await GetAPIProductsAsync(apimname, resourceGroup, apiName); JObject oApiProducts = JObject.Parse(apiProducts); string lastProductAPIName = null; foreach (var item in oApiProducts["value"]) { string apiProductName = ((JValue)item["name"]).Value.ToString(); Console.WriteLine("'{0}' Product association found", apiProductName); // convert returned api product associations to template resource class ProductAPITemplateResource productAPIResource = JsonConvert.DeserializeObject <ProductAPITemplateResource>(item.ToString()); productAPIResource.type = ResourceTypeConstants.ProductAPI; productAPIResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiProductName}/{apiName}')]"; productAPIResource.apiVersion = GlobalConstants.APIVersion; productAPIResource.scale = null; productAPIResource.dependsOn = (lastProductAPIName != null) ? new string[] { lastProductAPIName } : dependsOn; templateResources.Add(productAPIResource); lastProductAPIName = $"[resourceId('Microsoft.ApiManagement/service/products/apis', parameters('{ParameterNames.ApimServiceName}'), '{apiProductName}', '{apiName}')]"; } } catch (Exception) { } #endregion return(templateResources); }
public MasterTemplateResource CreateLinkedMasterTemplateResourceWithPolicyToken(string name, string uriLink, string[] dependsOn, Extractor exc) { if (exc.policyXMLSasToken == null) { return(this.CreateLinkedMasterTemplateResource(name, uriLink, dependsOn)); } else { MasterTemplateResource masterResourceTemplate = this.CreateLinkedMasterTemplateResource(name, uriLink, dependsOn); masterResourceTemplate.properties.parameters.Add(ParameterNames.PolicyXMLSasToken, new TemplateParameterProperties() { value = $"[parameters('{ParameterNames.PolicyXMLSasToken}')]" }); return(masterResourceTemplate); } }
public async Task <Template> GenerateLoggerTemplateAsync(Extractor exc, string singleApiName, List <TemplateResource> apiTemplateResources, Dictionary <string, Dictionary <string, string> > apiLoggerId) { Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting loggers from service"); Template armTemplate = GenerateEmptyLoggerTemplateWithParameters(exc); // isolate product api associations in the case of a single api extraction var policyResources = apiTemplateResources.Where(resource => (resource.type == ResourceTypeConstants.APIPolicy || resource.type == ResourceTypeConstants.APIOperationPolicy || resource.type == ResourceTypeConstants.ProductPolicy)); List <TemplateResource> templateResources = new List <TemplateResource>(); // pull all loggers for service string loggers = await GetLoggersAsync(exc.sourceApimName, exc.resourceGroup); JObject oLoggers = JObject.Parse(loggers); foreach (var extractedLogger in oLoggers["value"]) { string loggerName = ((JValue)extractedLogger["name"]).Value.ToString(); string fullLoggerResource = await GetLoggerDetailsAsync(exc.sourceApimName, exc.resourceGroup, loggerName); // convert returned logger to template resource class LoggerTemplateResource loggerResource = JsonConvert.DeserializeObject <LoggerTemplateResource>(fullLoggerResource); loggerResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{loggerName}')]"; loggerResource.type = ResourceTypeConstants.Logger; loggerResource.apiVersion = GlobalConstants.APIVersion; loggerResource.scale = null; if (singleApiName == null) { // if the user is extracting all apis, extract all the loggers Console.WriteLine("'{0}' Logger found", loggerName); templateResources.Add(loggerResource); } else { // if the user is extracting a single api, extract the loggers referenced by its diagnostics and api policies bool isReferencedInPolicy = false; bool isReferencedInDiagnostic = false; foreach (PolicyTemplateResource policyTemplateResource in policyResources) { if (policyTemplateResource.properties.value.Contains(loggerName)) { isReferencedInPolicy = true; } } string validApiName = ExtractorUtils.GenValidParamName(singleApiName, ParameterPrefix.Api); if (exc.paramApiLoggerId && apiLoggerId.ContainsKey(validApiName)) { Dictionary <string, string> curDiagnostic = apiLoggerId[validApiName]; string validDName = ExtractorUtils.GenValidParamName(loggerResource.properties.loggerType, ParameterPrefix.Diagnostic).ToLower(); if (curDiagnostic.ContainsKey(validDName) && curDiagnostic[validDName].Contains(loggerName)) { isReferencedInDiagnostic = true; } } if (isReferencedInPolicy == true || isReferencedInDiagnostic == true) { // logger was used in policy or diagnostic, extract it Console.WriteLine("'{0}' Logger found", loggerName); templateResources.Add(loggerResource); } }; } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }
public MasterTemplateResource CreateLinkedMasterTemplateResourceForLoggerTemplate(string name, string uriLink, string[] dependsOn, Extractor exc) { MasterTemplateResource masterResourceTemplate = this.CreateLinkedMasterTemplateResource(name, uriLink, dependsOn); if (exc.policyXMLSasToken != null) { masterResourceTemplate.properties.parameters.Add(ParameterNames.PolicyXMLSasToken, new TemplateParameterProperties() { value = $"[parameters('{ParameterNames.PolicyXMLSasToken}')]" }); } if (exc.paramLogResourceId) { masterResourceTemplate.properties.parameters.Add(ParameterNames.LoggerResourceId, new TemplateParameterProperties() { value = $"[parameters('{ParameterNames.LoggerResourceId}')]" }); } return(masterResourceTemplate); }
/* three condistions to use this function: * 1. singleApiName is null, then generate one master template for the multipleAPIs in multipleApiNams * 2. multipleApiNams is null, then generate separate folder and master template for each API * 3. when both singleApiName and multipleApiNams is null, then generate one master template to link all apis in the sourceapim */ public static async Task GenerateTemplates( Extractor exc, string singleApiName, List <string> multipleAPINames, FileNameGenerator fileNameGenerator, FileNames fileNames, FileWriter fileWriter, Template apiTemplate) { if (singleApiName != null && multipleAPINames != null) { throw new Exception("can't specify single API and multiple APIs to extract at the same time"); } // initialize entity extractor classes APIExtractor apiExtractor = new APIExtractor(fileWriter); APIVersionSetExtractor apiVersionSetExtractor = new APIVersionSetExtractor(); AuthorizationServerExtractor authorizationServerExtractor = new AuthorizationServerExtractor(); BackendExtractor backendExtractor = new BackendExtractor(); LoggerExtractor loggerExtractor = new LoggerExtractor(); PolicyExtractor policyExtractor = new PolicyExtractor(fileWriter); PropertyExtractor propertyExtractor = new PropertyExtractor(); TagExtractor tagExtractor = new TagExtractor(); ProductExtractor productExtractor = new ProductExtractor(fileWriter); MasterTemplateExtractor masterTemplateExtractor = new MasterTemplateExtractor(); // read parameters string sourceApim = exc.sourceApimName; string resourceGroup = exc.resourceGroup; string destinationApim = exc.destinationApimName; string linkedBaseUrl = exc.linkedTemplatesBaseUrl; string policyXMLBaseUrl = exc.policyXMLBaseUrl; string dirName = exc.fileFolder; List <string> multipleApiNames = multipleAPINames; string linkedUrlQueryString = exc.linkedTemplatesUrlQueryString; // extract templates from apim service Template globalServicePolicyTemplate = await policyExtractor.GenerateGlobalServicePolicyTemplateAsync(sourceApim, resourceGroup, policyXMLBaseUrl, dirName); if (apiTemplate == null) { apiTemplate = await apiExtractor.GenerateAPIsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, multipleApiNames, policyXMLBaseUrl, dirName); } List <TemplateResource> apiTemplateResources = apiTemplate.resources.ToList(); Template apiVersionSetTemplate = await apiVersionSetExtractor.GenerateAPIVersionSetsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl); Template authorizationServerTemplate = await authorizationServerExtractor.GenerateAuthorizationServersARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl); Template loggerTemplate = await loggerExtractor.GenerateLoggerTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl); Template productTemplate = await productExtractor.GenerateProductsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl, dirName); List <TemplateResource> productTemplateResources = productTemplate.resources.ToList(); Template namedValueTemplate = await propertyExtractor.GenerateNamedValuesTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, policyXMLBaseUrl); Template tagTemplate = await tagExtractor.GenerateTagsTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, productTemplateResources, policyXMLBaseUrl); List <TemplateResource> namedValueResources = namedValueTemplate.resources.ToList(); Template backendTemplate = await backendExtractor.GenerateBackendsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, namedValueResources, policyXMLBaseUrl); // create parameters file Template templateParameters = masterTemplateExtractor.CreateMasterTemplateParameterValues(destinationApim, linkedBaseUrl, linkedUrlQueryString, policyXMLBaseUrl); // write templates to output file location string apiFileName = fileNameGenerator.GenerateExtractorAPIFileName(singleApiName, sourceApim); fileWriter.WriteJSONToFile(apiTemplate, String.Concat(@dirName, apiFileName)); // won't generate template when there is no resources if (apiVersionSetTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(apiVersionSetTemplate, String.Concat(@dirName, fileNames.apiVersionSets)); } if (backendTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(backendTemplate, String.Concat(@dirName, fileNames.backends)); } if (authorizationServerTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(authorizationServerTemplate, String.Concat(@dirName, fileNames.authorizationServers)); } if (productTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(productTemplate, String.Concat(@dirName, fileNames.products)); } if (tagTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(tagTemplate, String.Concat(@dirName, fileNames.tags)); } if (namedValueTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(namedValueTemplate, String.Concat(@dirName, fileNames.namedValues)); } if (globalServicePolicyTemplate.resources.Count() != 0) { fileWriter.WriteJSONToFile(globalServicePolicyTemplate, String.Concat(@dirName, fileNames.globalServicePolicy)); } if (linkedBaseUrl != null) { // create a master template that links to all other templates Template masterTemplate = masterTemplateExtractor.GenerateLinkedMasterTemplate( apiTemplate, globalServicePolicyTemplate, apiVersionSetTemplate, productTemplate, loggerTemplate, backendTemplate, authorizationServerTemplate, namedValueTemplate, tagTemplate, fileNames, apiFileName, linkedUrlQueryString, policyXMLBaseUrl); fileWriter.WriteJSONToFile(masterTemplate, String.Concat(@dirName, fileNames.linkedMaster)); } // write parameters to outputLocation fileWriter.WriteJSONToFile(templateParameters, String.Concat(dirName, fileNames.parameters)); }
public Dictionary <string, TemplateParameterProperties> CreateMasterTemplateParameters(bool linked, Extractor exc) { // 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(ParameterNames.ApimServiceName, apimServiceNameProperties); // add remote location of template files for linked option if (linked == true) { TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Base URL of the repository that contains the generated templates" }, type = "string" }; parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties); // add linkedTemplatesSasToken parameter if provided and if the templates are linked if (exc.linkedTemplatesSasToken != null) { TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "The Shared Access Signature for the URL of the repository" }, type = "string" }; parameters.Add(ParameterNames.LinkedTemplatesSasToken, linkedTemplatesSasTokenProperties); } // add linkedTemplatesUrlQueryString parameter if provided and if the templates are linked if (exc.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); } } if (exc.policyXMLBaseUrl != null) { TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Base URL of the repository that contains the generated policy files" }, type = "string" }; parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlProperties); if (exc.policyXMLSasToken != null) { TemplateParameterProperties policyXMLSasTokenProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "The SAS token for the URL of the policy container" }, type = "string" }; parameters.Add(ParameterNames.PolicyXMLSasToken, policyXMLSasTokenProperties); } } if (exc.paramServiceUrl) { TemplateParameterProperties paramServiceUrlProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Service url for each Api" }, type = "object" }; parameters.Add(ParameterNames.ServiceUrl, paramServiceUrlProperties); } if (exc.paramNamedValue) { TemplateParameterProperties namedValueProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "Named values" }, type = "object" }; parameters.Add(ParameterNames.NamedValues, namedValueProperties); } if (exc.paramApiLoggerId) { TemplateParameterProperties loggerIdProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "LoggerId for this api" }, type = "object" }; parameters.Add(ParameterNames.ApiLoggerId, loggerIdProperties); } if (exc.paramLogResourceId) { TemplateParameterProperties loggerResourceIdProperties = new TemplateParameterProperties() { metadata = new TemplateParameterMetadata() { description = "ResourceId for the logger" }, type = "object" }; parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdProperties); } return(parameters); }
public async Task <Template> GenerateAPIsARMTemplateAsync(string singleApiName, List <string> multipleApiNames, Extractor exc) { // initialize arm template Template armTemplate = GenerateEmptyApiTemplateWithParameters(exc); List <TemplateResource> templateResources = new List <TemplateResource>(); // when extract single API if (singleApiName != null) { // check if this api exist try { string apiDetails = await GetAPIDetailsAsync(exc.sourceApimName, exc.resourceGroup, singleApiName); Console.WriteLine("{0} API found ...", singleApiName); templateResources.AddRange(await GenerateSingleAPIResourceAsync(singleApiName, exc)); } catch (Exception) { throw new Exception($"{singleApiName} API not found!"); } } // when extract multiple APIs and generate one master template else if (multipleApiNames != null) { Console.WriteLine("{0} APIs found ...", multipleApiNames.Count().ToString()); foreach (string apiName in multipleApiNames) { templateResources.AddRange(await GenerateSingleAPIResourceAsync(apiName, exc)); } } // when extract all APIs and generate one master template else { JToken[] oApis = await GetAllAPIObjsAsync(exc.sourceApimName, exc.resourceGroup); Console.WriteLine("{0} APIs found ...", (oApis.Count().ToString())); foreach (JToken oApi in oApis) { string apiName = ((JValue)oApi["name"]).Value.ToString(); templateResources.AddRange(await GenerateSingleAPIResourceAsync(apiName, exc)); } } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }
// this function will create master / parameter templates for deploying API revisions public Template CreateSingleAPIRevisionsMasterTemplate(List <string> revList, string currentRev, Extractor exc, FileNames fileNames) { // create empty template Template masterTemplate = GenerateEmptyTemplate(); // add parameters masterTemplate.parameters = this.CreateMasterTemplateParameters(true, exc); // add deployment resources that links to all resource files List <TemplateResource> resources = new List <TemplateResource>(); string curRevTemplate = String.Concat(currentRev, "MasterTemplate"); int masterCnt = 0; foreach (string apiName in revList) { string revMasterPath = String.Concat("/", apiName, fileNames.linkedMaster); string revUri = GenerateLinkedTemplateUri(exc.linkedTemplatesUrlQueryString, exc.linkedTemplatesSasToken, revMasterPath); string templatename = String.Concat("masterTemplate", masterCnt++); if (!apiName.Equals(currentRev)) { resources.Add(this.CreateLinkedMasterTemplateResource(templatename, revUri, GenerateAPIRevisionDependencies(curRevTemplate))); } else { resources.Add(this.CreateLinkedMasterTemplateResource(templatename, revUri, new string[] { })); } } masterTemplate.resources = resources.ToArray(); return(masterTemplate); }
public async Task <List <TemplateResource> > GenerateSingleAPITagResourceAsync(string apiName, Extractor exc, string[] dependsOn) { List <TemplateResource> templateResources = new List <TemplateResource>(); string apimname = exc.sourceApimName, resourceGroup = exc.resourceGroup, fileFolder = exc.fileFolder, policyXMLBaseUrl = exc.policyXMLBaseUrl, policyXMLSasToken = exc.policyXMLSasToken; Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting tags from {0} API:", apiName); string[] dependencyChain = dependsOn; #region Operations // pull api operations for service string[] operationNames = await GetAllOperationNames(apimname, resourceGroup, apiName); foreach (string operationName in operationNames) { string operationDetails = await GetAPIOperationDetailsAsync(apimname, resourceGroup, apiName, operationName); Console.WriteLine("'{0}' Operation found", operationName); // convert returned operation to template resource class OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails); string operationResourceName = operationResource.name; // add tags associated with the operation to template try { // pull tags associated with the operation string apiOperationTags = await GetOperationTagsAsync(apimname, resourceGroup, apiName, operationName); JObject oApiOperationTags = JObject.Parse(apiOperationTags); foreach (var tag in oApiOperationTags["value"]) { string apiOperationTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine(" - '{0}' Tag association found for {1} operation", apiOperationTagName, operationResourceName); // convert operation tag association to template resource class TagTemplateResource operationTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); operationTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{operationResourceName}/{apiOperationTagName}')]"; operationTagResource.apiVersion = GlobalConstants.APIVersion; operationTagResource.scale = null; operationTagResource.dependsOn = dependencyChain; templateResources.Add(operationTagResource); dependencyChain = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations/tags', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{operationResourceName}', '{apiOperationTagName}')]" }; } } catch (Exception) { } } #endregion #region Tags // add tags associated with the api to template try { // pull tags associated with the api string apiTags = await GetAPITagsAsync(apimname, resourceGroup, apiName); JObject oApiTags = JObject.Parse(apiTags); foreach (var tag in oApiTags["value"]) { string apiTagName = ((JValue)tag["name"]).Value.ToString(); Console.WriteLine("'{0}' Tag association found", apiTagName); // convert associations between api and tags to template resource class TagTemplateResource apiTagResource = JsonConvert.DeserializeObject <TagTemplateResource>(tag.ToString()); apiTagResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{apiTagName}')]"; apiTagResource.apiVersion = GlobalConstants.APIVersion; apiTagResource.scale = null; apiTagResource.dependsOn = dependencyChain; templateResources.Add(apiTagResource); dependencyChain = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/tags', parameters('{ParameterNames.ApimServiceName}'), '{apiName}', '{apiTagName}')]" }; } } catch (Exception) { } #endregion return(templateResources); }
public async Task <Template> CreateMasterTemplateParameterValues(List <string> apisToExtract, Extractor exc, Dictionary <string, Dictionary <string, string> > apiLoggerId, Dictionary <string, string> loggerResourceIds) { // used to create the parameter values for use in parameters file // create empty template Template masterTemplate = GenerateEmptyTemplate(); // add parameters with value property Dictionary <string, TemplateParameterProperties> parameters = new Dictionary <string, TemplateParameterProperties>(); TemplateParameterProperties apimServiceNameProperties = new TemplateParameterProperties() { value = exc.destinationApimName }; parameters.Add(ParameterNames.ApimServiceName, apimServiceNameProperties); if (exc.linkedTemplatesBaseUrl != null) { TemplateParameterProperties linkedTemplatesBaseUrlProperties = new TemplateParameterProperties() { value = exc.linkedTemplatesBaseUrl }; parameters.Add(ParameterNames.LinkedTemplatesBaseUrl, linkedTemplatesBaseUrlProperties); // add linkedTemplatesSasToken parameter if provided and if the user has provided a linkedTemplatesBaseUrl if (exc.linkedTemplatesSasToken != null) { TemplateParameterProperties linkedTemplatesSasTokenProperties = new TemplateParameterProperties() { value = exc.linkedTemplatesSasToken }; parameters.Add(ParameterNames.LinkedTemplatesSasToken, linkedTemplatesSasTokenProperties); } // add linkedTemplatesUrlQueryString parameter if provided and if the user has provided a linkedTemplatesBaseUrl if (exc.linkedTemplatesUrlQueryString != null) { TemplateParameterProperties linkedTemplatesUrlQueryStringProperties = new TemplateParameterProperties() { value = exc.linkedTemplatesUrlQueryString }; parameters.Add(ParameterNames.LinkedTemplatesUrlQueryString, linkedTemplatesUrlQueryStringProperties); } } if (exc.policyXMLBaseUrl != null) { TemplateParameterProperties policyTemplateBaseUrlProperties = new TemplateParameterProperties() { value = exc.policyXMLBaseUrl }; parameters.Add(ParameterNames.PolicyXMLBaseUrl, policyTemplateBaseUrlProperties); // add policyXMLSasToken parameter if provided and if the user has provided a policyXMLBaseUrl if (exc.policyXMLSasToken != null) { TemplateParameterProperties policyTemplateSasTokenProperties = new TemplateParameterProperties() { value = exc.policyXMLSasToken }; parameters.Add(ParameterNames.PolicyXMLSasToken, policyTemplateSasTokenProperties); } } if (exc.paramServiceUrl) { Dictionary <string, string> serviceUrls = new Dictionary <string, string>(); APIExtractor apiExc = new APIExtractor(new FileWriter()); foreach (string apiName in apisToExtract) { string validApiName = ExtractorUtils.GenValidParamName(apiName, ParameterPrefix.Api); string serviceUrl = exc.serviceUrlParameters != null?GetApiServiceUrlFromParameters(apiName, exc.serviceUrlParameters) : await apiExc.GetAPIServiceUrl(exc.sourceApimName, exc.resourceGroup, apiName); serviceUrls.Add(validApiName, serviceUrl); } TemplateObjectParameterProperties serviceUrlProperties = new TemplateObjectParameterProperties() { value = serviceUrls }; parameters.Add(ParameterNames.ServiceUrl, serviceUrlProperties); } if (exc.paramNamedValue) { Dictionary <string, string> namedValues = new Dictionary <string, string>(); PropertyExtractor pExc = new PropertyExtractor(); string[] properties = await pExc.GetPropertiesAsync(exc.sourceApimName, exc.resourceGroup); foreach (var extractedProperty in properties) { JToken oProperty = JObject.Parse(extractedProperty); string propertyName = ((JValue)oProperty["name"]).Value.ToString(); string fullPropertyResource = await pExc.GetPropertyDetailsAsync(exc.sourceApimName, exc.resourceGroup, propertyName); PropertyTemplateResource propertyTemplateResource = JsonConvert.DeserializeObject <PropertyTemplateResource>(fullPropertyResource); string propertyValue = propertyTemplateResource.properties.value; string validPName = ExtractorUtils.GenValidParamName(propertyName, ParameterPrefix.Property); namedValues.Add(validPName, propertyValue); } TemplateObjectParameterProperties namedValueProperties = new TemplateObjectParameterProperties() { value = namedValues }; parameters.Add(ParameterNames.NamedValues, namedValueProperties); } if (exc.paramApiLoggerId) { TemplateObjectParameterProperties loggerIdProperties = new TemplateObjectParameterProperties() { value = apiLoggerId }; parameters.Add(ParameterNames.ApiLoggerId, loggerIdProperties); } if (exc.paramLogResourceId) { TemplateObjectParameterProperties loggerResourceIdProperties = new TemplateObjectParameterProperties() { value = loggerResourceIds }; parameters.Add(ParameterNames.LoggerResourceId, loggerResourceIdProperties); } masterTemplate.parameters = parameters; return(masterTemplate); }
// this function generate apiTemplate for single api with all its revisions public async Task <Template> GenerateAPIRevisionTemplateAsync(string currentRevision, List <string> revList, string apiName, Extractor exc) { // generate apiTemplate Template armTemplate = GenerateEmptyTemplateWithParameters(exc.policyXMLBaseUrl, exc.policyXMLSasToken); List <TemplateResource> templateResources = new List <TemplateResource>(); Console.WriteLine("{0} APIs found ...", revList.Count().ToString()); List <TemplateResource> apiResources = await GenerateSingleAPIResourceAsync(apiName, exc.sourceApimName, exc.resourceGroup, exc.fileFolder, exc.policyXMLBaseUrl, exc.policyXMLSasToken); templateResources.AddRange(apiResources); foreach (string curApi in revList) { // should add current api to dependsOn to those revisions that are not "current" if (curApi.Equals(currentRevision)) { // add current API revision resource to template apiResources = await GenerateCurrentRevisionAPIResourceAsync(curApi, exc.sourceApimName, exc.resourceGroup, exc.fileFolder, exc.policyXMLBaseUrl, exc.policyXMLSasToken); templateResources.AddRange(apiResources); } else { // add other API revision resources to template apiResources = await GenerateSingleAPIResourceAsync(curApi, exc.sourceApimName, exc.resourceGroup, exc.fileFolder, exc.policyXMLBaseUrl, exc.policyXMLSasToken); // make current API a dependency to other revisions, in case destination apim doesn't have the this API TemplateResource apiResource = apiResources.FirstOrDefault(resource => resource.type == ResourceTypeConstants.API) as TemplateResource; List <TemplateResource> newResourcesList = ExtractorUtils.removeResourceType(ResourceTypeConstants.API, apiResources); List <string> dependsOn = apiResource.dependsOn.ToList(); dependsOn.Add($"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]"); apiResource.dependsOn = dependsOn.ToArray(); newResourcesList.Add(apiResource); templateResources.AddRange(newResourcesList); } } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }
public async Task <Template> GenerateNamedValuesTemplateAsync(string singleApiName, List <TemplateResource> apiTemplateResources, Extractor exc, BackendExtractor backendExtractor, List <TemplateResource> loggerTemplateResources) { Template armTemplate = GenerateEmptyPropertyTemplateWithParameters(); if (exc.paramNamedValue) { TemplateParameterProperties namedValueParameterProperties = new TemplateParameterProperties() { type = "object" }; armTemplate.parameters.Add(ParameterNames.NamedValues, namedValueParameterProperties); } if (exc.paramNamedValuesKeyVaultSecrets) { TemplateParameterProperties keyVaultNamedValueParameterProperties = new TemplateParameterProperties() { type = "object" }; armTemplate.parameters.Add(ParameterNames.NamedValueKeyVaultSecrets, keyVaultNamedValueParameterProperties); } if (exc.notIncludeNamedValue == true) { Console.WriteLine("------------------------------------------"); Console.WriteLine("Skipping extracting named values from service"); return(armTemplate); } Console.WriteLine("------------------------------------------"); Console.WriteLine("Extracting named values from service"); List <TemplateResource> templateResources = new List <TemplateResource>(); // pull all named values (properties) for service string[] properties = await GetPropertiesAsync(exc.sourceApimName, exc.resourceGroup); // isolate api and operation policy resources in the case of a single api extraction, as they may reference named value var policyResources = apiTemplateResources.Where(resource => (resource.type == ResourceTypeConstants.APIPolicy || resource.type == ResourceTypeConstants.APIOperationPolicy || resource.type == ResourceTypeConstants.ProductPolicy)); foreach (var extractedProperty in properties) { JToken oProperty = JObject.Parse(extractedProperty); string propertyName = ((JValue)oProperty["name"]).Value.ToString(); string fullPropertyResource = await GetPropertyDetailsAsync(exc.sourceApimName, exc.resourceGroup, propertyName); // convert returned named value to template resource class PropertyTemplateResource propertyTemplateResource = JsonConvert.DeserializeObject <PropertyTemplateResource>(fullPropertyResource); propertyTemplateResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{propertyName}')]"; propertyTemplateResource.type = ResourceTypeConstants.Property; propertyTemplateResource.apiVersion = GlobalConstants.APIVersion; propertyTemplateResource.scale = null; if (exc.paramNamedValue) { propertyTemplateResource.properties.value = $"[parameters('{ParameterNames.NamedValues}').{ExtractorUtils.GenValidParamName(propertyName, ParameterPrefix.Property)}]"; } //Hide the value field if it is a keyvault named value if (propertyTemplateResource.properties.keyVault != null) { propertyTemplateResource.properties.value = null; } if (propertyTemplateResource.properties.keyVault != null && exc.paramNamedValuesKeyVaultSecrets) { propertyTemplateResource.properties.keyVault.secretIdentifier = $"[parameters('{ParameterNames.NamedValueKeyVaultSecrets}').{ExtractorUtils.GenValidParamName(propertyName, ParameterPrefix.Property)}]"; } if (singleApiName == null) { // if the user is executing a full extraction, extract all the loggers Console.WriteLine("'{0}' Named value found", propertyName); templateResources.Add(propertyTemplateResource); } else { // if the user is executing a single api, extract all the named values used in the template resources bool foundInPolicy = DoesPolicyReferenceNamedValue(exc, policyResources, propertyName, propertyTemplateResource); bool foundInBackEnd = await backendExtractor.IsNamedValueUsedInBackends(exc.sourceApimName, exc.resourceGroup, singleApiName, apiTemplateResources, exc, propertyName, propertyTemplateResource.properties.displayName); bool foundInLogger = DoesLoggerReferenceNamedValue(loggerTemplateResources, propertyName, propertyTemplateResource); // check if named value is referenced in a backend if (foundInPolicy || foundInBackEnd || foundInLogger) { // named value was used in policy, extract it Console.WriteLine("'{0}' Named value found", propertyName); templateResources.Add(propertyTemplateResource); } } } armTemplate.resources = templateResources.ToArray(); return(armTemplate); }