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