private async void GenerateNamedValuesTemplate(string resourceGroup, string apimname, string fileFolder)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Getting named values from service");
PropertyExtractor propertyExtractor = new PropertyExtractor();
Template armTemplate = GenerateEmptyTemplateWithParameters();
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull named values for later credential reference
string properties = propertyExtractor.GetProperties(apimname, resourceGroup).Result;
JObject oProperties = JObject.Parse(properties);
foreach (var extractedProperty in oProperties["value"])
{
string propertyName = ((JValue)extractedProperty["name"]).Value.ToString();
Console.WriteLine("'{0}' Named value found", propertyName);
string fullLoggerResource = await propertyExtractor.GetProperty(apimname, resourceGroup, propertyName);
PropertyTemplateResource propertyTemplateResource = JsonConvert.DeserializeObject <PropertyTemplateResource>(fullLoggerResource);
propertyTemplateResource.name = $"[concat(parameters('ApimServiceName'), '/{propertyName}')]";
propertyTemplateResource.type = "Microsoft.ApiManagement/service/properties";
propertyTemplateResource.apiVersion = "2018-06-01-preview";
propertyTemplateResource.scale = null;
templateResources.Add(propertyTemplateResource);
}
armTemplate.resources = templateResources.ToArray();
FileWriter fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-namedvalues.json");
}
public ExtractCommand()
{
this.Name = GlobalConstants.ExtractName;
this.Description = GlobalConstants.ExtractDescription;
var sourceApimName = this.Option("--sourceApimName <sourceApimName>", "Source API Management name", CommandOptionType.SingleValue);
var destinationAPIManagementName = this.Option("--destinationApimName <destinationApimName>", "Destination API Management name", CommandOptionType.SingleValue);
var resourceGroupName = this.Option("--resourceGroup <resourceGroup>", "Resource Group name", CommandOptionType.SingleValue);
var fileFolderName = this.Option("--fileFolder <filefolder>", "ARM Template files folder", CommandOptionType.SingleValue);
var apiName = this.Option("--apiName <apiName>", "API name", CommandOptionType.SingleValue);
var linkedTemplatesBaseUrlName = this.Option("--linkedTemplatesBaseUrl <linkedTemplatesBaseUrl>", "Creates a master template with links", CommandOptionType.SingleValue);
var policyXMLBaseUrlName = this.Option("--policyXMLBaseUrl <policyXMLBaseUrl>", "Writes policies to local XML files that require deployment to remote folder", CommandOptionType.SingleValue);
this.HelpOption();
this.OnExecute(async() =>
{
try
{
if (!sourceApimName.HasValue())
{
throw new Exception("Missing parameter <sourceApimName>.");
}
if (!destinationAPIManagementName.HasValue())
{
throw new Exception("Missing parameter <destinationApimName>.");
}
if (!resourceGroupName.HasValue())
{
throw new Exception("Missing parameter <resourceGroup>.");
}
if (!fileFolderName.HasValue())
{
throw new Exception("Missing parameter <filefolder>.");
}
// isolate cli parameters
string resourceGroup = resourceGroupName.Values[0].ToString();
string sourceApim = sourceApimName.Values[0].ToString();
string destinationApim = destinationAPIManagementName.Values[0].ToString();
string fileFolder = fileFolderName.Values[0].ToString();
string linkedBaseUrl = linkedTemplatesBaseUrlName.HasValue() ? linkedTemplatesBaseUrlName.Value().ToString() : null;
string policyXMLBaseUrl = policyXMLBaseUrlName.HasValue() ? policyXMLBaseUrlName.Value().ToString() : null;
string singleApiName = null;
if (apiName.Values.Count > 0)
{
singleApiName = apiName.Values[0].ToString();
}
Console.WriteLine("API Management Template");
Console.WriteLine();
Console.WriteLine("Connecting to {0} API Management Service on {1} Resource Group ...", sourceApim, resourceGroup);
if (singleApiName != null)
{
Console.WriteLine("Executing extraction for {0} API ...", singleApiName);
}
else
{
Console.WriteLine("Executing full extraction ...", singleApiName);
}
// initialize file helper classes
FileWriter fileWriter = new FileWriter();
FileNameGenerator fileNameGenerator = new FileNameGenerator();
FileNames fileNames = fileNameGenerator.GenerateFileNames(sourceApim);
// 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();
PropertyExtractor propertyExtractor = new PropertyExtractor();
ProductExtractor productExtractor = new ProductExtractor(fileWriter);
MasterTemplateExtractor masterTemplateExtractor = new MasterTemplateExtractor();
// extract templates from apim service
Template apiTemplate = await apiExtractor.GenerateAPIsARMTemplateAsync(sourceApim, resourceGroup, singleApiName, policyXMLBaseUrl, fileFolder);
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, fileFolder);
Template namedValueTemplate = await propertyExtractor.GenerateNamedValuesTemplateAsync(sourceApim, resourceGroup, singleApiName, apiTemplateResources, 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, policyXMLBaseUrl);
// write templates to output file location
string apiFileName = fileNameGenerator.GenerateExtractorAPIFileName(singleApiName, sourceApim);
fileWriter.WriteJSONToFile(apiTemplate, String.Concat(@fileFolder, apiFileName));
fileWriter.WriteJSONToFile(apiVersionSetTemplate, String.Concat(@fileFolder, fileNames.apiVersionSets));
fileWriter.WriteJSONToFile(authorizationServerTemplate, String.Concat(@fileFolder, fileNames.authorizationServers));
fileWriter.WriteJSONToFile(backendTemplate, String.Concat(@fileFolder, fileNames.backends));
fileWriter.WriteJSONToFile(loggerTemplate, String.Concat(@fileFolder, fileNames.loggers));
fileWriter.WriteJSONToFile(namedValueTemplate, String.Concat(@fileFolder, fileNames.namedValues));
fileWriter.WriteJSONToFile(productTemplate, String.Concat(@fileFolder, fileNames.products));
if (linkedBaseUrl != null)
{
// create a master template that links to all other templates
Template masterTemplate = masterTemplateExtractor.GenerateLinkedMasterTemplate(apiTemplate, apiVersionSetTemplate, productTemplate, loggerTemplate, backendTemplate, authorizationServerTemplate, namedValueTemplate, fileNames, apiFileName, policyXMLBaseUrl);
fileWriter.WriteJSONToFile(masterTemplate, String.Concat(@fileFolder, fileNames.linkedMaster));
}
// write parameters to outputLocation
fileWriter.WriteJSONToFile(templateParameters, String.Concat(fileFolder, fileNames.parameters));
Console.WriteLine("Templates written to output location");
Console.WriteLine("Press any key to exit process:");
#if DEBUG
Console.ReadKey();
#endif
}
catch (Exception ex)
{
Console.WriteLine("Error occured: " + ex.Message);
throw;
}
});
}
/* 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 async Task <string> GetBackendsAsync(string ApiManagementName, string ResourceGroupName, string singleApiName)
{
(string azToken, string azSubId) = await auth.GetAccessToken();
if (string.IsNullOrEmpty(singleApiName))
{
string requestUrl = string.Format("{0}/subscriptions/{1}/resourceGroups/{2}/providers/Microsoft.ApiManagement/service/{3}/backends?api-version={4}",
baseUrl, azSubId, ResourceGroupName, ApiManagementName, GlobalConstants.APIVersion);
return(await CallApiManagementAsync(azToken, requestUrl));
}
else
{
JArray policies = new JArray();
// Get API Extractor for reading policies
FileWriter fw = new FileWriter();
var apiExtractor = new APIExtractor(fw);
// Add API policy
policies.Add(await apiExtractor.GetAPIPolicyAsync(ApiManagementName, ResourceGroupName, singleApiName));
// Get all operations of a specific API
var operations = await apiExtractor.GetAllOperationNames(ApiManagementName, ResourceGroupName, singleApiName);
// Add Operation policies
foreach (var operation in operations)
{
policies.Add(await apiExtractor.GetOperationPolicyAsync(ApiManagementName, ResourceGroupName, singleApiName, operation));
}
// Extract DisplayNames
JArray backendIds = new JArray();
var propertyRegex = new Regex("backend-id=\"({{(.*?)}}|.*?)\"");
foreach (var policy in policies)
{
var policyO = JObject.Parse(policy?.ToString());
var policyString = policyO["properties"]["value"]?.ToString();
var matches = propertyRegex.Matches(policyString);
foreach (Match match in matches)
{
string value = match.Groups[1].Value;
// Handle Named Value
if (value.StartsWith("{{"))
{
var nvExtractor = new PropertyExtractor();
// Get NamedValue without braces
value = match.Groups[2].Value;
var property = await nvExtractor.GetPropertyByDisplayName(ApiManagementName, ResourceGroupName, value);
var propertyO = JObject.Parse(property);
var backendId = propertyO["value"][0]["properties"]["value"]?.ToString();
backendIds.Add(backendId);
}
else
{
backendIds.Add(value);
}
}
}
var backends = new JObject();
backends["value"] = new JArray();
foreach (var backendId in backendIds)
{
var backend = await GetBackendDetailsAsync(ApiManagementName, ResourceGroupName, backendId?.ToString());
var backendO = JObject.Parse(backend);
((JArray)backends["value"]).Add(backendO);
}
backends["count"] = ((JArray)backends["value"]).Count;
return(backends.ToString());
}
}
public async Task <Template> GenerateBackendsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, List <TemplateResource> propertyResources, string policyXMLBaseUrl, string policyXMLSasToken)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting backends from service");
Template armTemplate = GenerateEmptyTemplateWithParameters(policyXMLBaseUrl, policyXMLSasToken);
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
string backends = await GetBackendsAsync(apimname, resourceGroup, singleApiName);
JObject 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;
if (singleApiName != null)
{
// Extract Properties
JArray namedValues = new JArray();
var propertyRegex = new Regex("{{(.*?)}}");
var matches = propertyRegex.Matches(item?.ToString());
foreach (Match match in matches)
{
var propertyName = match.Groups[1].Value;
var propertyExtractor = new PropertyExtractor();
var fullPropertyResource = await propertyExtractor.GetPropertyDetailsAsync(apimname, resourceGroup, propertyName);
PropertyTemplateResource propertyTemplateResource = propertyExtractor.GetPropertyTemplateResource(propertyName, fullPropertyResource);
propertyResources.Add(propertyTemplateResource);
}
}
////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
// Console.WriteLine("'{0}' Backend found", backendName);
// templateResources.Add(backendTemplateResource);
//}
//else
//{
// bool isReferencedInPolicy = false;
// foreach (PolicyTemplateResource policyTemplateResource in policyResources)
// {
// // the backend is used in a policy if the xml contains a set-backend-service policy, which will reference the backend's url or id
// string policyContent = policyTemplateResource.properties.policyContent;
// isReferencedInPolicy = DoesPolicyReferenceBackend(policyContent, namedValueResources, backendName, backendTemplateResource);
// }
// if (isReferencedInPolicy == true)
// {
// // backend was used in policy, extract it
// Console.WriteLine("'{0}' Backend found", backendName);
// templateResources.Add(backendTemplateResource);
// }
//}
Console.WriteLine("'{0}' Backend found", backendName);
templateResources.Add(backendTemplateResource);
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
public ExtractCommand()
{
this.Name = GlobalConstants.ExtractName;
this.Description = GlobalConstants.ExtractDescription;
var apiManagementName = this.Option("--name <apimname>", "API Management name", CommandOptionType.SingleValue);
var resourceGroupName = this.Option("--resourceGroup <resourceGroup>", "Resource Group name", CommandOptionType.SingleValue);
var fileFolderName = this.Option("--fileFolder <filefolder>", "ARM Template files folder", CommandOptionType.SingleValue);
var apiName = this.Option("--apiName <apiName>", "API name", CommandOptionType.SingleValue);
this.HelpOption();
this.OnExecute(async() =>
{
if (!apiManagementName.HasValue())
{
throw new Exception("Missing parameter <apimname>.");
}
if (!resourceGroupName.HasValue())
{
throw new Exception("Missing parameter <resourceGroup>.");
}
if (!fileFolderName.HasValue())
{
throw new Exception("Missing parameter <filefolder>.");
}
// isolate cli parameters
string resourceGroup = resourceGroupName.Values[0].ToString();
string apimname = apiManagementName.Values[0].ToString();
string fileFolder = fileFolderName.Values[0].ToString();
string singleApiName = null;
if (apiName.Values.Count > 0)
{
singleApiName = apiName.Values[0].ToString();
}
Console.WriteLine("API Management Template");
Console.WriteLine();
Console.WriteLine("Connecting to {0} API Management Service on {1} Resource Group ...", apimname, resourceGroup);
if (singleApiName != null)
{
Console.WriteLine("Executing extraction for {0} API ...", singleApiName);
}
else
{
Console.WriteLine("Executing full extraction ...", singleApiName);
}
// initialize entity extractor classes
FileWriter fileWriter = new FileWriter();
APIExtractor apiExtractor = new APIExtractor();
APIVersionSetExtractor apiVersionSetExtractor = new APIVersionSetExtractor();
AuthorizationServerExtractor authorizationServerExtractor = new AuthorizationServerExtractor();
BackendExtractor backendExtractor = new BackendExtractor();
LoggerExtractor loggerExtractor = new LoggerExtractor();
PropertyExtractor propertyExtractor = new PropertyExtractor();
ProductExtractor productExtractor = new ProductExtractor();
// extract templates from apim service
Template apiTemplate = await apiExtractor.GenerateAPIsARMTemplate(apimname, resourceGroup, fileFolder, singleApiName);
List <TemplateResource> apiTemplateResources = apiTemplate.resources.ToList();
Template apiVersionSetTemplate = await apiVersionSetExtractor.GenerateAPIVersionSetsARMTemplate(apimname, resourceGroup, singleApiName, apiTemplateResources);
Template authorizationTemplate = await authorizationServerExtractor.GenerateAuthorizationServersARMTemplate(apimname, resourceGroup, singleApiName, apiTemplateResources);
Template loggerTemplate = await loggerExtractor.GenerateLoggerTemplate(apimname, resourceGroup, singleApiName, apiTemplateResources);
Template productTemplate = await productExtractor.GenerateProductsARMTemplate(apimname, resourceGroup, singleApiName, apiTemplateResources);
Template namedValueTemplate = await propertyExtractor.GenerateNamedValuesTemplate(apimname, resourceGroup, singleApiName, apiTemplateResources);
List <TemplateResource> namedValueResources = namedValueTemplate.resources.ToList();
Template backendTemplate = await backendExtractor.GenerateBackendsARMTemplate(apimname, resourceGroup, singleApiName, apiTemplateResources, namedValueResources);
// write templates to output file location
string apiFileName = singleApiName == null ? @fileFolder + Path.DirectorySeparatorChar + apimname + "-apis-template.json" : @fileFolder + Path.DirectorySeparatorChar + apimname + "-" + singleApiName + "-api-template.json";
fileWriter.WriteJSONToFile(apiTemplate, apiFileName);
fileWriter.WriteJSONToFile(apiVersionSetTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-apiVersionSets.json");
fileWriter.WriteJSONToFile(authorizationTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-authorizationServers.json");
fileWriter.WriteJSONToFile(backendTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-backends.json");
fileWriter.WriteJSONToFile(loggerTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-loggers.json");
fileWriter.WriteJSONToFile(namedValueTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-namedValues.json");
fileWriter.WriteJSONToFile(productTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-products.json");
Console.WriteLine("Templates written to output location");
Console.WriteLine("Press any key to exit process:");
#if DEBUG
Console.ReadKey();
#endif
});
}
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);
}
/* 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));
}
private async void GenerateLoggerTemplate(string resourceGroup, string apimname, string fileFolder)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Geting loggers from service");
LoggerExtractor loggerExtractor = new LoggerExtractor();
PropertyExtractor propertyExtractor = new PropertyExtractor();
Template armTemplate = new Template()
{
schema = "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
contentVersion = "1.0.0.0",
parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
},
variables = { },
resources = { },
outputs = { }
};
List <TemplateResource> templateResources = new List <TemplateResource>();
// pull named values for later credential reference
string properties = propertyExtractor.GetProperties(apimname, resourceGroup).Result;
JObject oProperties = JObject.Parse(properties);
List <PropertyTemplateResource> propertyResources = oProperties["value"].ToObject <List <PropertyTemplateResource> >();
string loggers = loggerExtractor.GetLoggers(apimname, resourceGroup).Result;
JObject oLoggers = JObject.Parse(loggers);
foreach (var extractedLogger in oLoggers["value"])
{
string loggerName = ((JValue)extractedLogger["name"]).Value.ToString();
Console.WriteLine("'{0}' Logger found", loggerName);
string fullLoggerResource = await loggerExtractor.GetLogger(apimname, resourceGroup, loggerName);
LoggerTemplateResource loggerResource = JsonConvert.DeserializeObject <LoggerTemplateResource>(fullLoggerResource);
loggerResource.name = $"[concat(parameters('ApimServiceName'), '/{loggerName}')]";
loggerResource.type = "Microsoft.ApiManagement/service/loggers";
loggerResource.apiVersion = "2018-06-01-preview";
loggerResource.scale = null;
// swap credentials for their hidden values, taken from named values
if (loggerResource.properties.credentials != null)
{
if (loggerResource.properties.credentials.instrumentationKey != null)
{
string hiddenKey = loggerResource.properties.credentials.instrumentationKey.Substring(2, loggerResource.properties.credentials.instrumentationKey.Length - 4);
loggerResource.properties.credentials.instrumentationKey = propertyResources.Find(p => p.properties.displayName == hiddenKey).properties.value;
}
else if (loggerResource.properties.credentials.connectionString != null)
{
string hiddenKey = loggerResource.properties.credentials.connectionString.Substring(2, loggerResource.properties.credentials.connectionString.Length - 4);
loggerResource.properties.credentials.connectionString = propertyResources.Find(p => p.properties.displayName == hiddenKey).properties.value;
}
}
templateResources.Add(loggerResource);
}
armTemplate.resources = templateResources.ToArray();
FileWriter fileWriter = new FileWriter();
string filePath = fileFolder + Path.DirectorySeparatorChar + string.Format("loggers", "/", "-") + ".json";
fileWriter.WriteJSONToFile(armTemplate, filePath);
}
