public async Task <List <AzureSubscription> > GetSubscriptions()
{
if (_AzureSubscriptions != null)
{
return(_AzureSubscriptions);
}
String subscriptionsUrl = _AzureContext.AzureServiceUrls.GetASMServiceManagementUrl() + "subscriptions";
_AzureContext.StatusProvider.UpdateStatus("BUSY: Getting Subscriptions...");
AzureRestRequest azureRestRequest = new AzureRestRequest(subscriptionsUrl, _AzureContext.TokenProvider.AccessToken);
azureRestRequest.Headers.Add("x-ms-version", "2015-04-01");
AzureRestResponse azureRestResponse = await _AzureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
XmlDocument subscriptionsXml = AzureSubscription.RemoveXmlns(azureRestResponse.Response);
_AzureSubscriptions = new List <AzureSubscription>();
foreach (XmlNode subscriptionXml in subscriptionsXml.SelectNodes("//Subscription"))
{
AzureSubscription azureSubscription = new AzureSubscription(_AzureContext, subscriptionXml, this._AzureContext.AzureEnvironment);
_AzureSubscriptions.Add(azureSubscription);
}
return(_AzureSubscriptions);
}
public async Task <List <AzureSubscription> > GetAzureARMSubscriptions()
{
_AzureContext.LogProvider.WriteLog("GetAzureARMSubscriptions", "Start");
if (_ArmSubscriptions != null)
{
return(_ArmSubscriptions);
}
String subscriptionsUrl = _AzureContext.AzureServiceUrls.GetARMServiceManagementUrl() + "subscriptions?api-version=2015-01-01";
String accessToken = _AzureContext.TokenProvider.AccessToken;
_AzureContext.StatusProvider.UpdateStatus("BUSY: Getting Subscriptions...");
AzureRestRequest azureRestRequest = new AzureRestRequest(subscriptionsUrl, accessToken, "GET", true);
AzureRestResponse azureRestResponse = await _AzureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject subscriptionsJson = JObject.Parse(azureRestResponse.Response);
var subscriptions = from subscription in subscriptionsJson["value"]
select subscription;
_ArmSubscriptions = new List <AzureSubscription>();
foreach (JObject azureSubscriptionJson in subscriptions)
{
AzureSubscription azureSubscription = new AzureSubscription(_AzureContext, azureSubscriptionJson, null, _AzureContext.AzureEnvironment);
_ArmSubscriptions.Add(azureSubscription);
}
return(_ArmSubscriptions);
}
public async Task <List <AzureSubscription> > GetAzureARMSubscriptions(AzureTenant azureTenant)
{
_AzureContext.LogProvider.WriteLog("GetAzureARMSubscriptions", "Start - azureTenant: " + azureTenant.ToString());
String subscriptionsUrl = _AzureContext.AzureServiceUrls.GetARMServiceManagementUrl() + "subscriptions?api-version=2015-01-01";
String accessToken = _AzureContext.TokenProvider.AccessToken;
AuthenticationResult subscriptionAuthenticationResult = await _AzureContext.TokenProvider.GetAzureToken(azureTenant.TenantId.ToString());
if (subscriptionAuthenticationResult != null)
{
accessToken = subscriptionAuthenticationResult.AccessToken;
}
_AzureContext.StatusProvider.UpdateStatus("BUSY: Getting Subscriptions...");
AzureRestRequest azureRestRequest = new AzureRestRequest(subscriptionsUrl, accessToken, "GET", false);
AzureRestResponse azureRestResponse = await _AzureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject subscriptionsJson = JObject.Parse(azureRestResponse.Response);
var subscriptions = from subscription in subscriptionsJson["value"]
select subscription;
List <AzureSubscription> tenantSubscriptions = new List <AzureSubscription>();
foreach (JObject azureSubscriptionJson in subscriptions)
{
AzureSubscription azureSubscription = new AzureSubscription(_AzureContext, azureSubscriptionJson, azureTenant, _AzureContext.AzureEnvironment);
tenantSubscriptions.Add(azureSubscription);
}
return(tenantSubscriptions);
}
/// <summary>
/// Get Azure Subscriptions within the provided Azure Tenant
/// </summary>
/// <param name="azureTenant">Azure Tenant for which Azure Subscriptions should be retrieved</param>
/// <param name="allowRestCacheUse">False in production use so that Azure Token Content is Tenant specific. True in Unit Tests to allow offline (no actual URL querying).</param>
/// <returns></returns>
public async Task <List <AzureSubscription> > GetAzureARMSubscriptions(AzureContext azureContext, bool allowRestCacheUse = false)
{
azureContext.LogProvider.WriteLog("GetAzureARMSubscriptions", "Start - azureTenant: " + this.ToString());
azureContext.StatusProvider.UpdateStatus("BUSY: Getting Auth Token to Query Subscriptions");
String subscriptionsUrl = azureContext.AzureEnvironment.ResourceManagerEndpoint + "subscriptions?api-version=2015-01-01";
AuthenticationResult authenticationResult = await azureContext.TokenProvider.GetToken(azureContext.AzureEnvironment.ResourceManagerEndpoint, this.TenantId);
azureContext.StatusProvider.UpdateStatus("BUSY: Querying Subscriptions");
AzureRestRequest azureRestRequest = new AzureRestRequest(subscriptionsUrl, authenticationResult, "GET", allowRestCacheUse);
AzureRestResponse azureRestResponse = await azureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject subscriptionsJson = JObject.Parse(azureRestResponse.Response);
var subscriptions = from subscription in subscriptionsJson["value"]
select subscription;
azureContext.StatusProvider.UpdateStatus("BUSY: Instantiating Subscriptions");
List <AzureSubscription> azureSubscriptions = new List <AzureSubscription>();
foreach (JObject azureSubscriptionJson in subscriptions)
{
AzureSubscription azureSubscription = new AzureSubscription(azureSubscriptionJson, this, azureContext.AzureEnvironment, azureContext.GetARMServiceManagementUrl(), azureContext.GetARMTokenResourceUrl());
azureSubscriptions.Add(azureSubscription);
azureContext.StatusProvider.UpdateStatus("BUSY: Loaded Subscription " + azureSubscription.ToString());
}
azureContext.StatusProvider.UpdateStatus("BUSY: Getting Subscriptions Completed");
return(azureSubscriptions);
}
public async Task <List <AzureDomain> > GetAzureARMDomains(AzureContext azureContext, bool allowRestCacheUse = false)
{
try
{
azureContext.LogProvider.WriteLog("GetAzureARMDomains", "Start");
if (this == null)
{
throw new ArgumentNullException("AzureContext is null. Unable to call Azure API without Azure Context.");
}
if (azureContext.TokenProvider == null)
{
throw new ArgumentNullException("TokenProvider Context is null. Unable to call Azure API without TokenProvider.");
}
String domainUrl = azureContext.AzureEnvironment.GraphEndpoint + "myorganization/domains?api-version=1.6";
AuthenticationResult tenantAuthenticationResult = await azureContext.TokenProvider.GetToken(azureContext.AzureEnvironment.GraphEndpoint, this.TenantId, PromptBehavior.Never);
azureContext.StatusProvider.UpdateStatus("BUSY: Getting Tenant Domain details from Graph...");
AzureRestRequest azureRestRequest = new AzureRestRequest(domainUrl, tenantAuthenticationResult, "GET", allowRestCacheUse);
AzureRestResponse azureRestResponse = await azureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject domainsJson = JObject.Parse(azureRestResponse.Response);
var domains = from domain in domainsJson["value"]
select domain;
_Domains = new List <AzureDomain>();
foreach (JObject domainJson in domains)
{
try
{
AzureDomain azureDomain = new AzureDomain(this, domainJson);
_Domains.Add(azureDomain);
}
catch (Exception exc)
{
azureContext.LogProvider.WriteLog("GetAzureARMDomains", "Error getting Azure AD Domain:" + exc.Message);
}
}
}
catch (Exception exc)
{
azureContext.LogProvider.WriteLog("GetAzureARMDomains", "Error getting Azure Subscriptions:" + exc.Message);
}
return(_Domains);
}
public async Task <List <AzureDomain> > GetAzureARMDomains(AzureTenant azureTenant)
{
_AzureContext.LogProvider.WriteLog("GetAzureARMDomains", "Start");
if (_AzureContext == null)
{
throw new ArgumentNullException("AzureContext is null. Unable to call Azure API without Azure Context.");
}
if (_AzureContext.TokenProvider == null)
{
throw new ArgumentNullException("TokenProvider Context is null. Unable to call Azure API without TokenProvider.");
}
if (_AzureContext.TokenProvider.AccessToken == null)
{
throw new ArgumentNullException("AccessToken Context is null. Unable to call Azure API without AccessToken.");
}
String accessToken = _AzureContext.TokenProvider.AccessToken;
String domainUrl = _AzureContext.AzureServiceUrls.GetGraphApiUrl() + "myorganization/domains?api-version=1.6";
AuthenticationResult tenantAuthenticationResult = await _AzureContext.TokenProvider.GetGraphToken(azureTenant.TenantId.ToString());
if (tenantAuthenticationResult != null)
{
accessToken = tenantAuthenticationResult.AccessToken;
}
_AzureContext.StatusProvider.UpdateStatus("BUSY: Getting Tenant Domain details from Graph...");
AzureRestRequest azureRestRequest = new AzureRestRequest(domainUrl, accessToken, "GET", false);
AzureRestResponse azureRestResponse = await _AzureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject domainsJson = JObject.Parse(azureRestResponse.Response);
var domains = from domain in domainsJson["value"]
select domain;
List <AzureDomain> armTenantDomains = new List <AzureDomain>();
foreach (JObject domainJson in domains)
{
AzureDomain azureDomain = new AzureDomain(domainJson, _AzureContext);
armTenantDomains.Add(azureDomain);
}
return(armTenantDomains);
}
public async Task <List <AzureTenant> > GetAzureARMTenants(bool allowRestCacheUse = false)
{
this.LogProvider.WriteLog("GetAzureARMTenants", "Start");
if (_ArmTenants != null)
{
return(_ArmTenants);
}
if (this.TokenProvider == null)
{
throw new ArgumentNullException("TokenProvider Context is null. Unable to call Azure API without TokenProvider.");
}
AuthenticationResult tenantAuthenticationResult = await this.TokenProvider.GetToken(this.AzureEnvironment.ResourceManagerEndpoint, Guid.Empty);
String tenantUrl = this.AzureEnvironment.ResourceManagerEndpoint + "tenants?api-version=2015-01-01";
this.StatusProvider.UpdateStatus("BUSY: Getting Tenants...");
AzureRestRequest azureRestRequest = new AzureRestRequest(tenantUrl, tenantAuthenticationResult, "GET", allowRestCacheUse);
AzureRestResponse azureRestResponse = await this.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject tenantsJson = JObject.Parse(azureRestResponse.Response);
var tenants = from tenant in tenantsJson["value"]
select tenant;
_ArmTenants = new List <AzureTenant>();
foreach (JObject tenantJson in tenants)
{
try
{
AzureTenant azureTenant = new AzureTenant(this, tenantJson);
await azureTenant.InitializeChildren(this, allowRestCacheUse);
_ArmTenants.Add(azureTenant);
}
catch (Exception exc)
{
this.LogProvider.WriteLog("GetAzureARMTenants", "Error getting Azure Tenant: '" + exc.Message);
}
}
return(_ArmTenants);
}
public async Task <List <AzureTenant> > GetAzureARMTenants()
{
_AzureContext.LogProvider.WriteLog("GetAzureARMTenants", "Start");
if (_ArmTenants != null)
{
return(_ArmTenants);
}
if (_AzureContext == null)
{
throw new ArgumentNullException("AzureContext is null. Unable to call Azure API without Azure Context.");
}
if (_AzureContext.TokenProvider == null)
{
throw new ArgumentNullException("TokenProvider Context is null. Unable to call Azure API without TokenProvider.");
}
if (_AzureContext.TokenProvider.AccessToken == null)
{
throw new ArgumentNullException("AccessToken Context is null. Unable to call Azure API without AccessToken.");
}
String tenantUrl = _AzureContext.AzureServiceUrls.GetARMServiceManagementUrl() + "tenants?api-version=2015-01-01";
_AzureContext.StatusProvider.UpdateStatus("BUSY: Getting Tenants...");
AzureRestRequest azureRestRequest = new AzureRestRequest(tenantUrl, _AzureContext.TokenProvider.AccessToken, "GET", true);
AzureRestResponse azureRestResponse = await _AzureContext.AzureRetriever.GetAzureRestResponse(azureRestRequest);
JObject tenantsJson = JObject.Parse(azureRestResponse.Response);
var tenants = from tenant in tenantsJson["value"]
select tenant;
_ArmTenants = new List <AzureTenant>();
foreach (JObject tenantJson in tenants)
{
AzureTenant azureTenant = new AzureTenant(tenantJson, _AzureContext);
await azureTenant.InitializeChildren();
_ArmTenants.Add(azureTenant);
}
return(_ArmTenants);
}
public async Task <AzureRestResponse> GetAzureRestResponse(AzureRestRequest azureRestRequest)
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " Url: " + azureRestRequest.Url);
if (azureRestRequest.UseCached && _RestApiCache.ContainsKey(azureRestRequest.Url))
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " Using Cached Response");
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " End REST Request");
AzureRestResponse cachedRestResponse = (AzureRestResponse)_RestApiCache[azureRestRequest.Url];
return(cachedRestResponse);
}
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(azureRestRequest.Url);
request.Method = azureRestRequest.Method;
if (azureRestRequest.AccessToken != String.Empty)
{
string authorizationHeader = "Bearer " + azureRestRequest.AccessToken;
request.Headers.Add(HttpRequestHeader.Authorization, authorizationHeader);
writeRetreiverResultToLog(azureRestRequest.RequestGuid, "GetAzureRestResponse", azureRestRequest.Url, authorizationHeader);
}
if (request.Method == "POST")
{
request.ContentLength = 0;
}
foreach (String headerKey in azureRestRequest.Headers.Keys)
{
request.Headers.Add(headerKey, azureRestRequest.Headers[headerKey]);
}
string webRequesetResult = String.Empty;
try
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " " + azureRestRequest.Method + " " + azureRestRequest.Url);
// Retry Guidlines for 500 series with Backoff Timer - https://msdn.microsoft.com/en-us/library/azure/jj878112.aspx https://msdn.microsoft.com/en-us/library/azure/gg185909.aspx
HttpWebResponse response = null;
const Int32 maxRetrySecond = 32;
Int32 retrySeconds = 1;
bool boolRetryGetResponse = true;
while (boolRetryGetResponse)
{
try
{
response = (HttpWebResponse)await request.GetResponseAsync();
boolRetryGetResponse = false;
}
catch (WebException webException)
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " EXCEPTION " + webException.Message);
HttpWebResponse exceptionResponse = (HttpWebResponse)webException.Response;
if (exceptionResponse != null)
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " EXCEPTION HttpWebResponse Status Code: " + exceptionResponse.StatusCode);
if (
(int)exceptionResponse.StatusCode == 429 || // 429 Too Many Requests
((int)exceptionResponse.StatusCode >= 500 && (int)exceptionResponse.StatusCode <= 599)
)
{
DateTime sleepUntil = DateTime.Now.AddSeconds(retrySeconds);
string sleepMessage = "Sleeping for " + retrySeconds.ToString() + " second(s) (until " + sleepUntil.ToString() + ") before web request retry.";
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " " + sleepMessage);
_StatusProvider.UpdateStatus(sleepMessage);
while (DateTime.Now < sleepUntil)
{
Application.DoEvents();
}
retrySeconds = retrySeconds * 2;
if (retrySeconds > maxRetrySecond)
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " Too many retry.");
_StatusProvider.UpdateStatus("Too many retry.");
throw webException;
// too many retry -> throw exception
}
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " Initiating retry of Web Request.");
_StatusProvider.UpdateStatus("Initiating retry of Web Request.");
}
else if (exceptionResponse.StatusCode == HttpStatusCode.Conflict)
{
boolRetryGetResponse = false;
}
else
{
throw webException;
}
}
else
{
throw webException;
}
}
catch (Exception exc)
{
// todo?
}
}
if (response != null)
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " Status Code " + response.StatusCode);
webRequesetResult = new StreamReader(response.GetResponseStream()).ReadToEnd();
writeRetreiverResultToLog(azureRestRequest.RequestGuid, "GetAzureRestResponse", azureRestRequest.Url, webRequesetResult);
}
}
catch (Exception exception)
{
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + azureRestRequest.Url + " EXCEPTION " + exception.Message);
throw exception;
}
_LogProvider.WriteLog("GetAzureRestResponse", azureRestRequest.RequestGuid.ToString() + " End REST Request");
AzureRestResponse azureRestResponse = new AzureRestResponse(azureRestRequest, webRequesetResult);
if (!_RestApiCache.ContainsKey(azureRestRequest.Url))
{
_RestApiCache.Add(azureRestRequest.Url, azureRestResponse);
}
OnRestResult?.Invoke(azureRestResponse);
return(azureRestResponse);
}
