public List<AzureSubscription> GetSubscriptions(AzureProfile profile) { string subscriptions = string.Empty; List<AzureSubscription> subscriptionsList = new List<AzureSubscription>(); if (Properties.ContainsKey(Property.Subscriptions)) { subscriptions = Properties[Property.Subscriptions]; } foreach (var subscription in subscriptions.Split(new [] {','}, StringSplitOptions.RemoveEmptyEntries)) { try { Guid subscriptionId = new Guid(subscription); Debug.Assert(profile.Subscriptions.ContainsKey(subscriptionId)); subscriptionsList.Add(profile.Subscriptions[subscriptionId]); } catch { // Skip } } return subscriptionsList; }
public void AddsAzureEnvironment() { var profile = new AzureProfile(); Mock<ICommandRuntime> commandRuntimeMock = new Mock<ICommandRuntime>(); AddAzureEnvironmentCommand cmdlet = new AddAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Name = "Katal", PublishSettingsFileUrl = "http://microsoft.com", ServiceEndpoint = "endpoint.net", ManagementPortalUrl = "management portal url", StorageEndpoint = "endpoint.net", GalleryEndpoint = "http://galleryendpoint.com", Profile = profile }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); commandRuntimeMock.Verify(f => f.WriteObject(It.IsAny<PSAzureEnvironment>()), Times.Once()); ProfileClient client = new ProfileClient(profile); AzureEnvironment env = client.GetEnvironmentOrDefault("KaTaL"); Assert.Equal(env.Name, cmdlet.Name); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.PublishSettingsFileUrl], cmdlet.PublishSettingsFileUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ServiceManagement], cmdlet.ServiceEndpoint); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.ManagementPortalUrl], cmdlet.ManagementPortalUrl); Assert.Equal(env.Endpoints[AzureEnvironment.Endpoint.Gallery], "http://galleryendpoint.com"); }
public void RemovesAzureEnvironment() { var commandRuntimeMock = new Mock<ICommandRuntime>(); commandRuntimeMock.Setup(f => f.ShouldProcess(It.IsAny<string>(), It.IsAny<string>())).Returns(true); const string name = "test"; var profile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); AzurePSCmdlet.CurrentProfile = profile; ProfileClient client = new ProfileClient(profile); client.AddOrSetEnvironment(new AzureEnvironment { Name = name }); client.Profile.Save(); var cmdlet = new RemoveAzureEnvironmentCommand() { CommandRuntime = commandRuntimeMock.Object, Force = true, Name = name }; cmdlet.InvokeBeginProcessing(); cmdlet.ExecuteCmdlet(); cmdlet.InvokeEndProcessing(); client = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile))); Assert.False(client.Profile.Environments.ContainsKey(name)); }
public void SwitchesSlots() { // Setup var mockClient = new Mock<IWebsitesClient>(); string slot1 = WebsiteSlotName.Production.ToString(); string slot2 = "staging"; mockClient.Setup(c => c.GetWebsiteSlots("website1")) .Returns(new List<Site> { new Site { Name = "website1", WebSpace = "webspace1" }, new Site { Name = "website1(staging)", WebSpace = "webspace1" } }); mockClient.Setup(f => f.GetSlotName("website1")).Returns(slot1); mockClient.Setup(f => f.GetSlotName("website1(staging)")).Returns(slot2); mockClient.Setup(f => f.SwitchSlots("webspace1", "website1(staging)", slot1, slot2)).Verifiable(); mockClient.Setup(f => f.GetWebsiteNameFromFullName("website1")).Returns("website1"); // Test SwitchAzureWebsiteSlotCommand switchAzureWebsiteCommand = new SwitchAzureWebsiteSlotCommand { CommandRuntime = new MockCommandRuntime(), WebsitesClient = mockClient.Object, Name = "website1", Force = true }; currentProfile = new AzureProfile(); var subscription = new AzureSubscription { Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Switch existing website switchAzureWebsiteCommand.ExecuteCmdlet(); mockClient.Verify(c => c.SwitchSlots("webspace1", "website1", slot1, slot2), Times.Once()); }
public List <AzureSubscription> GetSubscriptions(AzureProfile profile) { string subscriptions = string.Empty; List <AzureSubscription> subscriptionsList = new List <AzureSubscription>(); if (Properties.ContainsKey(Property.Subscriptions)) { subscriptions = Properties[Property.Subscriptions]; } foreach (var subscription in subscriptions.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { try { Guid subscriptionId = new Guid(subscription); Debug.Assert(profile.Subscriptions.ContainsKey(subscriptionId)); subscriptionsList.Add(profile.Subscriptions[subscriptionId]); } catch { // Skip } } return(subscriptionsList); }
public void BaseSetup() { if (AzureSession.DataStore != null && !(AzureSession.DataStore is MemoryDataStore)) { AzureSession.DataStore = new MemoryDataStore(); } currentProfile = new AzureProfile(); if (currentProfile.Context.Subscription == null) { var newGuid = Guid.NewGuid(); currentProfile.Subscriptions[newGuid] = new AzureSubscription { Id = newGuid, Name = "test", Environment = EnvironmentName.AzureCloud, Account = "test" }; currentProfile.Accounts["test"] = new AzureAccount { Id = "test", Type = AzureAccount.AccountType.User, Properties = new Dictionary<AzureAccount.Property, string> { {AzureAccount.Property.Subscriptions, newGuid.ToString()} } }; currentProfile.DefaultSubscription = currentProfile.Subscriptions[newGuid]; } AzureSession.AuthenticationFactory = new MockTokenAuthenticationFactory(); }
/// <summary> /// Creates new WebsitesClient /// </summary> /// <param name="subscription">Subscription containing websites to manipulate</param> /// <param name="logger">The logger action</param> public WebsitesClient(AzureProfile profile, AzureSubscription subscription, Action<string> logger) { Logger = logger; cloudServiceClient = new CloudServiceClient(profile, subscription, debugStream: logger); WebsiteManagementClient = AzureSession.ClientFactory.CreateClient<WebSiteManagementClient>(profile, subscription, AzureEnvironment.Endpoint.ServiceManagement); this.subscription = subscription; }
public void DisableAzureWebsiteApplicationDiagnosticApplication() { // Setup websitesClientMock.Setup(f => f.DisableApplicationDiagnostic( websiteName, WebsiteDiagnosticOutput.FileSystem, null)); disableAzureWebsiteApplicationDiagnosticCommand = new DisableAzureWebsiteApplicationDiagnosticCommand() { CommandRuntime = commandRuntimeMock.Object, Name = websiteName, WebsitesClient = websitesClientMock.Object, File = true, }; currentProfile = new AzureProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Test disableAzureWebsiteApplicationDiagnosticCommand.ExecuteCmdlet(); // Assert websitesClientMock.Verify(f => f.DisableApplicationDiagnostic( websiteName, WebsiteDiagnosticOutput.FileSystem, null), Times.Once()); commandRuntimeMock.Verify(f => f.WriteObject(true), Times.Never()); }
/// <summary> /// Determines the API version. /// </summary> /// <param name="profile">The azure profile.</param> /// <param name="providerNamespace">The provider namespace.</param> /// <param name="resourceType">The resource type.</param> /// <param name="cancellationToken">The cancellation token</param> /// <param name="pre">When specified, indicates if pre-release API versions should be considered.</param> internal static Task<string> DetermineApiVersion(AzureProfile profile, string providerNamespace, string resourceType, CancellationToken cancellationToken, bool? pre = null) { var cacheKey = ApiVersionCache.GetCacheKey(providerNamespace: providerNamespace, resourceType: resourceType); var apiVersions = ApiVersionCache.Instance .AddOrGetExisting(cacheKey: cacheKey, getFreshData: () => ApiVersionHelper.GetApiVersionsForResourceType( profile: profile, providerNamespace: providerNamespace, resourceType: resourceType, cancellationToken: cancellationToken)); apiVersions = apiVersions.CoalesceEnumerable().ToArray(); var apiVersionsToSelectFrom = apiVersions; if (pre == null || pre == false) { apiVersionsToSelectFrom = apiVersions .Where(apiVersion => apiVersion.IsDecimal(NumberStyles.AllowDecimalPoint) || apiVersion.IsDateTime("yyyy-mm-dd", DateTimeStyles.None)) .ToArray(); } var selectedApiVersion = apiVersionsToSelectFrom.OrderByDescending(apiVersion => apiVersion).FirstOrDefault(); if (string.IsNullOrWhiteSpace(selectedApiVersion) && apiVersions.Any()) { // fall back on pre-release APIs if they're the only ones available. selectedApiVersion = apiVersions.OrderByDescending(apiVersion => apiVersion).FirstOrDefault(); } var result = string.IsNullOrWhiteSpace(selectedApiVersion) ? Constants.DefaultApiVersion : selectedApiVersion; return Task.FromResult(result); }
public void ClearAzureProfileClearsDefaultProfile() { ClearAzureProfileCommand cmdlt = new ClearAzureProfileCommand(); // Setup var profile = new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile)); AzurePSCmdlet.CurrentProfile = profile; ProfileClient client = new ProfileClient(profile); client.AddOrSetAccount(azureAccount); client.AddOrSetEnvironment(azureEnvironment); client.AddOrSetSubscription(azureSubscription1); client.Profile.Save(); cmdlt.CommandRuntime = commandRuntimeMock; cmdlt.Force = new SwitchParameter(true); // Act cmdlt.InvokeBeginProcessing(); cmdlt.ExecuteCmdlet(); cmdlt.InvokeEndProcessing(); // Verify client = new ProfileClient(new AzureProfile(Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile))); Assert.Equal(0, client.Profile.Subscriptions.Count); Assert.Equal(0, client.Profile.Accounts.Count); Assert.Equal(2, client.Profile.Environments.Count); //only default environments }
public void ListWebHostingPlansTest() { // Setup var clientMock = new Mock<IWebsitesClient>(); clientMock.Setup(c => c.ListWebSpaces()) .Returns(new[] {new WebSpace {Name = "webspace1"}, new WebSpace {Name = "webspace2"}}); clientMock.Setup(c => c.ListWebHostingPlans()) .Returns(new List<WebHostingPlan> { new WebHostingPlan {Name = "Plan1", WebSpace = "webspace1"}, new WebHostingPlan { Name = "Plan2", WebSpace = "webspace2" } }); // Test var command = new GetAzureWebHostingPlanCommand { CommandRuntime = new MockCommandRuntime(), WebsitesClient = clientMock.Object }; currentProfile = new AzureProfile(); var subscription = new AzureSubscription{Id = new Guid(subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(subscriptionId)] = subscription; command.ExecuteCmdlet(); var plans = System.Management.Automation.LanguagePrimitives.GetEnumerable(((MockCommandRuntime)command.CommandRuntime).OutputPipeline).Cast<WebHostingPlan>(); Assert.NotNull(plans); Assert.Equal(2, plans.Count()); Assert.True(plans.Any(p => (p).Name.Equals("Plan1") && (p).WebSpace.Equals("webspace1"))); Assert.True(plans.Any(p => (p).Name.Equals("Plan2") && (p).WebSpace.Equals("webspace2"))); }
/// <summary> /// Constructs a database adapter /// </summary> /// <param name="profile">The current azure profile</param> /// <param name="subscription">The current azure subscription</param> public AzureSqlDatabaseAdapter(AzureProfile Profile, AzureSubscription subscription) { this.Profile = Profile; this._subscription = subscription; Communicator = new AzureSqlDatabaseCommunicator(Profile, subscription); ElasticPoolCommunicator = new AzureSqlElasticPoolCommunicator(Profile, subscription); }
public void ProcessShowWebsiteTest() { // Setup var mockClient = new Mock<IWebsitesClient>(); mockClient.Setup(c => c.GetWebsite("website1", null)) .Returns(new Site { Name = "website1", WebSpace = "webspace1", HostNames = new[] {"website1.cloudapp.com"} }); // Test ShowAzureWebsiteCommand showAzureWebsiteCommand = new ShowAzureWebsiteCommand { CommandRuntime = new MockCommandRuntime(), Name = "website1", WebsitesClient = mockClient.Object }; currentProfile = new AzureProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; // Show existing website showAzureWebsiteCommand.ExecuteCmdlet(); }
public void StopsWebsiteSlot() { const string slot = "staging"; const string websiteName = "website1"; // Setup Mock<IWebsitesClient> websitesClientMock = new Mock<IWebsitesClient>(); websitesClientMock.Setup(f => f.StopWebsite(websiteName, slot)); // Test StopAzureWebsiteCommand stopAzureWebsiteCommand = new StopAzureWebsiteCommand() { CommandRuntime = new MockCommandRuntime(), Name = websiteName, WebsitesClient = websitesClientMock.Object, Slot = slot }; currentProfile = new AzureProfile(); var subscription = new AzureSubscription{Id = new Guid(base.subscriptionId) }; subscription.Properties[AzureSubscription.Property.Default] = "True"; currentProfile.Subscriptions[new Guid(base.subscriptionId)] = subscription; stopAzureWebsiteCommand.ExecuteCmdlet(); websitesClientMock.Verify(f => f.StopWebsite(websiteName, slot), Times.Once()); }
/// <summary> /// Registers resource providers for Sparta. /// </summary> /// <typeparam name="T">The client type</typeparam> private void RegisterResourceManagerProviders <T>(AzureProfile profile) where T : ServiceClient <T> { var providersToRegister = RequiredResourceLookup.RequiredProvidersForResourceManager <T>(); var registeredProviders = profile.Context.Subscription.GetPropertyAsArray(AzureSubscription.Property.RegisteredResourceProviders); var unregisteredProviders = providersToRegister.Where(p => !registeredProviders.Contains(p)).ToList(); var successfullyRegisteredProvider = new List <string>(); SubscriptionCloudCredentials creds = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(profile.Context); if (unregisteredProviders.Count > 0) { using (var client = ClientFactory.CreateCustomClient <ResourceManagementClient>( creds, profile.Context.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ResourceManager))) { foreach (string provider in unregisteredProviders) { try { client.Providers.Register(provider); successfullyRegisteredProvider.Add(provider); } catch { // Ignore this as the user may not have access to service management endpoint or the provider is already registered } } } UpdateSubscriptionRegisteredProviders(profile, profile.Context.Subscription, successfullyRegisteredProvider); } }
public bool Deserialize(string contents, AzureProfile profile) { ProfileData data; Debug.Assert(profile != null); DeserializeErrors = new List<string>(); DataContractSerializer serializer = new DataContractSerializer(typeof(ProfileData)); using (MemoryStream s = new MemoryStream(Encoding.UTF8.GetBytes(contents ?? ""))) { data = (ProfileData)serializer.ReadObject(s); } if (data != null) { foreach (AzureEnvironmentData oldEnv in data.Environments) { profile.Environments[oldEnv.Name] = oldEnv.ToAzureEnvironment(); } List<AzureEnvironment> envs = profile.Environments.Values.ToList(); foreach (AzureSubscriptionData oldSubscription in data.Subscriptions) { try { var newSubscription = oldSubscription.ToAzureSubscription(envs); if (newSubscription.Account == null) { continue; } var newAccounts = oldSubscription.ToAzureAccounts(); foreach (var account in newAccounts) { if (profile.Accounts.ContainsKey(account.Id)) { profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Tenants, account.GetPropertyAsArray(AzureAccount.Property.Tenants)); profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Subscriptions, account.GetPropertyAsArray(AzureAccount.Property.Subscriptions)); } else { profile.Accounts[account.Id] = account; } } profile.Subscriptions[newSubscription.Id] = newSubscription; } catch (Exception ex) { // Skip subscription if failed to load DeserializeErrors.Add(ex.Message); } } } return DeserializeErrors.Count == 0; }
/// <summary> /// Constructs a database adapter /// </summary> /// <param name="profile">The current azure profile</param> /// <param name="subscription">The current azure subscription</param> public AzureSqlDatabaseReplicationAdapter(AzureProfile Profile, AzureSubscription subscription) { this.Profile = Profile; this._subscription = subscription; ReplicationCommunicator = new AzureSqlDatabaseReplicationCommunicator(Profile, subscription); DatabaseCommunicator = new AzureSqlDatabaseCommunicator(Profile, subscription); ServerCommunicator = new AzureSqlServerCommunicator(Profile, subscription); }
public SqlAuditAdapter(AzureProfile profile, AzureSubscription subscription) { Profile = profile; Subscription = subscription; Communicator = new AuditingEndpointsCommunicator(Profile, subscription); AzureCommunicator = new AzureEndpointsCommunicator(Profile, subscription); IgnoreStorage = false; }
/// <summary> /// Creates a communicator for Azure SQL Server Active Directory administrator /// </summary> /// <param name="profile"></param> /// <param name="subscription"></param> public AzureSqlServerActiveDirectoryAdministratorCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
public ApiManagementClient(AzureProfile azureProfile) { if (azureProfile == null) { throw new ArgumentNullException("azureProfile"); } _azureProfile = azureProfile; }
/// <summary> /// Creates a communicator for Azure Sql Databases TransparentDataEncryption /// </summary> /// <param name="profile"></param> /// <param name="subscription"></param> public AzureSqlDatabaseTransparentDataEncryptionCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
/// <summary> /// Creates a communicator for Azure Sql Recommended Elastic Pool /// </summary> /// <param name="profile"></param> /// <param name="subscription"></param> public AzureSqlElasticPoolRecommendationCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
public SecureConnectionEndpointsCommunicator(AzureProfile profile , AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
/// <summary> /// Creates a communicator for Azure Sql Database backup REST endpoints. /// </summary> /// <param name="profile">Azure profile</param> /// <param name="subscription">Associated subscription</param> public AzureSqlDatabaseBackupCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
public DataMaskingEndpointsCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
/// <summary> /// Creates a communicator for Azure Sql Databases /// </summary> /// <param name="profile"></param> /// <param name="subscription"></param> public AzureSqlServerCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
public string Serialize(AzureProfile profile) { return(JsonConvert.SerializeObject(new { Environments = profile.Environments.Values.ToList(), Subscriptions = profile.Subscriptions.Values.ToList(), Accounts = profile.Accounts.Values.ToList() }, Formatting.Indented)); }
/// <summary> /// Creates a communicator for Azure Sql Databases /// </summary> /// <param name="profile"></param> /// <param name="subscription"></param> public AzureSqlDatabaseIndexRecommendationCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; SqlClient = null; } }
public string Serialize(AzureProfile profile) { return JsonConvert.SerializeObject(new { Environments = profile.Environments.Values.ToList(), Subscriptions = profile.Subscriptions.Values.ToList(), Accounts = profile.Accounts.Values.ToList() }, Formatting.Indented); }
/// <summary> /// Creates new ResourceManagementClient /// </summary> /// <param name="profile">Profile containing resources to manipulate</param> public ResourcesClient(AzureProfile profile) : this( AzureSession.ClientFactory.CreateClient<ResourceManagementClient>(profile, AzureEnvironment.Endpoint.ResourceManager), new GalleryTemplatesClient(profile.Context), // TODO: http://vstfrd:8080/Azure/RD/_workitems#_a=edit&id=3247094 //AzureSession.ClientFactory.CreateClient<EventsClient>(context, AzureEnvironment.Endpoint.ResourceManager), AzureSession.ClientFactory.CreateClient<AuthorizationManagementClient>(profile.Context, AzureEnvironment.Endpoint.ResourceManager)) { }
/// <summary> /// Determines the API version. /// </summary> /// <param name="profile">The azure profile.</param> /// <param name="resourceId">The resource Id.</param> /// <param name="cancellationToken">The cancellation token</param> /// <param name="pre">When specified, indicates if pre-release API versions should be considered.</param> internal static Task<string> DetermineApiVersion(AzureProfile profile, string resourceId, CancellationToken cancellationToken, bool? pre = null) { var providerNamespace = ResourceIdUtility.GetExtensionProviderNamespace(resourceId) ?? ResourceIdUtility.GetProviderNamespace(resourceId); var resourceType = ResourceIdUtility.GetExtensionResourceType(resourceId: resourceId, includeProviderNamespace: false) ?? ResourceIdUtility.GetResourceType(resourceId: resourceId, includeProviderNamespace: false); return ApiVersionHelper.DetermineApiVersion(profile: profile, providerNamespace: providerNamespace, resourceType: resourceType, cancellationToken: cancellationToken, pre: pre); }
/// <summary> /// Default Constructor. /// </summary> /// <param name="profile">The current azure profile</param> /// <param name="subscription">The current azure subscription</param> public AzureEndpointsCommunicator(AzureProfile profile, AzureSubscription subscription) { Profile = profile; if (subscription != Subscription) { Subscription = subscription; StorageClient = null; ResourcesClient = null; StorageV2Client = null; } }
public void NewProfileFromCertificateWithNullsThrowsArgumentNullException() { MemoryDataStore dataStore = new MemoryDataStore(); AzureSession.DataStore = dataStore; AzureProfile newProfile = new AzureProfile(); ProfileClient client1 = new ProfileClient(newProfile); Assert.Throws<ArgumentNullException>(() => client1.InitializeProfile(null, Guid.NewGuid(), new X509Certificate2(), "foo")); Assert.Throws<ArgumentNullException>(() => client1.InitializeProfile(AzureEnvironment.PublicEnvironments["AzureCloud"], Guid.NewGuid(), null, "foo")); }
public bool Deserialize(string contents, AzureProfile profile) { DeserializeErrors = new List <string>(); try { var jsonProfile = JObject.Parse(contents); foreach (var env in jsonProfile["Environments"]) { try { profile.Environments[(string)env["Name"]] = JsonConvert.DeserializeObject <AzureEnvironment>(env.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } foreach (var subscription in jsonProfile["Subscriptions"]) { try { profile.Subscriptions[new Guid((string)subscription["Id"])] = JsonConvert.DeserializeObject <AzureSubscription>(subscription.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } foreach (var account in jsonProfile["Accounts"]) { try { profile.Accounts[(string)account["Id"]] = JsonConvert.DeserializeObject <AzureAccount>(account.ToString()); } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } } } catch (Exception ex) { DeserializeErrors.Add(ex.Message); } return(DeserializeErrors.Count == 0); }
public void Apply <TClient>(TClient client, AzureProfile profile, AzureEnvironment.Endpoint endpoint) where TClient : ServiceClient <TClient> { Debug.Assert(ClientFactory != null); if (endpoint == AzureEnvironment.Endpoint.ServiceManagement) { RegisterServiceManagementProviders <TClient>(profile); } else if (endpoint == AzureEnvironment.Endpoint.ResourceManager) { RegisterResourceManagerProviders <TClient>(profile); } }
private void UpdateSubscriptionRegisteredProviders(AzureProfile profile, AzureSubscription subscription, List <string> providers) { if (providers != null && providers.Count > 0) { subscription.SetOrAppendProperty(AzureSubscription.Property.RegisteredResourceProviders, providers.ToArray()); try { ProfileClient profileClient = new ProfileClient(profile); profileClient.AddOrSetSubscription(subscription); profileClient.Profile.Save(); } catch (KeyNotFoundException) { // if using a subscription data file, do not write registration to disk // long term solution is using -Profile parameter } } }
/// <summary> /// Registers resource providers for RDFE. /// </summary> /// <typeparam name="T">The client type</typeparam> private void RegisterServiceManagementProviders <T>(AzureProfile profile) where T : ServiceClient <T> { var credentials = AzureSession.AuthenticationFactory.GetSubscriptionCloudCredentials(profile.Context); var providersToRegister = RequiredResourceLookup.RequiredProvidersForServiceManagement <T>(); var registeredProviders = profile.Context.Subscription.GetPropertyAsArray(AzureSubscription.Property.RegisteredResourceProviders); var unregisteredProviders = providersToRegister.Where(p => !registeredProviders.Contains(p)).ToList(); var successfullyRegisteredProvider = new List <string>(); if (unregisteredProviders.Count > 0) { using (var client = new ManagementClient( credentials, profile.Context.Environment.GetEndpointAsUri(AzureEnvironment.Endpoint.ServiceManagement))) { foreach (var provider in unregisteredProviders) { try { client.Subscriptions.RegisterResource(provider); } catch (CloudException ex) { if (ex.Response.StatusCode != HttpStatusCode.Conflict && ex.Response.StatusCode != HttpStatusCode.NotFound) { // Conflict means already registered, that's OK. // NotFound means there is no registration support, like Windows Azure Pack. // Otherwise it's a failure. throw; } } successfullyRegisteredProvider.Add(provider); } } UpdateSubscriptionRegisteredProviders(profile, profile.Context.Subscription, successfullyRegisteredProvider); } }
public bool Deserialize(string contents, AzureProfile profile) { ProfileData data; Debug.Assert(profile != null); DeserializeErrors = new List <string>(); DataContractSerializer serializer = new DataContractSerializer(typeof(ProfileData)); using (MemoryStream s = new MemoryStream(Encoding.UTF8.GetBytes(contents ?? ""))) { data = (ProfileData)serializer.ReadObject(s); } if (data != null) { foreach (AzureEnvironmentData oldEnv in data.Environments) { profile.Environments[oldEnv.Name] = oldEnv.ToAzureEnvironment(); } List <AzureEnvironment> envs = profile.Environments.Values.ToList(); foreach (AzureSubscriptionData oldSubscription in data.Subscriptions) { try { var newSubscription = oldSubscription.ToAzureSubscription(envs); if (newSubscription.Account == null) { continue; } var newAccounts = oldSubscription.ToAzureAccounts(); foreach (var account in newAccounts) { if (profile.Accounts.ContainsKey(account.Id)) { profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Tenants, account.GetPropertyAsArray(AzureAccount.Property.Tenants)); profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Subscriptions, account.GetPropertyAsArray(AzureAccount.Property.Subscriptions)); } else { profile.Accounts[account.Id] = account; } } profile.Subscriptions[newSubscription.Id] = newSubscription; } catch (Exception ex) { // Skip subscription if failed to load DeserializeErrors.Add(ex.Message); } } } return(DeserializeErrors.Count == 0); }
public string Serialize(AzureProfile obj) { // We do not use the serialize for xml serializer anymore and rely solely on the JSON serializer. throw new NotImplementedException(); }