private static MetricDefinitionListResponse GetAvailableMetricDefinitions(TokenCloudCredentials credentials, string resourceUri)
{
using (var client = new InsightsClient(credentials))
{
return(client.MetricDefinitionOperations.GetMetricDefinitions(resourceUri, null));
}
}
static void Main(string[] args)
{
var token = GetAccessTokenWithClientSecret();
var creds = new TokenCloudCredentials(subscriptionId, token.AccessToken);
CreateSqlServer(creds);
}
public async Task <MetricListResponse> GetTelemetryVolume()
{
string token = await GetAuthenticationHeader();
string subscriptionID = "36dfc234-9a2d-4f33-be43-db6e321dbc2bss";
TokenCloudCredentials credentials = new TokenCloudCredentials(subscriptionID, token);
string resourceUri = "/subscriptions/dd0db424-9a49-408d-911e-67e398aaaa3a/resourceGroups/artrejo-scaledemo2/providers/Microsoft.DocumentDB/databaseAccounts/artrejo-scaledemo2";
//string filter = null;
TimeSpan period = new TimeSpan(0, 0, 0, 30, 0);
string filter = "(name.value eq 'Total Requests')";
MetricListResponse vmMetricList = GetResourceMetrics(credentials, resourceUri, filter, TimeSpan.FromHours(1), "PT5M");
// LINQ Query
// var metricValuesQuery = vmMetricList.MetricCollection.Value.FirstOrDefault().MetricValues.Select(metricValue => metricValue.Total.Value);
// var metricValuesQuery = vmMetricList.MetricCollection.Value.FirstOrDefault().MetricValues.Select(metricValue => metricValue.Total.Value);
//var metricValuesQuery = vmMetricList.MetricCollection.Value.FirstOrDefault().MetricValues;
//var metricValuesQuery = vmMetricList;
//MetricDefinitionListResponse list = GetAvailableMetricDefinitions(credentials, resourceUri);
// MetricListResponse list = GetResourceMetrics(credentials, resourceUri, filter, period, duration);
//return metricValuesQuery.ToArray();
return(vmMetricList);
}
public static SubscriptionCloudCredentials GetUserSubscriptionCredentials( )
{
TokenCloudCredentials toFoundSubscriptions = AzureCredentialsProvider.GetCredentialsByUserADAuth( );
IList <SubscriptionListOperationResponse.Subscription> subscriptions =
AzureCredentialsProvider.GetSubscriptionList(toFoundSubscriptions).Result;
if (!subscriptions.Any( ))
{
Console.WriteLine("No available subscriptions.");
return(null);
}
Console.WriteLine("Please select one of available subscriptions: ");
int listSize = 1;
foreach (var subscription in subscriptions)
{
Console.WriteLine(listSize + ": " + subscription.SubscriptionName);
listSize++;
}
string answer = Console.ReadLine( );
int selection = 0;
if (!int.TryParse(answer, out selection) || selection >= listSize)
{
return(null);
}
TokenCloudCredentials result =
AzureCredentialsProvider.GetCredentialsByUserADAuth(subscriptions[selection - 1].SubscriptionId, subscriptions[selection - 1].ActiveDirectoryTenantId);
return(result);
}
public void DismissFaults()
{
var handler = new RecordedDelegatingHandler
{
StatusCodeToReturn = HttpStatusCode.NoContent
};
var subscriptionId = Guid.NewGuid().ToString();
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
client.Faults.Dismiss(
Constants.ResourceGroupName,
Constants.FarmId,
Constants.FaultId
);
Assert.Equal(handler.Method, HttpMethod.Post);
var expectedUri = string.Format(
FaultDismissUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId,
Constants.FaultId);
Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);
}
public static async Task <ActionResponse> RegisterAzureProvider(string azureProvider, string azureToken, string subscriptionId)
{
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscriptionId, azureToken);
using (ResourceManagementClient managementClient = new ResourceManagementClient(creds))
{
var prov = await managementClient.Providers.GetAsync(azureProvider);
if (!prov.Provider.RegistrationState.EqualsIgnoreCase((REGISTERED)))
{
AzureOperationResponse operationResponse = managementClient.Providers.Register(azureProvider);
if (
!(operationResponse.StatusCode == System.Net.HttpStatusCode.OK ||
operationResponse.StatusCode == System.Net.HttpStatusCode.Accepted))
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "RegisterProviderError"));
}
// Temporary hack to wait for regiastration to complete
await Task.Delay(20000);
}
}
return(new ActionResponse(ActionStatus.Success));
}
public void GetFault()
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(ExpectedResults.FaultGetResponse)
};
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var subscriptionId = Guid.NewGuid().ToString();
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
var result = client.Faults.Get(
Constants.ResourceGroupName,
Constants.FarmId,
Constants.FaultId
);
// validate requestor
Assert.Equal(handler.Method, HttpMethod.Get);
var expectedUri = string.Format(
FaultGetUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId,
Constants.FaultId);
Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);
CompareExpectedResult(result.Fault, true);
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
string azureProvider = request.DataStore.GetValue("AzureProvider");
string azureToken = request.DataStore.GetJson("AzureToken", "access_token");
string subscriptionId = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscriptionId, azureToken);
using (ResourceManagementClient managementClient = new ResourceManagementClient(creds))
{
var prov = await managementClient.Providers.GetAsync(azureProvider);
if (!prov.Provider.RegistrationState.EqualsIgnoreCase((REGISTERED)))
{
AzureOperationResponse operationResponse = managementClient.Providers.Register(azureProvider);
if (
!(operationResponse.StatusCode == System.Net.HttpStatusCode.OK ||
operationResponse.StatusCode == System.Net.HttpStatusCode.Accepted))
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetEmptyJObject(), "RegisterProviderError"));
}
// Temporary hack to wait for regiastration to complete
await Task.Delay(20000);
}
}
return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject()));
}
private async Task CreateTemplateDeploymentAsync(TokenCloudCredentials credential, string rgName, string templateContent, string parameterContent)
{
Deployment deployment = new Deployment();
string deploymentname = rgName + "dp";
deployment.Properties = new DeploymentProperties
{
Mode = DeploymentMode.Incremental,
Template = templateContent,
Parameters = parameterContent,
};
using (ResourceManagementClient templateDeploymentClient = new ResourceManagementClient(credential))
{
try
{
DeploymentOperationsCreateResult dpResult =
await templateDeploymentClient.Deployments.CreateOrUpdateAsync(rgName, deploymentname, deployment);
ServiceEventSource.Current.Message("ArmClusterOperator: Deployment in RG {0}: {1} ({2})", rgName, dpResult.RequestId, dpResult.StatusCode);
}
catch (Exception e)
{
ServiceEventSource.Current.Message(
"ArmClusterOperator: Failed deploying ARM template to create a cluster in RG {0}. {1}",
rgName,
e.Message);
throw;
}
}
}
/// <summary>
/// Initiates creation of a new cluster.
/// </summary>
/// <remarks>
/// If a cluster with the given domain could not be created, an exception should be thrown indicating the failure reason.
/// </remarks>
/// <param name="name">A unique name for the cluster.</param>
/// <returns>The FQDN of the new cluster.</returns>
public async Task <string> CreateClusterAsync(string name, IEnumerable <int> ports)
{
string token = await this.GetAuthorizationTokenAsync();
TokenCloudCredentials credential = new TokenCloudCredentials(this.settings.SubscriptionID.ToUnsecureString(), token);
string rgStatus = await this.CreateResourceGroupAsync(credential, name);
if (rgStatus == "Exists")
{
throw new System.InvalidOperationException(
"ResourceGroup/Cluster already exists. Please try passing a different name, or delete the ResourceGroup/Cluster first.");
}
string templateContent = this.armTemplate;
string parameterContent = this.armParameters
.Replace("_CLUSTER_NAME_", name)
.Replace("_CLUSTER_LOCATION_", this.settings.Region)
.Replace("_USER_", this.settings.Username.ToUnsecureString())
.Replace("_PWD_", this.settings.Password.ToUnsecureString());
int ix = 1;
foreach (int port in ports)
{
parameterContent = parameterContent.Replace($"_PORT{ix}_", port.ToString());
++ix;
}
await this.CreateTemplateDeploymentAsync(credential, name, templateContent, parameterContent);
return(name + "." + this.settings.Region + ".cloudapp.azure.com");
}
public void UndeleteStorageAccounts()
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
};
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var subscriptionId = Guid.NewGuid().ToString();
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
StorageAccountUndeleteParameters para = new StorageAccountUndeleteParameters();
var result = client.StorageAccounts.Undelete(Constants.ResourceGroupName, Constants.FarmId, "myaccount", para);
// validate requestor
Assert.Equal(handler.Method, HttpMethod.Post);
var expectedUri = string.Format(
UndeleteUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId,
"myaccount");
Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);
// Validate headers
Assert.Equal(HttpMethod.Post, handler.Method);
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var location = request.DataStore.GetJson("SelectedLocation")["Name"].ToString();
var deploymentName = request.DataStore.GetValue("DeploymentName");
var sitename = request.DataStore.GetValue("SiteName");
var functionAppHostingPlan = request.DataStore.GetValue("FunctionHostingPlan");
var param = new AzureArmParameterGenerator();
param.AddStringParam("storageaccountname", "solutiontemplate" + Path.GetRandomFileName().Replace(".", "").Substring(0, 8));
param.AddStringParam("sitename", sitename);
param.AddStringParam("AppHostingPlan", functionAppHostingPlan);
param.AddStringParam("resourcegroup", resourceGroup);
param.AddStringParam("subscription", subscription);
var armTemplate = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.Info.App.AppFilePath, "Service/AzureArm/function.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds);
return(new ActionResponse(ActionStatus.Success));
}
public void TestClientInitialization()
{
var tokenCredentials = new TokenCloudCredentials("123", "abc");
var fakeClient = new WebSiteManagementClient(tokenCredentials);
Assert.IsNotNull(fakeClient);
}
public void Delete()
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
var subscriptionId = Guid.NewGuid().ToString();
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
var result = client.Acquisitions.Delete(
Constants.ResourceGroupName,
Constants.FarmId,
Constants.AcquisitionId
);
Assert.Equal(handler.Method, HttpMethod.Delete);
var expectedUri = string.Format(
GetUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId,
Constants.AcquisitionId);
Assert.Equal(expectedUri, handler.Uri.AbsoluteUri);
}
public static DwManagementClient Create(string resourceId, ExecutionContext context)
{
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
SubscriptionId = config["SubscriptionId"];
TenantId = config["TenantId"];
ClientId = config["ClientId"];
ClientKey = config["ClientKey"];
var httpClient = new HttpClient();
var authenticationContext = new AuthenticationContext(ActiveDirectoryEndpoint + TenantId);
var credential = new ClientCredential(clientId: ClientId, clientSecret: ClientKey);
var result = authenticationContext.AcquireTokenAsync(resource: WindowsManagementUri, clientCredential: credential).Result;
if (result == null)
{
throw new InvalidOperationException("Failed to obtain the token!");
}
var token = result.AccessToken;
var aadTokenCredentials = new TokenCloudCredentials(SubscriptionId, token);
var client = new DwManagementClient(aadTokenCredentials, resourceId);
return(client);
}
public static SubscriptionClient Create(IDictionary <string, object> settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
CloudCredentials credentials = null;
string token = ConfigurationHelper.GetString(settings, "Token", false);
if (token != null)
{
credentials = new TokenCloudCredentials {
Token = token
};
}
else
{
credentials = ConfigurationHelper.GetCredentials <CloudCredentials>(settings, true);
}
Uri baseUri = ConfigurationHelper.GetUri(settings, "BaseUri", false);
return(baseUri != null ?
new SubscriptionClient(credentials, baseUri) :
new SubscriptionClient(credentials));
}
public async Task DeleteResourceGroups()
{
DataStore dataStore = await AAD.GetUserTokenFromPopup();
CloudCredentials creds = new TokenCloudCredentials(dataStore.GetJson("AzureToken")["access_token"].ToString());
Microsoft.Azure.Subscriptions.SubscriptionClient clientSubscription = new SubscriptionClient(creds);
var subscriptionList = (await clientSubscription.Subscriptions.ListAsync(new CancellationToken())).Subscriptions.ToList();
List <Task> tasksToExecute = new List <Task>();
foreach (var subscription in subscriptionList)
{
SubscriptionCloudCredentials creds2 = new TokenCloudCredentials(subscription.SubscriptionId, dataStore.GetJson("AzureToken")["access_token"].ToString());
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds2);
string subId = subscription.SubscriptionId;
var resourceGroups = await client.ResourceGroups.ListAsync(new ResourceGroupListParameters());
var resourceGroupsToDelete = resourceGroups.ResourceGroups.Where(p => p.Name.ToLower().StartsWith("solution"));
foreach (var rg in resourceGroupsToDelete)
{
tasksToExecute.Add(client.ResourceGroups.DeleteAsync(rg.Name, new CancellationToken()));
}
resourceGroupsToDelete = resourceGroups.ResourceGroups.Where(p => p.Name.ToLower().StartsWith("unit"));
foreach (var rg in resourceGroupsToDelete)
{
tasksToExecute.Add(client.ResourceGroups.DeleteAsync(rg.Name, new CancellationToken()));
}
}
await Task.WhenAll(tasksToExecute);
}
private async Task <IEnumerable <Models.RunbookParameter> > ListAutomationRunbookParameters(
string accessToken,
string subscriptionId,
string resourceGroupName,
string automationAccountName,
string runbookName)
{
var credentials = new TokenCloudCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationRunbookResult = await automationClient.Runbooks.GetAsync(resourceGroupName, automationAccountName, runbookName);
var automationRunbookPrameters = automationRunbookResult.Runbook.Properties.Parameters.Select(
parameter => new Models.RunbookParameter
{
ParameterName = parameter.Key,
DefaultValue = parameter.Value.DefaultValue,
IsMandatory = parameter.Value.IsMandatory,
Position = parameter.Value.Position,
Type = parameter.Value.Type
}).ToList();
return(automationRunbookPrameters);
}
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken", "access_token");
var subscription = request.DataStore.GetJson("SelectedSubscription", "SubscriptionId");
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var deploymentName = request.DataStore.GetValue("DeploymentName");
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
ResourceManagementClient client = new ResourceManagementClient(creds);
while (true)
{
Thread.Sleep(5000);
var status = await client.Deployments.GetAsync(resourceGroup, deploymentName, new CancellationToken());
var operations = await client.DeploymentOperations.ListAsync(resourceGroup, deploymentName, new DeploymentOperationsListParameters(), new CancellationToken());
var provisioningState = status.Deployment.Properties.ProvisioningState;
if (provisioningState == "Accepted" || provisioningState == "Running")
{
continue;
}
if (provisioningState == "Succeeded")
{
return(new ActionResponse(ActionStatus.Success, operations));
}
var operation = operations.Operations.First(p => p.Properties.ProvisioningState == ProvisioningState.Failed);
var operationFailed = await client.DeploymentOperations.GetAsync(resourceGroup, deploymentName, operation.OperationId, new CancellationToken());
return(new ActionResponse(ActionStatus.Failure, operationFailed));
}
}
private WebSiteManagementClient GetWSClient(string subscriptionId)
{
var token = Request.Headers.GetValues("X-MS-OAUTH-TOKEN").FirstOrDefault();
var creds = new TokenCloudCredentials(subscriptionId, token);
return(new WebSiteManagementClient(creds, new Uri(Utils.GetCSMUrl(Request.RequestUri.Host))));
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
var subscription = request.DataStore.GetJson("SelectedSubscription")["SubscriptionId"].ToString();
var resourceGroup = request.DataStore.GetValue("SelectedResourceGroup");
var deploymentName = request.DataStore.GetValue("DeploymentName") ?? "AzureMLDeployment";
var workspaceName = request.DataStore.GetValue("WorkspaceName");
var storageAccountName = request.DataStore.GetValue("StorageAccountName");
var planName = request.DataStore.GetValue("PlanName") ?? "azuremlplan";
var skuName = request.DataStore.GetValue("SkuName") ?? "S1";
var skuTier = request.DataStore.GetValue("SkuTier") ?? "Standard";
var skuCapacity = request.DataStore.GetValue("SkuCapacity") ?? "1";
// Get email address
var param = new AzureArmParameterGenerator();
param.AddStringParam("name", workspaceName);
param.AddStringParam("resourcegroup", resourceGroup);
param.AddStringParam("subscription", subscription);
param.AddStringParam("newStorageAccountName", storageAccountName);
param.AddStringParam("planName", planName);
param.AddStringParam("skuName", skuName);
param.AddStringParam("skuTier", skuTier);
param.AddStringParam("skuCapacity", skuCapacity);
param.AddStringParam("ownerEmail", AzureUtility.GetEmailFromToken(request.DataStore.GetJson("AzureToken")));
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription, azureToken);
Microsoft.Azure.Management.Resources.ResourceManagementClient client = new ResourceManagementClient(creds);
var armTemplate = JsonUtility.GetJObjectFromJsonString(System.IO.File.ReadAllText(Path.Combine(request.ControllerModel.SiteCommonFilePath, "Service/Arm/azureml.json")));
var armParamTemplate = JsonUtility.GetJObjectFromObject(param.GetDynamicObject());
armTemplate.Remove("parameters");
armTemplate.Add("parameters", armParamTemplate["parameters"]);
var deployment = new Microsoft.Azure.Management.Resources.Models.Deployment()
{
Properties = new DeploymentPropertiesExtended()
{
Template = armTemplate.ToString(),
Parameters = JsonUtility.GetEmptyJObject().ToString()
}
};
var validate = client.Deployments.ValidateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
if (!validate.IsValid)
{
return(new ActionResponse(ActionStatus.Failure, JsonUtility.GetJObjectFromObject(validate), null,
DefaultErrorCodes.DefaultErrorCode, $"Azure:{validate.Error.Message} Details:{validate.Error.Details}"));
}
var deploymentItem = client.Deployments.CreateOrUpdateAsync(resourceGroup, deploymentName, deployment, new CancellationToken()).Result;
return(new ActionResponse(ActionStatus.Success));
}
public TClient CreateClient <TClient>(AzureSMProfile profile, AzureSubscription subscription, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient>
{
if (subscription == null)
{
throw new ArgumentException(Microsoft.Azure.Commands.ResourceManager.Common.Properties.Resources.InvalidDefaultSubscription);
}
if (profile == null)
{
profile = new AzureSMProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile));
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient(profile);
AzureContext context = new AzureContext(
subscription,
profileClient.GetAccount(subscription.Account),
profileClient.GetEnvironmentOrDefault(subscription.Environment)
);
creds = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = profile.Environments[subscription.Environment].GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
}
public AzureStackClient GetAzureStackAdminClient(RecordedDelegatingHandler handler)
{
var token = new TokenCloudCredentials(Guid.NewGuid().ToString(), "fake");
handler.IsPassThrough = false;
return(new AzureStackClient(new Uri("https://armuri"), token, "2015-11-01").WithHandler(handler));
}
private async Task <string> GenerateSiteName(string siteName, string token, Repository repo, SubscriptionInfo[] subscriptions)
{
if (!string.IsNullOrEmpty(repo.RepositoryName))
{
bool isAvailable = false;
var creds = new TokenCloudCredentials(subscriptions.First().subscriptionId, token);
var rdfeBaseUri = new Uri(Utils.GetRDFEUrl(Request.RequestUri.Host));
using (var webSiteMgmtClient = CloudContext.Clients.CreateWebSiteManagementClient(creds, rdfeBaseUri))
{
for (int i = 0; i < 3; i++)
{
siteName = GenerateRandomSiteName(repo.RepositoryName);
isAvailable = (await webSiteMgmtClient.WebSites.IsHostnameAvailableAsync(siteName)).IsAvailable;
if (isAvailable)
{
break;
}
}
}
if (!isAvailable)
{
siteName = null;
}
}
return(siteName);
}
public TClient CreateClient <TClient>(IAzureContextContainer profile, IAzureSubscription subscription, string endpoint) where TClient : ServiceClient <TClient>
{
#if !NETSTANDARD
if (subscription == null)
{
throw new ArgumentException(Microsoft.Azure.Commands.ResourceManager.Common.Properties.Resources.InvalidDefaultSubscription);
}
if (profile == null)
{
profile = new AzureSMProfile(Path.Combine(AzureSession.Instance.ProfileDirectory, AzureSession.Instance.ProfileFile));
}
SubscriptionCloudCredentials creds = new TokenCloudCredentials(subscription.Id.ToString(), "fake_token");
if (HttpMockServer.GetCurrentMode() != HttpRecorderMode.Playback)
{
ProfileClient profileClient = new ProfileClient(profile as AzureSMProfile);
AzureContext context = new AzureContext(
subscription,
profileClient.GetAccount(subscription.GetAccount()),
profileClient.GetEnvironmentOrDefault(subscription.GetEnvironment())
);
creds = AzureSession.Instance.AuthenticationFactory.GetSubscriptionCloudCredentials(context);
}
Uri endpointUri = profile.Environments.FirstOrDefault((e) => e.Name.Equals(subscription.GetEnvironment(), StringComparison.OrdinalIgnoreCase)).GetEndpointAsUri(endpoint);
return(CreateCustomClient <TClient>(creds, endpointUri));
#else
throw new NotSupportedException("AzureSMProfile is not supported in Azure PS on .Net Core.");
#endif
}
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request)
{
var azureToken = request.DataStore.GetJson("AzureToken")["access_token"].ToString();
CloudCredentials creds = new TokenCloudCredentials(azureToken);
dynamic subscriptionWrapper = new ExpandoObject();
List <Subscription> validSubscriptions = new List <Subscription>();
using (SubscriptionClient client = new SubscriptionClient(creds))
{
SubscriptionListResult subscriptionList = await client.Subscriptions.ListAsync();
foreach (Subscription s in subscriptionList.Subscriptions)
{
if (s.State.Equals("Disabled", System.StringComparison.OrdinalIgnoreCase) || s.State.Equals("Deleted", System.StringComparison.OrdinalIgnoreCase))
{
continue;
}
validSubscriptions.Add(s);
}
subscriptionWrapper.value = validSubscriptions;
}
request.Logger.LogEvent("GetAzureSubscriptions-result", new Dictionary <string, string>()
{
{ "Subscriptions", string.Join(",", validSubscriptions.Select(p => p.SubscriptionId)) }
});
return(new ActionResponse(ActionStatus.Success, subscriptionWrapper));
}
public void ListShares()
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(ExpectedResults.ShareListResponse)
};
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var subscriptionId = Guid.NewGuid().ToString();
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
var result = client.Shares.List(Constants.ResourceGroupName, Constants.FarmId);
var expectedUri = string.Format(
ListUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId);
Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);
Assert.Equal(HttpMethod.Get, handler.Method);
Assert.True(result.Shares.Count > 1);
CompareExpectedResult(result.Shares[0]);
}
static async Task MainAsync()
{
// Set Environment - Choose between Azure public cloud, china cloud and US govt. cloud
_environment = AzureEnvironment.PublicEnvironments[EnvironmentName.AzureCloud];
// Get the credentials
TokenCloudCredentials cloudCreds = GetCredsFromServicePrincipal();
var tokenCreds = new TokenCredentials(cloudCreds.Token);
var loggingHandler = new LoggingHandler(new HttpClientHandler());
// Create our own HttpClient so we can do logging
var httpClient = new HttpClient(loggingHandler);
// Use the creds to create the clients we need
_resourceGroupClient = new ResourceManagementClient(_environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager), tokenCreds, loggingHandler);
_resourceGroupClient.SubscriptionId = cloudCreds.SubscriptionId;
_websiteClient = new WebSiteManagementClient(_environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager), tokenCreds, loggingHandler);
_websiteClient.SubscriptionId = cloudCreds.SubscriptionId;
await ListResourceGroupsAndSites();
// Note: site names are globally unique, so you may need to change it to avoid conflicts
await CreateSite("MyResourceGroup", "MyAppServicePlan", "SampleSiteFromAPI", "West US");
// Upload certificate to resource group
await UpdateLoadCertificate("MyResourceGroup", "CertificateName", "West US", "PathToPfxFile", "CertificatePassword");
// Bind certificate to resource group
await BindCertificateToSite("MyResourceGroup", "SiteName", "CertificateName", "hostName");
}
public ResourceManagementClient GetResourceManagementClient(RecordedDelegatingHandler handler)
{
var token = new TokenCloudCredentials(Guid.NewGuid().ToString(), "abc123");
handler.IsPassThrough = false;
return(new ResourceManagementClient(token).WithHandler(handler));
}
public void DisableNode()
{
var response = new HttpResponseMessage(HttpStatusCode.Accepted);
var subscriptionId = Guid.NewGuid().ToString();
string locationUri = string.Format(
LocationUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId,
Constants.NodeId,
Guid.NewGuid()
);
response.Headers.Add("Location", locationUri);
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.Accepted,
SubsequentStatusCodeToReturn = HttpStatusCode.OK
};
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
var result = client.Nodes.Disable(
Constants.ResourceGroupName,
Constants.FarmId,
Constants.NodeId
);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
Assert.Equal(locationUri, handler.Uri.AbsoluteUri);
}
public void TokenCloudCredentialAddsHeader()
{
var tokenCredentials = new TokenCloudCredentials("123","abc");
var handler = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK };
var fakeClient = new FakeServiceClientWithCredentials(tokenCredentials).WithHandler(handler);
fakeClient.DoStuff().Wait();
Assert.Equal("Bearer", handler.RequestHeaders.Authorization.Scheme);
Assert.Equal("abc", handler.RequestHeaders.Authorization.Parameter);
}
public static SubscriptionClient Create(IDictionary<string, object> settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
CloudCredentials credentials = null;
string token = ConfigurationHelper.GetString(settings, "Token", false);
if (token != null)
{
credentials = new TokenCloudCredentials { Token = token };
}
else
{
credentials = ConfigurationHelper.GetCredentials<CloudCredentials>(settings, true);
}
Uri baseUri = ConfigurationHelper.GetUri(settings, "BaseUri", false);
return baseUri != null ?
new SubscriptionClient(credentials, baseUri) :
new SubscriptionClient(credentials);
}
public IEnumerable<WindowsAzureSubscription> AddAccount(ITokenProvider tokenProvider)
{
if (ActiveDirectoryEndpoint == null || ActiveDirectoryServiceEndpointResourceId == null)
{
throw new Exception(string.Format(Resources.EnvironmentDoesNotSupportActiveDirectory, Name));
}
IAccessToken mainToken = tokenProvider.GetNewToken(this);
var credentials = new TokenCloudCredentials(mainToken.AccessToken);
using (var subscriptionClient = new SubscriptionClient(credentials, new Uri(ServiceEndpoint)))
{
var result = subscriptionClient.Subscriptions.List();
// Filter out subscriptions with no tenant, backfill's not done on them
foreach (var subscription in result.Subscriptions.Where(s => !string.IsNullOrEmpty(s.ActiveDirectoryTenantId)))
{
var azureSubscription = new WindowsAzureSubscription
{
ActiveDirectoryEndpoint = ActiveDirectoryEndpoint,
ActiveDirectoryTenantId = subscription.ActiveDirectoryTenantId,
ActiveDirectoryUserId = mainToken.UserId,
ActiveDirectoryServiceEndpointResourceId = ActiveDirectoryServiceEndpointResourceId,
SubscriptionId = subscription.SubscriptionId,
SubscriptionName = subscription.SubscriptionName,
ServiceEndpoint = !string.IsNullOrEmpty(ServiceEndpoint) ? new Uri(ServiceEndpoint) : null,
ResourceManagerEndpoint = !string.IsNullOrEmpty(ResourceManagerEndpoint) ? new Uri(ResourceManagerEndpoint) : null,
TokenProvider = tokenProvider,
GalleryEndpoint = !string.IsNullOrEmpty(GalleryEndpoint) ? new Uri(GalleryEndpoint) : null
};
if (mainToken.LoginType == LoginType.LiveId)
{
azureSubscription.SetAccessToken(tokenProvider.GetNewToken(azureSubscription, mainToken.UserId));
}
else
{
azureSubscription.SetAccessToken(mainToken);
}
yield return azureSubscription;
}
}
}
public static BatchManagementClient CreateBatchManagementClient(this CloudClients clients, TokenCloudCredentials credentials, Uri baseUri)
{
return new BatchManagementClient(credentials, baseUri);
}
public static WebSiteManagementClient CreateWebSiteManagementClient(this CloudClients clients, TokenCloudCredentials credentials, Uri baseUri)
{
return new WebSiteManagementClient(credentials, baseUri);
}
