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