public static string GetPolicyContent(Extractor exc, PolicyTemplateResource policyTemplateResource)
{
// 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.value;
// check if this is a file or is it the raw policy content
if (policyContent.Contains(".xml"))
{
var key = policyContent;
//check cache
if (_policyCache.TryGetValue(key, out string content))
{
return(content);
}
var filename = policyContent.Split(',')[1].Replace("'", string.Empty).Trim();
var policyFolder = $@"{exc.fileFolder}/policies";
var filepath = $@"{Directory.GetCurrentDirectory()}/{policyFolder}/{filename}";
if (File.Exists(filepath))
{
policyContent = File.ReadAllText(filepath);
_policyCache.Set(key, policyContent);
}
}
return(policyContent);
}
public List <TemplateResource> CreateChildResourceTemplates(APIConfig api)
{
List <TemplateResource> resources = new List <TemplateResource>();
// all child resources will depend on the api
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{api.name}')]" };
PolicyTemplateResource apiPolicyResource = api.policy != null?this.policyTemplateCreator.CreateAPIPolicyTemplateResource(api, dependsOn) : null;
List <PolicyTemplateResource> operationPolicyResources = api.operations != null?this.policyTemplateCreator.CreateOperationPolicyTemplateResources(api, dependsOn) : null;
List <ProductAPITemplateResource> productAPIResources = api.products != null?this.productAPITemplateCreator.CreateProductAPITemplateResources(api, dependsOn) : null;
DiagnosticTemplateResource diagnosticTemplateResource = api.diagnostic != null?this.diagnosticTemplateCreator.CreateAPIDiagnosticTemplateResource(api, dependsOn) : null;
// add resources if not null
if (apiPolicyResource != null)
{
resources.Add(apiPolicyResource);
}
if (operationPolicyResources != null)
{
resources.AddRange(operationPolicyResources);
}
if (productAPIResources != null)
{
resources.AddRange(productAPIResources);
}
if (diagnosticTemplateResource != null)
{
resources.Add(diagnosticTemplateResource);
}
return(resources);
}
public void ShouldCreateAPIPolicyTemplateResourceFromCreatorConfigWithCorrectContent()
{
// arrange
PolicyTemplateCreator policyTemplateCreator = PolicyTemplateCreatorFactory.GeneratePolicyTemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
apis = new List <APIConfig>()
};
APIConfig api = new APIConfig()
{
name = "name",
policy = "http://someurl.com"
};
creatorConfig.apis.Add(api);
string[] dependsOn = new string[] { "dependsOn" };
// act
PolicyTemplateResource policyTemplateResource = policyTemplateCreator.CreateAPIPolicyTemplateResource(api, dependsOn);
// assert
Assert.Equal($"[concat(parameters('apimServiceName'), '/{api.name}/policy')]", policyTemplateResource.name);
Assert.Equal("rawxml-link", policyTemplateResource.properties.format);
Assert.Equal(api.policy, policyTemplateResource.properties.value);
Assert.Equal(dependsOn, policyTemplateResource.dependsOn);
}
public async Task <Template> Create(DeploymentDefinition creatorConfig)
{
var template = EmptyTemplate;
template.Parameters.Add(ApiServiceNameParameter.Key, ApiServiceNameParameter.Value);
var fileReader = new FileReader();
var policy = creatorConfig.Policy;
var isUrl = policy.IsUri(out _);
var policyTemplateResource = new PolicyTemplateResource()
{
Name = $"[concat(parameters('ApimServiceName'), '/policy')]",
Properties = new PolicyProperties()
{
Format = isUrl ? "rawxml-link" : "rawxml",
Value = isUrl ? policy : await fileReader.RetrieveFileContentsAsync(policy)
},
DependsOn = new string[0]
};
template.Resources = new TemplateResource[] { policyTemplateResource };
return(await Task.FromResult(template));
}
public PolicyTemplateResource CreateProductPolicyTemplateResource(ProductConfig product, string[] dependsOn)
{
if (string.IsNullOrEmpty(product.name))
{
product.name = product.displayName;
}
Uri uriResult;
bool isUrl = Uri.TryCreate(product.policy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.name}/policy')]",
type = ResourceTypeConstants.ProductPolicy,
apiVersion = GlobalConstants.APIVersion,
properties = new PolicyTemplateProperties()
{
// if policy is a url inline the url, if it is a local file inline the file contents
format = isUrl ? "rawxml-link" : "rawxml",
value = isUrl ? product.policy : this.fileReader.RetrieveLocalFileContents(product.policy)
},
dependsOn = dependsOn
};
return(policyTemplateResource);
}
public void ShouldCreateProductPolicyTemplateResourceFromCreatorConfigWithCorrectContent()
{
// arrange
PolicyTemplateCreator policyTemplateCreator = PolicyTemplateCreatorFactory.GeneratePolicyTemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
products = new List <ProductConfig>()
};
ProductConfig product = new ProductConfig()
{
displayName = "displayName",
description = "description",
terms = "terms",
subscriptionRequired = true,
approvalRequired = true,
subscriptionsLimit = 1,
state = "state",
policy = "http://someurl.com"
};
creatorConfig.products.Add(product);
string[] dependsOn = new string[] { "dependsOn" };
// act
PolicyTemplateResource policyTemplateResource = policyTemplateCreator.CreateProductPolicyTemplateResource(product, dependsOn);
// assert
Assert.Equal($"[concat(parameters('apimServiceName'), '/{product.displayName}/policy')]", policyTemplateResource.name);
Assert.Equal("rawxml-link", policyTemplateResource.properties.format);
Assert.Equal(product.policy, policyTemplateResource.properties.value);
Assert.Equal(dependsOn, policyTemplateResource.dependsOn);
}
public Template CreateProductTemplate(CreatorConfig creatorConfig)
{
// create empty template
Template productTemplate = CreateEmptyTemplate();
// add parameters
productTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
foreach (ProductConfig product in creatorConfig.products)
{
// create product resource with properties
ProductsTemplateResource productsTemplateResource = new ProductsTemplateResource()
{
name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.displayName}')]",
type = ResourceTypeConstants.Product,
apiVersion = GlobalConstants.APIVersion,
properties = new ProductsTemplateProperties()
{
description = product.description,
terms = product.terms,
subscriptionRequired = product.subscriptionRequired,
approvalRequired = product.subscriptionRequired ? product.approvalRequired : null,
subscriptionsLimit = product.subscriptionRequired ? product.subscriptionsLimit : null,
state = product.state,
displayName = product.displayName
},
dependsOn = new string[] { }
};
resources.Add(productsTemplateResource);
// create product policy resource that depends on the product, if provided
if (product.policy != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.displayName}')]" };
PolicyTemplateResource productPolicy = this.policyTemplateCreator.CreateProductPolicyTemplateResource(product, dependsOn);
resources.Add(productPolicy);
}
// create product group resources if provided
if (product.groups != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.displayName}')]" };
List <ProductGroupsValue> productGroups = this.productGroupTemplateCreator.CreateProductGroupTemplateResources(product, dependsOn);
resources.AddRange(productGroups);
}
}
productTemplate.resources = resources.ToArray();
return(productTemplate);
}
public Template CreateSubsequentAPITemplate(CreatorConfig creatorConfig)
{
// create empty template
Template apiTemplate = this.templateCreator.CreateEmptyTemplate();
// add parameters
apiTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ "ApimServiceName", new TemplateParameterProperties()
{
type = "string"
} }
};
string apiName = creatorConfig.api.name;
string[] dependsOnSubsequentAPI = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
List <TemplateResource> resources = new List <TemplateResource>();
// create api resource w/ swagger content and policies
APITemplateResource subsequentAPITemplateResource = this.CreateSubsequentAPITemplateResource(creatorConfig);
PolicyTemplateResource apiPolicyResource = creatorConfig.api.policy != null?this.policyTemplateCreator.CreateAPIPolicyTemplateResource(creatorConfig, dependsOnSubsequentAPI) : null;
List <PolicyTemplateResource> operationPolicyResources = creatorConfig.api.operations != null?this.policyTemplateCreator.CreateOperationPolicyTemplateResources(creatorConfig, dependsOnSubsequentAPI) : null;
List <ProductAPITemplateResource> productAPIResources = creatorConfig.api.products != null?this.productAPITemplateCreator.CreateProductAPITemplateResources(creatorConfig, dependsOnSubsequentAPI) : null;
DiagnosticTemplateResource diagnosticTemplateResource = creatorConfig.api.diagnostic != null?this.diagnosticTemplateCreator.CreateAPIDiagnosticTemplateResource(creatorConfig, dependsOnSubsequentAPI) : null;
resources.Add(subsequentAPITemplateResource);
// add resources if not null
if (apiPolicyResource != null)
{
resources.Add(apiPolicyResource);
}
if (operationPolicyResources != null)
{
resources.AddRange(operationPolicyResources);
}
if (productAPIResources != null)
{
resources.AddRange(productAPIResources);
}
if (diagnosticTemplateResource != null)
{
resources.Add(diagnosticTemplateResource);
}
apiTemplate.resources = resources.ToArray();
return(apiTemplate);
}
async Task SavePolicyXmlAsync(
PolicyTemplateResource policyTemplateResource,
string baseFilesDirectory,
string policyFileName)
{
string policyXMLContent = policyTemplateResource.Properties.PolicyContent;
var policiesDirectory = Path.Combine(baseFilesDirectory, PoliciesDirectoryName);
// creating <files-root>/policies
FileWriter.CreateFolderIfNotExists(policiesDirectory);
// writing <files-root>/policies/<policyFileName>.xml
await FileWriter.SaveTextToFileAsync(policyXMLContent, policiesDirectory, policyFileName);
}
void SetPolicyTemplateResourcePolicyContentWithArmPresetValues(
ExtractorParameters extractorParameters,
PolicyTemplateResource policyTemplate,
string policyFileName)
{
policyTemplate.Properties.Format = "rawxml-link";
if (extractorParameters.PolicyXMLSasToken != null)
{
policyTemplate.Properties.PolicyContent = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{policyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]";
}
else
{
policyTemplate.Properties.PolicyContent = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{policyFileName}')]";
}
}
public List <TemplateResource> CreateChildResourceTemplates(APIConfig api)
{
List <TemplateResource> resources = new List <TemplateResource>();
// all child resources will depend on the api
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('{ParameterNames.ApimServiceName}'), '{api.name}')]" };
PolicyTemplateResource apiPolicyResource = api.policy != null?this.policyTemplateCreator.CreateAPIPolicyTemplateResource(api, dependsOn) : null;
List <PolicyTemplateResource> operationPolicyResources = api.operations != null?this.policyTemplateCreator.CreateOperationPolicyTemplateResources(api, dependsOn) : null;
List <ProductAPITemplateResource> productAPIResources = api.products != null?this.productAPITemplateCreator.CreateProductAPITemplateResources(api, dependsOn) : null;
List <TagAPITemplateResource> tagAPIResources = api.tags != null?this.tagAPITemplateCreator.CreateTagAPITemplateResources(api, dependsOn) : null;
DiagnosticTemplateResource diagnosticTemplateResource = api.diagnostic != null?this.diagnosticTemplateCreator.CreateAPIDiagnosticTemplateResource(api, dependsOn) : null;
// add release resource if the name has been appended with ;rev{revisionNumber}
ReleaseTemplateResource releaseTemplateResource = api.name.Contains(";rev") == true?this.releaseTemplateCreator.CreateAPIReleaseTemplateResource(api, dependsOn) : null;
// add resources if not null
if (apiPolicyResource != null)
{
resources.Add(apiPolicyResource);
}
if (operationPolicyResources != null)
{
resources.AddRange(operationPolicyResources);
}
if (productAPIResources != null)
{
resources.AddRange(productAPIResources);
}
if (tagAPIResources != null)
{
resources.AddRange(tagAPIResources);
}
if (diagnosticTemplateResource != null)
{
resources.Add(diagnosticTemplateResource);
}
if (releaseTemplateResource != null)
{
resources.Add(releaseTemplateResource);
}
return(resources);
}
public async Task <Template> GenerateGlobalServicePolicyTemplateAsync(string apimname, string resourceGroup, string policyXMLBaseUrl, string policyXMLSasToken, string fileFolder)
{
// extract global service policy in both full and single api extraction cases
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting global service policy from service");
Template armTemplate = GenerateEmptyTemplateWithParameters(policyXMLBaseUrl, policyXMLSasToken);
List <TemplateResource> templateResources = new List <TemplateResource>();
// add global service policy resource to template
try
{
string globalServicePolicy = await GetGlobalServicePolicyAsync(apimname, resourceGroup);
Console.WriteLine($" - Global policy found for {apimname} API Management service");
PolicyTemplateResource globalServicePolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(globalServicePolicy);
// REST API will return format property as rawxml and value property as the xml by default
globalServicePolicyResource.name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/policy')]";
globalServicePolicyResource.apiVersion = GlobalConstants.APIVersion;
globalServicePolicyResource.scale = null;
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (policyXMLBaseUrl != null)
{
string policyXMLContent = globalServicePolicyResource.properties.value;
string policyFolder = String.Concat(fileFolder, $@"/policies");
string globalServicePolicyFileName = $@"/globalServicePolicy.xml";
this.fileWriter.CreateFolderIfNotExists(policyFolder);
this.fileWriter.WriteXMLToFile(policyXMLContent, String.Concat(policyFolder, globalServicePolicyFileName));
globalServicePolicyResource.properties.format = "rawxml-link";
if (policyXMLSasToken != null)
{
globalServicePolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{globalServicePolicyFileName}', parameters('{ParameterNames.PolicyXMLSasToken}'))]";
}
else
{
globalServicePolicyResource.properties.value = $"[concat(parameters('{ParameterNames.PolicyXMLBaseUrl}'), '{globalServicePolicyFileName}')]";
}
}
templateResources.Add(globalServicePolicyResource);
}
catch (Exception) { }
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
public void ShouldCreateGlobalServicePolicyTemplateResourceFromCreatorConfigWithCorrectContent()
{
// arrange
PolicyTemplateCreator policyTemplateCreator = PolicyTemplateCreatorFactory.GeneratePolicyTemplateCreator();
CreatorConfig creatorConfig = new CreatorConfig()
{
policy = "http://someurl.com"
};
// act
Template policyTemplate = policyTemplateCreator.CreateGlobalServicePolicyTemplate(creatorConfig);
PolicyTemplateResource policyTemplateResource = policyTemplate.resources[0] as PolicyTemplateResource;
// assert
Assert.Equal($"[concat(parameters('apimServiceName'), '/policy')]", policyTemplateResource.name);
Assert.Equal("rawxml-link", policyTemplateResource.properties.format);
Assert.Equal(creatorConfig.policy, policyTemplateResource.properties.value);
}
public string GetCachedPolicyContent(PolicyTemplateResource policyTemplateResource, string baseFilesGenerationDirectory)
{
if (policyTemplateResource?.Properties is null)
{
this.logger.LogWarning("Policy was not initialized correctly {0}", policyTemplateResource.Name);
return(string.Empty);
}
// easy code flow, if we already have a policy-content-file-full-path to use as a key for policy content caches
if (!string.IsNullOrEmpty(policyTemplateResource.Properties.PolicyContentFileFullPath))
{
if (this.policyPathToContentCache.ContainsKey(policyTemplateResource.Properties.PolicyContentFileFullPath))
{
return(this.policyPathToContentCache[policyTemplateResource.Properties.PolicyContentFileFullPath]);
}
else
{
this.logger.LogWarning("Policy content at '{0}' was initialized, but wasn't cached properly", policyTemplateResource.Properties.PolicyContentFileFullPath);
}
}
// if no path found already, trying to get one from policy content
// check if this is a file or is it the raw policy content
var policyContent = policyTemplateResource?.Properties?.PolicyContent ?? string.Empty;
if (policyContent.Contains(".xml"))
{
var fileNameSection = policyContent.Split(',')[1];
var policyFileName = ParameterNamingHelper.GetSubstringBetweenTwoCharacters('\'', '\'', fileNameSection);
var policyFileFullPath = Path.Combine(baseFilesGenerationDirectory, PoliciesDirectoryName, policyFileName);
if (File.Exists(policyFileFullPath))
{
var policyContentFromFile = File.ReadAllText(policyFileFullPath);
policyTemplateResource.Properties.PolicyContentFileFullPath = policyFileFullPath;
this.policyPathToContentCache[policyFileFullPath] = policyContentFromFile;
return(policyContentFromFile);
}
}
return(policyContent);
}
public PolicyTemplateResource CreateAPIPolicyTemplateResource(APIConfig api, string[] dependsOn)
{
Uri uriResult;
bool isUrl = Uri.TryCreate(api.policy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{api.name}/policy')]",
type = ResourceTypeConstants.APIPolicy,
apiVersion = "2018-06-01-preview",
properties = new PolicyTemplateProperties()
{
contentFormat = isUrl ? "rawxml-link" : "rawxml",
policyContent = isUrl ? api.policy : this.fileReader.RetrieveLocalFileContents(api.policy)
},
dependsOn = dependsOn
};
return(policyTemplateResource);
}
public PolicyTemplateResource CreateAPIPolicyTemplateResource(CreatorConfig creatorConfig, string[] dependsOn)
{
Uri uriResult;
bool isUrl = Uri.TryCreate(creatorConfig.api.policy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{creatorConfig.api.name}/policy')]",
type = "Microsoft.ApiManagement/service/apis/policies",
apiVersion = "2018-01-01",
properties = new PolicyTemplateProperties()
{
contentFormat = isUrl ? "rawxml-link" : "rawxml",
policyContent = isUrl ? creatorConfig.api.policy : this.fileReader.RetrieveLocalFileContents(creatorConfig.api.policy)
},
dependsOn = dependsOn
};
return(policyTemplateResource);
}
public PolicyTemplateResource CreateOperationPolicyTemplateResource(KeyValuePair <string, OperationsConfig> policyPair, string apiName, string[] dependsOn)
{
Uri uriResult;
bool isUrl = Uri.TryCreate(policyPair.Value.policy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
name = $"[concat(parameters('ApimServiceName'), '/{apiName}/{policyPair.Key}/policy')]",
type = "Microsoft.ApiManagement/service/apis/operations/policies",
apiVersion = "2018-06-01-preview",
properties = new PolicyTemplateProperties()
{
contentFormat = isUrl ? "rawxml-link" : "rawxml",
policyContent = isUrl ? policyPair.Value.policy : this.fileReader.RetrieveLocalFileContents(policyPair.Value.policy)
},
dependsOn = dependsOn
};
return(policyTemplateResource);
}
public PolicyTemplateResource CreateAPIPolicyTemplateResource(APIConfig api, string[] dependsOn)
{
Uri uriResult;
bool isUrl = Uri.TryCreate(api.policy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{api.name}/policy')]",
Type = ResourceTypeConstants.APIPolicy,
ApiVersion = GlobalConstants.ApiVersion,
Properties = new PolicyTemplateProperties()
{
// if policy is a url inline the url, if it is a local file inline the file contents
Format = isUrl ? "rawxml-link" : "rawxml",
PolicyContent = isUrl ? api.policy : this.fileReader.RetrieveLocalFileContents(api.policy)
},
DependsOn = dependsOn
};
return(policyTemplateResource);
}
public PolicyTemplateResource CreateOperationPolicyTemplateResource(KeyValuePair <string, OperationsConfig> policyPair, string apiName, string[] dependsOn)
{
Uri uriResult;
bool isUrl = Uri.TryCreate(policyPair.Value.policy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{apiName}/{policyPair.Key}/policy')]",
type = ResourceTypeConstants.APIOperationPolicy,
apiVersion = GlobalConstants.APIVersion,
properties = new PolicyTemplateProperties()
{
// if policy is a url inline the url, if it is a local file inline the file contents
format = isUrl ? "rawxml-link" : "rawxml",
value = isUrl ? policyPair.Value.policy : this.fileReader.RetrieveLocalFileContents(policyPair.Value.policy)
},
dependsOn = dependsOn
};
return(policyTemplateResource);
}
public void ShouldCreateOperationPolicyTemplateResourceFromPairWithCorrectContent()
{
// arrange
PolicyTemplateCreator policyTemplateCreator = PolicyTemplateCreatorFactory.GeneratePolicyTemplateCreator();
KeyValuePair <string, OperationsConfig> policyPair = new KeyValuePair <string, OperationsConfig>("key", new OperationsConfig()
{
policy = "http://someurl.com"
});
string apiName = "apiName";
string[] dependsOn = new string[] { "dependsOn" };
// act
PolicyTemplateResource policyTemplateResource = policyTemplateCreator.CreateOperationPolicyTemplateResource(policyPair, apiName, dependsOn);
// assert
Assert.Equal($"[concat(parameters('apimServiceName'), '/{apiName}/{policyPair.Key}/policy')]", policyTemplateResource.name);
Assert.Equal("rawxml-link", policyTemplateResource.properties.format);
Assert.Equal(policyPair.Value.policy, policyTemplateResource.properties.value);
Assert.Equal(dependsOn, policyTemplateResource.dependsOn);
}
public Template CreateGlobalServicePolicyTemplate(CreatorConfig creatorConfig)
{
// create empty template
Template policyTemplate = CreateEmptyTemplate();
// add parameters
policyTemplate.parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
// create global service policy resource with properties
string globalServicePolicy = creatorConfig.policy;
Uri uriResult;
bool isUrl = Uri.TryCreate(globalServicePolicy, UriKind.Absolute, out uriResult) && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
// create policy resource with properties
PolicyTemplateResource policyTemplateResource = new PolicyTemplateResource()
{
name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/policy')]",
type = ResourceTypeConstants.GlobalServicePolicy,
apiVersion = GlobalConstants.APIVersion,
properties = new PolicyTemplateProperties()
{
// if policy is a url inline the url, if it is a local file inline the file contents
format = isUrl ? "rawxml-link" : "rawxml",
value = isUrl ? globalServicePolicy : this.fileReader.RetrieveLocalFileContents(globalServicePolicy)
},
dependsOn = new string[] { }
};
resources.Add(policyTemplateResource);
policyTemplate.resources = resources.ToArray();
return(policyTemplate);
}
async Task SavePolicyXmlAsync(
PolicyTemplateResource policyTemplateResource,
string baseFilesDirectory,
string policyFileName)
{
var policiesDirectory = Path.Combine(baseFilesDirectory, PoliciesDirectoryName);
var fullPolicyPathWithName = Path.Combine(policiesDirectory, policyFileName);
FileWriter.CreateFolderIfNotExists(policiesDirectory); // creating <files-root>/policies
var policyXMLContent = policyTemplateResource.Properties.PolicyContent;
if (this.policyPathToContentCache.ContainsKey(fullPolicyPathWithName))
{
this.logger.LogError("Policy content already exists in {0} and will be overwritten!", fullPolicyPathWithName);
}
// saving to cache + saving path for easily extraction
this.policyPathToContentCache[fullPolicyPathWithName] = policyXMLContent;
policyTemplateResource.Properties.PolicyContentFileFullPath = fullPolicyPathWithName;
// writing <files-root>/policies/<policyFileName>.xml
await FileWriter.SaveTextToFileAsync(policyXMLContent, fullPolicyPathWithName);
}
// this function will get the current revision of this api and will remove "isCurrent" paramter
public async Task <List <TemplateResource> > GenerateCurrentRevisionAPIResourceAsync(string apiName, string apimname, string resourceGroup, string fileFolder, string policyXMLBaseUrl, string policyXMLSasToken)
{
List <TemplateResource> templateResources = new List <TemplateResource>();
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('ApimServiceName'), '/{apiName}')]";
apiResource.apiVersion = GlobalConstants.APIVersion;
apiResource.scale = null;
apiResource.properties.isCurrent = null;
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('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('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('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('ApimServiceName'), '/{apiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = GlobalConstants.APIVersion;
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('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 = $@"/{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('PolicyXMLBaseUrl'), '{operationPolicyFileName}', parameters('PolicyXMLSasToken'))]";
}
else
{
operationPolicyResource.properties.value = $"[concat(parameters('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('ApimServiceName'), '/{apiName}/{operationResourceName}/{apiOperationTagName}')]";
operationTagResource.apiVersion = GlobalConstants.APIVersion;
operationTagResource.scale = null;
operationTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('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('ApimServiceName'), '/{apiName}/{apiPoliciesResource.name}')]";
apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('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('PolicyXMLBaseUrl'), '{apiPolicyFileName}', parameters('PolicyXMLSasToken'))]";
}
else
{
apiPoliciesResource.properties.value = $"[concat(parameters('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('ApimServiceName'), '/{apiName}/{apiTagName}')]";
apiTagResource.apiVersion = GlobalConstants.APIVersion;
apiTagResource.scale = null;
apiTagResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('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('ApimServiceName'), '/{apiProductName}/{apiName}')]";
productAPIResource.apiVersion = GlobalConstants.APIVersion;
productAPIResource.scale = null;
productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('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('ApimServiceName'), '/{apiName}/{diagnosticName}')]";
diagnosticResource.type = ResourceTypeConstants.APIDiagnostic;
diagnosticResource.apiVersion = GlobalConstants.APIVersion;
diagnosticResource.scale = null;
diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
if (!diagnosticName.Contains("applicationinsights"))
{
// enableHttpCorrelationHeaders only works for application insights, causes errors otherwise
diagnosticResource.properties.enableHttpCorrelationHeaders = null;
}
templateResources.Add(diagnosticResource);
}
#endregion
return(templateResources);
}
public async Task <Template> GenerateAPIsARMTemplate(string apimname, string resourceGroup, string fileFolder, string singleApiName)
{
// pull all apis from service
string apis = await GetAPIs(apimname, resourceGroup);
// initialize arm template
Template armTemplate = GenerateEmptyTemplateWithParameters();
JObject oApi = JObject.Parse(apis);
oApi = FormatoApi(singleApiName, oApi);
Console.WriteLine("{0} API's found ...", ((JContainer)oApi["value"]).Count.ToString());
List <TemplateResource> templateResources = new List <TemplateResource>();
for (int i = 0; i < ((JContainer)oApi["value"]).Count; i++)
{
string apiName = ((JValue)oApi["value"][i]["name"]).Value.ToString();
string apiDetails = await GetAPIDetails(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);
string oApiName = ((JValue)oApiDetails["name"]).Value.ToString();
apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString();
apiResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}')]";
apiResource.apiVersion = GlobalConstants.APIVersion;
apiResource.scale = null;
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('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 operations = await GetAPIOperations(apimname, resourceGroup, apiName);
JObject oOperations = JObject.Parse(operations);
foreach (var item in oOperations["value"])
{
string operationName = ((JValue)item["name"]).Value.ToString();
string operationDetails = await GetAPIOperationDetail(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('ApimServiceName'), '/{oApiName}/{operationResourceName}')]";
operationResource.apiVersion = GlobalConstants.APIVersion;
operationResource.scale = null;
// add api and schemas to operation dependsOn, if necessary
List <string> operationDependsOn = new List <string>()
{
$"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]"
};
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationResource.properties.request.representations)
{
if (operationTemplateRepresentation.schemaId != null)
{
string dependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/schemas', parameters('ApimServiceName'), '{oApiName}', '{operationTemplateRepresentation.schemaId}')]";
// add value to list if schema has not already been added
if (!operationDependsOn.Exists(o => o == dependsOn))
{
operationDependsOn.Add(dependsOn);
}
}
}
foreach (OperationsTemplateResponse operationTemplateResponse in operationResource.properties.responses)
{
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationTemplateResponse.representations)
{
if (operationTemplateRepresentation.schemaId != null)
{
string dependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/schemas', parameters('ApimServiceName'), '{oApiName}', '{operationTemplateRepresentation.schemaId}')]";
// add value to list if schema has not already been added
if (!operationDependsOn.Exists(o => o == dependsOn))
{
operationDependsOn.Add(dependsOn);
}
}
}
}
operationResource.dependsOn = operationDependsOn.ToArray();
templateResources.Add(operationResource);
// add operation policy resource to api template
try
{
string operationPolicy = await GetOperationPolicy(apimname, resourceGroup, oApiName, operationName);
Console.WriteLine($" - Operation policy found for {operationName} operation");
PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy);
operationPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = GlobalConstants.APIVersion;
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{oApiName}', '{operationResourceName}')]" };
templateResources.Add(operationPolicyResource);
}
catch (Exception) { }
}
#endregion
#region API Policies
// add api policy resource to api template
try
{
string apiPolicies = await GetAPIPolicies(apimname, resourceGroup, apiName);
Console.WriteLine("API policy found");
PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies);
apiPoliciesResource.apiVersion = GlobalConstants.APIVersion;
apiPoliciesResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{apiPoliciesResource.name}')]";
apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
templateResources.Add(apiPoliciesResource);
}
catch (Exception) { }
#endregion
// add product api associations to template
#region API Products
try
{
// pull product api associations
string apiProducts = await GetAPIProducts(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>(apiProducts);
productAPIResource.type = ResourceTypeConstants.ProductAPI;
productAPIResource.name = $"[concat(parameters('ApimServiceName'), '/{apiProductName}/{oApiName}')]";
productAPIResource.apiVersion = GlobalConstants.APIVersion;
productAPIResource.scale = null;
productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
templateResources.Add(productAPIResource);
}
}
catch (Exception) { }
#endregion
#region Diagnostics
// add diagnostics to template
// pull diagnostics for api
string diagnostics = await GetAPIDiagnostics(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('ApimServiceName'), '/{oApiName}/{diagnosticName}')]";
diagnosticResource.type = ResourceTypeConstants.APIDiagnostic;
diagnosticResource.apiVersion = GlobalConstants.APIVersion;
diagnosticResource.scale = null;
diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
if (!diagnosticName.Contains("applicationinsights"))
{
// enableHttpCorrelationHeaders only works for application insights, causes errors otherwise
diagnosticResource.properties.enableHttpCorrelationHeaders = null;
}
templateResources.Add(diagnosticResource);
}
#endregion
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
private void GenerateARMTemplate(string apimname, string resourceGroup, string fileFolder, string singleApiName)
{
#region API's
FileWriter fileWriter;
APIExtractor apiExtractor = new APIExtractor();
string apis = apiExtractor.GetAPIs(apimname, resourceGroup).Result;
Template armTemplate = GenerateEmptyTemplateWithParameters();
JObject oApi = JObject.Parse(apis);
oApi = FormatoApi(singleApiName, oApi);
Console.WriteLine("{0} API's found ...", ((JContainer)oApi["value"]).Count.ToString());
List <TemplateResource> templateResources = new List <TemplateResource>();
for (int i = 0; i < ((JContainer)oApi["value"]).Count; i++)
{
string apiName = ((JValue)oApi["value"][i]["name"]).Value.ToString();
string apiDetails = apiExtractor.GetAPIDetails(apimname, resourceGroup, apiName).Result;
Console.WriteLine("------------------------------------------");
Console.WriteLine("Getting operations from {0} API:", apiName);
JObject oApiDetails = JObject.Parse(apiDetails);
APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails);
string oApiName = ((JValue)oApiDetails["name"]).Value.ToString();
apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString();
apiResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}')]";
apiResource.apiVersion = "2018-06-01-preview";
apiResource.scale = null;
if (apiResource.properties.apiVersionSetId != null)
{
apiResource.dependsOn = new string[] { };
string versionSetName = apiResource.properties.apiVersionSetId;
int versionSetPosition = versionSetName.IndexOf("api-version-sets/");
versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition));
apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('ApimServiceName')), '/{versionSetName}')]";
GenerateVersionSetARMTemplate(apimname, resourceGroup, versionSetName, fileFolder);
}
else
{
apiResource.dependsOn = new string[] { };
}
templateResources.Add(apiResource);
#region Schemas
List <TemplateResource> schemaResources = GenerateSchemasARMTemplate(apimname, apiName, resourceGroup, fileFolder);
templateResources.AddRange(schemaResources);
#endregion
#region Operations
string operations = apiExtractor.GetAPIOperations(apimname, resourceGroup, apiName).Result;
JObject oOperations = JObject.Parse(operations);
foreach (var item in oOperations["value"])
{
string operationName = ((JValue)item["name"]).Value.ToString();
string operationDetails = apiExtractor.GetAPIOperationDetail(apimname, resourceGroup, apiName, operationName).Result;
Console.WriteLine("'{0}' Operation found", operationName);
OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails);
string operationResourceName = operationResource.name;
operationResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}')]";
operationResource.apiVersion = "2018-06-01-preview";
operationResource.scale = null;
// depend on api and schemas if necessary
List <string> operationDependsOn = new List <string>()
{
$"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]"
};
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationResource.properties.request.representations)
{
if (operationTemplateRepresentation.schemaId != null)
{
string dependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/schemas', parameters('ApimServiceName'), '{oApiName}', '{operationTemplateRepresentation.schemaId}')]";
// add value to list if schema has not already been added
if (!operationDependsOn.Exists(o => o == dependsOn))
{
operationDependsOn.Add(dependsOn);
}
}
}
foreach (OperationsTemplateResponse operationTemplateResponse in operationResource.properties.responses)
{
foreach (OperationTemplateRepresentation operationTemplateRepresentation in operationTemplateResponse.representations)
{
if (operationTemplateRepresentation.schemaId != null)
{
string dependsOn = $"[resourceId('Microsoft.ApiManagement/service/apis/schemas', parameters('ApimServiceName'), '{oApiName}', '{operationTemplateRepresentation.schemaId}')]";
// add value to list if schema has not already been added
if (!operationDependsOn.Exists(o => o == dependsOn))
{
operationDependsOn.Add(dependsOn);
}
}
}
}
operationResource.dependsOn = operationDependsOn.ToArray();
templateResources.Add(operationResource);
try
{
string operationPolicy = apiExtractor.GetOperationPolicy(apimname, resourceGroup, oApiName, operationName).Result;
Console.WriteLine($" - Policy found to {operationName} operation");
PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy);
operationPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = "2018-06-01-preview";
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{oApiName}', '{operationResourceName}')]" };
templateResources.Add(operationPolicyResource);
}
catch (Exception)
{
Console.WriteLine($" - No policy found for {operationName} operation");
}
}
#endregion
#region API Policies
try
{
Console.WriteLine("Getting API Policy from {0} API: ", apiName);
string apiPolicies = apiExtractor.GetAPIPolicies(apimname, resourceGroup, apiName).Result;
Console.WriteLine("API Policy found!");
PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies);
apiPoliciesResource.apiVersion = "2018-06-01-preview";
apiPoliciesResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{apiPoliciesResource.name}')]";
apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
templateResources.Add(apiPoliciesResource);
}
catch (Exception)
{
Console.WriteLine("No API policy!");
}
#endregion
#region API Products
try
{
Console.WriteLine("Getting API Products from {0} API: ", apiName);
string apiProducts = apiExtractor.GetApiProducts(apimname, resourceGroup, apiName).Result;
JObject oApiProducts = JObject.Parse(apiProducts);
foreach (var item in oApiProducts["value"])
{
string apiProductName = ((JValue)item["name"]).Value.ToString();
Console.WriteLine($" -- {apiProductName} Product found to {oApiName} API");
ProductAPITemplateResource productAPIResource = JsonConvert.DeserializeObject <ProductAPITemplateResource>(apiProducts);
productAPIResource.type = ResourceTypeConstants.ProductAPI;
productAPIResource.name = $"[concat(parameters('ApimServiceName'), '/{apiProductName}/{oApiName}')]";
productAPIResource.apiVersion = "2018-06-01-preview";
productAPIResource.scale = null;
productAPIResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
templateResources.Add(productAPIResource);
}
}
catch (Exception)
{
Console.WriteLine("No API products!");
}
#endregion
#region Diagnostics
Console.WriteLine("------------------------------------------");
Console.WriteLine("Getting diagnostics from {0} API:", apiName);
string diagnostics = apiExtractor.GetAPIDiagnostics(apimname, resourceGroup, apiName).Result;
JObject oDiagnostics = JObject.Parse(diagnostics);
foreach (var diagnostic in oDiagnostics["value"])
{
string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString();
Console.WriteLine("'{0}' Diagnostic found", diagnosticName);
DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>();
diagnosticResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{diagnosticName}')]";
diagnosticResource.type = ResourceTypeConstants.APIDiagnostic;
diagnosticResource.apiVersion = "2018-06-01-preview";
diagnosticResource.scale = null;
diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
if (!diagnosticName.Contains("applicationinsights"))
{
// enableHttpCorrelationHeaders only works for application insights, causes errors otherwise
diagnosticResource.properties.enableHttpCorrelationHeaders = null;
}
templateResources.Add(diagnosticResource);
}
#endregion
armTemplate.resources = templateResources.ToArray();
if (singleApiName != null)
{
fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-" + oApiName + "-template.json");
}
}
// extract resources that do not fall under api. Pass in the single api name and associated resources for the single api case
GenerateProductsARMTemplate(apimname, resourceGroup, fileFolder, singleApiName, templateResources);
GenerateNamedValuesTemplate(resourceGroup, apimname, fileFolder, singleApiName, templateResources);
GenerateLoggerTemplate(resourceGroup, apimname, fileFolder, singleApiName, templateResources);
if (singleApiName == null)
{
fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-apis-template.json");
}
#endregion
}
public Template CreateProductTemplate(CreatorConfig creatorConfig)
{
// create empty template
Template productTemplate = this.templateBuilder.GenerateEmptyTemplate().Build();
// add parameters
productTemplate.Parameters = new Dictionary <string, TemplateParameterProperties>
{
{ ParameterNames.ApimServiceName, new TemplateParameterProperties()
{
Type = "string"
} }
};
List <TemplateResource> resources = new List <TemplateResource>();
foreach (ProductConfig product in creatorConfig.products)
{
if (string.IsNullOrEmpty(product.Name))
{
product.Name = product.DisplayName;
}
// create product resource with properties
ProductsTemplateResource productsTemplateResource = new ProductsTemplateResource()
{
Name = $"[concat(parameters('{ParameterNames.ApimServiceName}'), '/{product.Name}')]",
Type = ResourceTypeConstants.Product,
ApiVersion = GlobalConstants.ApiVersion,
Properties = new ProductsProperties()
{
Description = product.Description,
Terms = product.Terms,
SubscriptionRequired = product.SubscriptionRequired,
ApprovalRequired = product.SubscriptionRequired ? product.ApprovalRequired : null,
SubscriptionsLimit = product.SubscriptionRequired ? product.SubscriptionsLimit : null,
State = product.State,
DisplayName = product.DisplayName
},
DependsOn = new string[] { }
};
resources.Add(productsTemplateResource);
// create product policy resource that depends on the product, if provided
if (product.policy != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.Name}')]" };
PolicyTemplateResource productPolicy = this.policyTemplateCreator.CreateProductPolicyTemplateResource(product, dependsOn);
resources.Add(productPolicy);
}
// create product group resources if provided
if (product.groups != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.Name}')]" };
List <GroupTemplateResource> productGroups = this.productGroupTemplateCreator.CreateProductGroupTemplateResources(product, dependsOn);
resources.AddRange(productGroups);
}
// create product subscriptions if provided
if (product.subscriptions != null)
{
string[] dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('{ParameterNames.ApimServiceName}'), '{product.Name}')]" };
List <SubscriptionsTemplateResource> subscriptions = this.subscriptionTemplateCreator.CreateSubscriptionsTemplateResources(product, dependsOn);
resources.AddRange(subscriptions);
}
}
productTemplate.Resources = resources.ToArray();
return(productTemplate);
}
/// <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);
}
public async Task <Template> GenerateProductsARMTemplateAsync(string apimname, string resourceGroup, string singleApiName, List <TemplateResource> apiTemplateResources, string policyXMLBaseUrl, string fileFolder)
{
Console.WriteLine("------------------------------------------");
Console.WriteLine("Extracting products from service");
Template armTemplate = GenerateEmptyTemplateWithParameters(policyXMLBaseUrl);
// 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('ApimServiceName'), '/{productName}')]";
productsTemplateResource.apiVersion = GlobalConstants.APIVersion;
// 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
{
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('ApimServiceName'), '/{productName}/policy')]";
productPolicyResource.apiVersion = GlobalConstants.APIVersion;
productPolicyResource.scale = null;
productPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/products', parameters('ApimServiceName'), '{productName}')]" };
// write policy xml content to file and point to it if policyXMLBaseUrl is provided
if (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";
productPolicyResource.properties.value = $"[concat(parameters('PolicyXMLBaseUrl'), '{productPolicyFileName}')]";
}
templateResources.Add(productPolicyResource);
}
catch (Exception) { }
}
}
armTemplate.resources = templateResources.ToArray();
return(armTemplate);
}
private void GenerateARMTemplate(string apimname, string resourceGroup, string fileFolder, string singleApiName)
{
#region API's
FileWriter fileWriter;
APIExtractor apiExtractor = new APIExtractor();
string apis = apiExtractor.GetAPIs(apimname, resourceGroup).Result;
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 = { }
};
JObject oApi = JObject.Parse(apis);
oApi = FormatoApi(singleApiName, oApi);
Console.WriteLine("{0} API's found ...", ((JContainer)oApi["value"]).Count.ToString());
if (singleApiName == null)
{
GenerateLoggerTemplate(resourceGroup, apimname, fileFolder);
}
List <TemplateResource> templateResources = new List <TemplateResource>();
for (int i = 0; i < ((JContainer)oApi["value"]).Count; i++)
{
string apiName = ((JValue)oApi["value"][i]["name"]).Value.ToString();
string apiDetails = apiExtractor.GetAPIDetails(apimname, resourceGroup, apiName).Result;
Console.WriteLine("------------------------------------------");
Console.WriteLine("Geting operations from {0} API:", apiName);
JObject oApiDetails = JObject.Parse(apiDetails);
APITemplateResource apiResource = JsonConvert.DeserializeObject <APITemplateResource>(apiDetails);
string oApiName = ((JValue)oApiDetails["name"]).Value.ToString();
apiResource.type = ((JValue)oApiDetails["type"]).Value.ToString();
apiResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}')]";
apiResource.apiVersion = "2018-06-01-preview";
apiResource.scale = null;
if (apiResource.properties.apiVersionSetId != null)
{
apiResource.dependsOn = new string[] { };
string versionSetName = apiResource.properties.apiVersionSetId;
int versionSetPosition = versionSetName.IndexOf("api-version-sets/");
versionSetName = versionSetName.Substring(versionSetPosition, (versionSetName.Length - versionSetPosition));
apiResource.properties.apiVersionSetId = $"[concat(resourceId('Microsoft.ApiManagement/service', parameters('ApimServiceName')), '/{versionSetName}')]";
GenerateVersionSetARMTemplate(apimname, resourceGroup, versionSetName, fileFolder);
}
else
{
apiResource.dependsOn = new string[] { };
}
templateResources.Add(apiResource);
#region Operations
string operations = apiExtractor.GetAPIOperations(apimname, resourceGroup, apiName).Result;
JObject oOperations = JObject.Parse(operations);
foreach (var item in oOperations["value"])
{
string operationName = ((JValue)item["name"]).Value.ToString();
string operationDetails = apiExtractor.GetAPIOperationDetail(apimname, resourceGroup, apiName, operationName).Result;
Console.WriteLine("'{0}' Operation found", operationName);
OperationTemplateResource operationResource = JsonConvert.DeserializeObject <OperationTemplateResource>(operationDetails);
string operationResourceName = operationResource.name;
operationResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}')]";
operationResource.apiVersion = "2018-06-01-preview";
operationResource.scale = null;
operationResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
templateResources.Add(operationResource);
try
{
string operationPolicy = apiExtractor.GetOperationPolicy(apimname, resourceGroup, oApiName, operationName).Result;
Console.WriteLine($" - Policy found to {operationName} operation");
PolicyTemplateResource operationPolicyResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(operationPolicy);
operationPolicyResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{operationResourceName}/policy')]";
operationPolicyResource.apiVersion = "2018-06-01-preview";
operationPolicyResource.scale = null;
operationPolicyResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis/operations', parameters('ApimServiceName'), '{oApiName}', '{operationResourceName}')]" };
templateResources.Add(operationPolicyResource);
}
catch (Exception)
{
Console.WriteLine($" - No policy found for {operationName} operation");
}
}
#endregion
#region API Policies
try
{
Console.WriteLine("Geting API Policy from {0} API: ", apiName);
string apiPolicies = apiExtractor.GetAPIPolicies(apimname, resourceGroup, apiName).Result;
Console.WriteLine("API Policy found!");
PolicyTemplateResource apiPoliciesResource = JsonConvert.DeserializeObject <PolicyTemplateResource>(apiPolicies);
apiPoliciesResource.apiVersion = "2018-06-01-preview";
apiPoliciesResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{apiPoliciesResource.name}')]";
apiPoliciesResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{apiName}')]" };
templateResources.Add(apiPoliciesResource);
}
catch (Exception)
{
Console.WriteLine("No API policy!");
}
#endregion
#region API Products
try
{
Console.WriteLine("Geting API Products from {0} API: ", apiName);
string apiProducts = apiExtractor.GetApiProducts(apimname, resourceGroup, apiName).Result;
JObject oApiProducts = JObject.Parse(apiProducts);
foreach (var item in oApiProducts["value"])
{
string apiProductName = ((JValue)item["name"]).Value.ToString();
Console.WriteLine($" -- {apiProductName} Product found to {oApiName} API");
ApiProductsTemplateResource apiProductsResource = JsonConvert.DeserializeObject <ApiProductsTemplateResource>(apiProducts);
apiProductsResource.type = "Microsoft.ApiManagement/service/products/apis";
apiProductsResource.name = $"[concat(parameters('ApimServiceName'), '/{apiProductName}/{oApiName}')]";
apiProductsResource.apiVersion = "2018-06-01-preview";
apiProductsResource.scale = null;
apiProductsResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
templateResources.Add(apiProductsResource);
}
}
catch (Exception)
{
Console.WriteLine("No API products!");
}
#endregion
#region Diagnostics
Console.WriteLine("------------------------------------------");
Console.WriteLine("Geting diagnostics from {0} API:", apiName);
string diagnostics = apiExtractor.GetAPIDiagnostics(apimname, resourceGroup, apiName).Result;
JObject oDiagnostics = JObject.Parse(diagnostics);
foreach (var diagnostic in oDiagnostics["value"])
{
string diagnosticName = ((JValue)diagnostic["name"]).Value.ToString();
Console.WriteLine("'{0}' Diagnostic found", diagnosticName);
DiagnosticTemplateResource diagnosticResource = diagnostic.ToObject <DiagnosticTemplateResource>();
diagnosticResource.name = $"[concat(parameters('ApimServiceName'), '/{oApiName}/{diagnosticName}')]";
diagnosticResource.type = "Microsoft.ApiManagement/service/apis/diagnostics";
diagnosticResource.apiVersion = "2018-06-01-preview";
diagnosticResource.scale = null;
diagnosticResource.dependsOn = new string[] { $"[resourceId('Microsoft.ApiManagement/service/apis', parameters('ApimServiceName'), '{oApiName}')]" };
if (!diagnosticName.Contains("applicationinsights"))
{
// enableHttpCorrelationHeaders only works for application insights, causes errors otherwise
diagnosticResource.properties.enableHttpCorrelationHeaders = null;
}
templateResources.Add(diagnosticResource);
}
#endregion
armTemplate.resources = templateResources.ToArray();
if (singleApiName != null)
{
fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-" + oApiName + "-template.json");
templateResources = new List <TemplateResource>();
}
}
if (singleApiName == null)
{
fileWriter = new FileWriter();
fileWriter.WriteJSONToFile(armTemplate, @fileFolder + Path.DirectorySeparatorChar + apimname + "-apis-template.json");
}
#endregion
}
