public CreateLoadBalancerRequest(LoadBalancerConfiguration configuration) { if (configuration == null) throw new ArgumentNullException("configuration"); _configuration = configuration; }
/// <summary> /// Generates the model from user input. /// </summary> /// <param name="model">This is null since the Availability Group Listener doesn't exist yet</param> /// <returns>The generated model from user input</returns> protected override IEnumerable <AzureAvailabilityGroupListenerModel> ApplyUserInputToModel(IEnumerable <AzureAvailabilityGroupListenerModel> model) { List <AzureAvailabilityGroupListenerModel> newEntity = new List <AzureAvailabilityGroupListenerModel>(); var privateIpAddress = new PrivateIPAddress() { IpAddress = this.IpAddress, SubnetResourceId = this.SubnetId }; var loadBalancerConfiguration = new LoadBalancerConfiguration() { LoadBalancerResourceId = this.LoadBalancerResourceId, PrivateIpAddress = privateIpAddress, ProbePort = this.ProbePort, PublicIpAddressResourceId = this.PublicIpAddressResourceId, SqlVirtualMachineInstances = this.SqlVirtualMachineId }; var loadBalancerConfigurations = new List <LoadBalancerConfiguration>(); loadBalancerConfigurations.Add(loadBalancerConfiguration); newEntity.Add(new AzureAvailabilityGroupListenerModel(ResourceGroupName, SqlVMGroupName) { AvailabilityGroupName = this.AvailabilityGroupName, Name = this.Name, Port = this.Port, LoadBalancerConfigurations = loadBalancerConfigurations }); return(newEntity); }
public CreateLoadBalancerRequest(LoadBalancerConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException("configuration"); } _configuration = configuration; }
public LoadBalancer(LoadBalancerConfiguration loadBalancerConfiguration) { _localhost = loadBalancerConfiguration.Localhost; _localPorts = loadBalancerConfiguration.LocalPorts; _foreignHost = loadBalancerConfiguration.ForeignHost; _foreignPort = loadBalancerConfiguration.ForeignPort; _user = loadBalancerConfiguration.User; _password = loadBalancerConfiguration.Password; _protocolPort = loadBalancerConfiguration.ProtocolPort; _currentProtocol = loadBalancerConfiguration.CurrentProtocol; }
public async Task TestListCurrentUsage() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); IEnumerable<LoadBalancerUsage> usage = await provider.ListCurrentUsageAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(usage); LoadBalancerUsage[] usageRecords = usage.ToArray(); if (usageRecords.Length == 0) Assert.Inconclusive("No current usage was reported for load balancer: {0}", tempLoadBalancer.Id); Console.WriteLine("Current Load Balancer Usage ({0} records)", usageRecords.Length); foreach (LoadBalancerUsage usageRecord in usageRecords) Console.WriteLine(JsonConvert.SerializeObject(usageRecord, Formatting.Indented)); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestAddRemoveVirtualAddresses() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(240)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); IEnumerable<LoadBalancerVirtualAddress> addresses = await provider.ListVirtualAddressesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); if (!addresses.Any()) Assert.Inconclusive("The load balancer did not report any virtual addresses."); Console.WriteLine("Initial virtual addresses"); foreach (var address in addresses) Console.WriteLine("{0}: {1} ({2}, {3})", address.Id, address.Address, address.IPVersion, address.Type); List<LoadBalancerVirtualAddress> addedAddresses = new List<LoadBalancerVirtualAddress>(); for (int i = 0; i < 4; i++) { // add a virtual address LoadBalancerVirtualAddress addedAddress = await provider.AddVirtualAddressAsync(tempLoadBalancer.Id, LoadBalancerVirtualAddressType.Public, AddressFamily.InterNetworkV6, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.IsNotNull(addedAddress); Assert.IsNotNull(addedAddress.Address); Assert.AreEqual(AddressFamily.InterNetworkV6, addedAddress.Address.AddressFamily); addedAddresses.Add(addedAddress); } addresses = await provider.ListVirtualAddressesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Console.WriteLine("After adding IPv6 virtual address"); foreach (var address in addresses) Console.WriteLine("{0}: {1} ({2}, {3})", address.Id, address.Address, address.IPVersion, address.Type); // remove a single virtual address await provider.RemoveVirtualAddressAsync(tempLoadBalancer.Id, addedAddresses[0].Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); addresses = await provider.ListVirtualAddressesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Console.WriteLine("After removing 1 IPv6 virtual address"); foreach (var address in addresses) Console.WriteLine("{0}: {1} ({2}, {3})", address.Id, address.Address, address.IPVersion, address.Type); // remove multiple virtual addresses await provider.RemoveVirtualAddressRangeAsync(tempLoadBalancer.Id, new[] { addedAddresses[1].Id, addedAddresses[3].Id }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); addresses = await provider.ListVirtualAddressesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Console.WriteLine("After removing 1 IPv6 virtual address"); foreach (var address in addresses) Console.WriteLine("{0}: {1} ({2}, {3})", address.Id, address.Address, address.IPVersion, address.Type); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestListBillableLoadBalancers() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); IEnumerable<LoadBalancer> billable = await provider.ListBillableLoadBalancersAsync(DateTimeOffset.Now.Date.AddDays(-60), DateTimeOffset.Now.Date.AddDays(1), null, null, cancellationTokenSource.Token); Assert.IsNotNull(billable); LoadBalancer[] loadBalancers = billable.ToArray(); if (loadBalancers.Length == 0) Assert.Inconclusive("No billable load balancers were reported."); Console.WriteLine("Billable Load Balancers:"); foreach (LoadBalancer loadBalancer in loadBalancers) Console.WriteLine(" {0}", loadBalancer.Id); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestListNodeServiceEvents() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IPHostEntry entry = await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("docs.rackspace.com", null, null), Dns.EndGetHostEntry); IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: new[] { new NodeConfiguration(entry.AddressList[0], 80, NodeCondition.Enabled, NodeType.Primary, null) }, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Node node = tempLoadBalancer.Nodes.Single(); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Status); NodeUpdate updatedNodeConfiguration = new NodeUpdate(condition: NodeCondition.Draining); await provider.UpdateNodeAsync(tempLoadBalancer.Id, node.Id, updatedNodeConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); NodeServiceEvent[] serviceEvents = ListAllNodeServiceEvents(provider, tempLoadBalancer.Id, null, cancellationTokenSource.Token).ToArray(); if (!serviceEvents.Any()) Assert.Inconclusive("The load balancer did not report any node service events."); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestListVirtualAddresses() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); IEnumerable<LoadBalancerVirtualAddress> addresses = await provider.ListVirtualAddressesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); if (!addresses.Any()) Assert.Inconclusive("The load balancer did not report any virtual addresses."); foreach (var address in addresses) { Console.WriteLine("{0}: {1} ({2}, {3})", address.Id, address.Address, address.IPVersion, address.Type); } /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public static LoadBalancer CreateLoadBalancer(this ILoadBalancerService service, LoadBalancerConfiguration configuration) { if (service == null) throw new ArgumentNullException("service"); try { return service.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestSubmitted, CancellationToken.None, null).Result; } catch (AggregateException ex) { ReadOnlyCollection<Exception> innerExceptions = ex.Flatten().InnerExceptions; if (innerExceptions.Count == 1) throw innerExceptions[0]; throw; } }
public async Task TestSetSourceAddressSessionPersistence() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol ldapProtocol = protocols.First(i => i.Name.Equals("LDAP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: ldapProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: null, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // verify initially null SessionPersistence sessionPersistence = await provider.GetSessionPersistenceAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(sessionPersistence); Assert.IsNull(sessionPersistence.PersistenceType); // set to source address await provider.SetSessionPersistenceAsync(tempLoadBalancer.Id, new SessionPersistence(SessionPersistenceType.SourceAddress), AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); sessionPersistence = await provider.GetSessionPersistenceAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(sessionPersistence); Assert.AreEqual(SessionPersistenceType.SourceAddress, sessionPersistence.PersistenceType); // set to source address again await provider.SetSessionPersistenceAsync(tempLoadBalancer.Id, new SessionPersistence(SessionPersistenceType.SourceAddress), AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); sessionPersistence = await provider.GetSessionPersistenceAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(sessionPersistence); Assert.AreEqual(SessionPersistenceType.SourceAddress, sessionPersistence.PersistenceType); // should fail to set to HTTP cookie try { try { await provider.SetSessionPersistenceAsync(tempLoadBalancer.Id, new SessionPersistence(SessionPersistenceType.HttpCookie), AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.Fail("Expected a WebException"); } catch (WebException ex) { throw new AggregateException(ex); } } catch (AggregateException aggregate) { aggregate.Flatten().Handle( ex => { WebException webException = ex as WebException; if (webException == null) return false; HttpWebResponse response = webException.Response as HttpWebResponse; if (response == null) return false; Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); return true; }); } sessionPersistence = await provider.GetSessionPersistenceAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(sessionPersistence); Assert.AreEqual(SessionPersistenceType.SourceAddress, sessionPersistence.PersistenceType); // set to none await provider.RemoveSessionPersistenceAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); sessionPersistence = await provider.GetSessionPersistenceAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(sessionPersistence); Assert.IsNull(sessionPersistence.PersistenceType); try { try { // set to none again await provider.RemoveSessionPersistenceAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.Fail("Expected a WebException"); } catch (WebException ex) { throw new AggregateException(ex); } } catch (AggregateException aggregate) { aggregate.Flatten().Handle( ex => { WebException webException = ex as WebException; if (webException == null) return false; HttpWebResponse response = webException.Response as HttpWebResponse; if (response == null) return false; Assert.AreEqual((HttpStatusCode)422, response.StatusCode); return true; }); } sessionPersistence = await provider.GetSessionPersistenceAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(sessionPersistence); Assert.IsNull(sessionPersistence.PersistenceType); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestNodeMetadata() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IPHostEntry entry = await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("docs.rackspace.com", null, null), Dns.EndGetHostEntry); IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); string expectedKey = "key1"; string expectedValue = "value!!"; LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: new[] { new NodeConfiguration(entry.AddressList[0], 80, NodeCondition.Enabled, NodeType.Primary, null) }, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Node node = tempLoadBalancer.Nodes.Single(); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Status); // can't set node metadata during the initial creation, so we set it right afterwards await provider.AddNodeMetadataAsync(tempLoadBalancer.Id, node.Id, new Dictionary<string, string> { { expectedKey, expectedValue } }, cancellationTokenSource.Token); IEnumerable<LoadBalancerMetadataItem> metadata = await provider.ListNodeMetadataAsync(tempLoadBalancer.Id, node.Id, cancellationTokenSource.Token); Assert.IsNotNull(metadata); LoadBalancerMetadataItem expectedItem = null; foreach (LoadBalancerMetadataItem item in metadata) { Console.WriteLine(" {0}: {1} = {2}", item.Id, item.Key, item.Value); LoadBalancerMetadataItem singleItem = await provider.GetNodeMetadataItemAsync(tempLoadBalancer.Id, node.Id, item.Id, cancellationTokenSource.Token); Assert.AreEqual(item.Id, singleItem.Id); Assert.AreEqual(item.Key, singleItem.Key); Assert.AreEqual(item.Value, singleItem.Value); if (item.Key == expectedKey) expectedItem = item; } Assert.IsNotNull(expectedItem); Assert.AreEqual(expectedKey, expectedItem.Key); Assert.AreEqual(expectedValue, expectedItem.Value); string updatedValue = "My new value."; await provider.UpdateNodeMetadataItemAsync(tempLoadBalancer.Id, node.Id, expectedItem.Id, updatedValue, cancellationTokenSource.Token); // verify that the update command did not place the load balancer in the "PendingUpdate" state Assert.AreEqual(NodeStatus.Online, (await provider.GetNodeAsync(tempLoadBalancer.Id, node.Id, cancellationTokenSource.Token)).Status); expectedItem = await provider.GetNodeMetadataItemAsync(tempLoadBalancer.Id, node.Id, expectedItem.Id, cancellationTokenSource.Token); Assert.IsNotNull(expectedItem); Assert.AreEqual(expectedKey, expectedItem.Key); Assert.AreEqual(updatedValue, expectedItem.Value); string expectedSecondKey = "key2"; Dictionary<string, string> updatedMetadata = new Dictionary<string, string> { { expectedSecondKey, expectedValue } }; IEnumerable<LoadBalancerMetadataItem> updateMetadataItems = await provider.AddNodeMetadataAsync(tempLoadBalancer.Id, node.Id, updatedMetadata, cancellationTokenSource.Token); LoadBalancerMetadataItem secondItem = updateMetadataItems.SingleOrDefault(); Assert.IsNotNull(secondItem); Assert.AreEqual(expectedSecondKey, secondItem.Key); Assert.AreEqual(expectedValue, secondItem.Value); await provider.RemoveNodeMetadataItemAsync(tempLoadBalancer.Id, node.Id, new[] { expectedItem.Id, secondItem.Id }, cancellationTokenSource.Token); metadata = await provider.ListNodeMetadataAsync(tempLoadBalancer.Id, node.Id, cancellationTokenSource.Token); Assert.IsNotNull(metadata); Assert.IsFalse(metadata.Any()); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestCreatePtrRecords() { string domainName = CreateRandomDomainName(); string loadBalancerName = UserLoadBalancerTests.CreateRandomLoadBalancerName(); IDnsService provider = CreateProvider(); ILoadBalancerService loadBalancerProvider = UserLoadBalancerTests.CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable <LoadBalancingProtocol> protocols = await loadBalancerProvider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); LoadBalancerConfiguration loadBalancerConfiguration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer loadBalancer = await loadBalancerProvider.CreateLoadBalancerAsync(loadBalancerConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.IsNotNull(loadBalancer.VirtualAddresses); Assert.IsTrue(loadBalancer.VirtualAddresses.Count > 0); string originalData = loadBalancer.VirtualAddresses[0].Address.ToString(); string originalName = string.Format("www.{0}", domainName); string updatedName = string.Format("www2.{0}", domainName); string originalCommentValue = "Integration test record"; string updatedCommentValue = "Integration test record 2"; TimeSpan?originalTimeToLive; TimeSpan?updatedTimeToLive = TimeSpan.FromMinutes(12); DnsDomainRecordConfiguration[] recordConfigurations = { new DnsDomainRecordConfiguration( type: DnsRecordType.Ptr, name: string.Format("www.{0}",domainName), data: originalData, timeToLive: null, comment: originalCommentValue, priority: null) }; string serviceName = "cloudLoadBalancers"; Uri deviceResourceUri = await((UserLoadBalancerTests.TestCloudLoadBalancerProvider)loadBalancerProvider).GetDeviceResourceUri(loadBalancer, cancellationTokenSource.Token); DnsJob <DnsRecordsList> recordsResponse = await provider.AddPtrRecordsAsync(serviceName, deviceResourceUri, recordConfigurations, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.IsNotNull(recordsResponse.Response); Assert.IsNotNull(recordsResponse.Response.Records); DnsRecord[] records = recordsResponse.Response.Records.ToArray(); Assert.AreEqual(recordConfigurations.Length, records.Length); originalTimeToLive = records[0].TimeToLive; Assert.AreNotEqual(originalTimeToLive, updatedTimeToLive); Assert.AreEqual(originalData, records[0].Data); Assert.AreEqual(originalTimeToLive, records[0].TimeToLive); Assert.AreEqual(originalCommentValue, records[0].Comment); foreach (var record in records) { Console.WriteLine(); Console.WriteLine("Record: {0} ({1})", record.Name, record.Id); Console.WriteLine(); Console.WriteLine(await JsonConvert.SerializeObjectAsync(record, Formatting.Indented)); } // update the comment and verify nothing else changed DnsDomainRecordUpdateConfiguration recordUpdateConfiguration = new DnsDomainRecordUpdateConfiguration(records[0], originalName, originalData, comment: updatedCommentValue); await provider.UpdatePtrRecordsAsync(serviceName, deviceResourceUri, new[] { recordUpdateConfiguration }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); DnsRecord updatedRecord = await provider.ListPtrRecordDetailsAsync(serviceName, deviceResourceUri, records[0].Id, cancellationTokenSource.Token); Assert.IsNotNull(updatedRecord); Assert.AreEqual(originalData, updatedRecord.Data); Assert.AreEqual(originalName, updatedRecord.Name); Assert.AreEqual(originalTimeToLive, updatedRecord.TimeToLive); Assert.AreEqual(updatedCommentValue, updatedRecord.Comment); // update the TTL and verify nothing else changed recordUpdateConfiguration = new DnsDomainRecordUpdateConfiguration(records[0], originalName, originalData, timeToLive: updatedTimeToLive); await provider.UpdatePtrRecordsAsync(serviceName, deviceResourceUri, new[] { recordUpdateConfiguration }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); updatedRecord = await provider.ListPtrRecordDetailsAsync(serviceName, deviceResourceUri, records[0].Id, cancellationTokenSource.Token); Assert.IsNotNull(updatedRecord); Assert.AreEqual(originalData, updatedRecord.Data); Assert.AreEqual(originalName, updatedRecord.Name); Assert.AreEqual(updatedTimeToLive, updatedRecord.TimeToLive); Assert.AreEqual(updatedCommentValue, updatedRecord.Comment); // update the name and verify nothing else changed recordUpdateConfiguration = new DnsDomainRecordUpdateConfiguration(records[0], updatedName, originalData); await provider.UpdatePtrRecordsAsync(serviceName, deviceResourceUri, new[] { recordUpdateConfiguration }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); updatedRecord = await provider.ListPtrRecordDetailsAsync(serviceName, deviceResourceUri, records[0].Id, cancellationTokenSource.Token); Assert.IsNotNull(updatedRecord); Assert.AreEqual(originalData, updatedRecord.Data); Assert.AreEqual(updatedName, updatedRecord.Name); Assert.AreEqual(updatedTimeToLive, updatedRecord.TimeToLive); Assert.AreEqual(updatedCommentValue, updatedRecord.Comment); // remove the PTR record // TODO: verify result? await provider.RemovePtrRecordsAsync(serviceName, deviceResourceUri, loadBalancer.VirtualAddresses[0].Address, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); /* Cleanup */ await loadBalancerProvider.RemoveLoadBalancerAsync(loadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestSslTermination() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(240)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); string privateKey; string certificate; CngKeyCreationParameters keyParams = new CngKeyCreationParameters(); keyParams.ExportPolicy = CngExportPolicies.AllowExport | CngExportPolicies.AllowPlaintextExport; keyParams.KeyUsage = CngKeyUsages.AllUsages; keyParams.Provider = CngProvider.MicrosoftSoftwareKeyStorageProvider; using (CngKey key = CngKey.Create(CngAlgorithm2.Rsa, Guid.NewGuid().ToString(), keyParams)) { byte[] exported = key.Export(CngKeyBlobFormat.Pkcs8PrivateBlob); StringBuilder formatted = new StringBuilder(); formatted.AppendLine("-----BEGIN RSA PRIVATE KEY-----"); formatted.AppendLine(Convert.ToBase64String(exported, Base64FormattingOptions.InsertLineBreaks)); formatted.Append("-----END RSA PRIVATE KEY-----"); Console.WriteLine(formatted.ToString()); privateKey = formatted.ToString(); X509CertificateCreationParameters certParams = new X509CertificateCreationParameters(new X500DistinguishedName(string.Format("CN={0}, OU=Integration Testing, O=openstacknetsdk, L=San Antonio, S=Texas, C=US", loadBalancerName))); certParams.SignatureAlgorithm = X509CertificateSignatureAlgorithm.RsaSha1; certParams.StartTime = DateTime.Now; certParams.EndTime = DateTime.Now.AddYears(10); certParams.TakeOwnershipOfKey = true; X509Certificate signed = key.CreateSelfSignedCertificate(certParams); exported = signed.Export(X509ContentType.Cert); formatted = new StringBuilder(); formatted.AppendLine("-----BEGIN CERTIFICATE-----"); formatted.AppendLine(Convert.ToBase64String(exported, Base64FormattingOptions.InsertLineBreaks)); formatted.Append("-----END CERTIFICATE-----"); Console.WriteLine(formatted.ToString()); certificate = formatted.ToString(); } string intermediateCertificate = null; LoadBalancerSslConfiguration sslConfiguration = new LoadBalancerSslConfiguration(true, false, 443, privateKey, certificate, intermediateCertificate); await provider.UpdateSslConfigurationAsync(tempLoadBalancer.Id, sslConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); LoadBalancerSslConfiguration updatedConfiguration = new LoadBalancerSslConfiguration(true, true, 443); await provider.UpdateSslConfigurationAsync(tempLoadBalancer.Id, updatedConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); await provider.RemoveSslConfigurationAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestLoadBalancerMetadata() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); string expectedKey = "key1"; string expectedValue = "value!!"; LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin, metadata: new[] { new LoadBalancerMetadataItem(expectedKey, expectedValue) }); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Status); IEnumerable<LoadBalancerMetadataItem> metadata = await provider.ListLoadBalancerMetadataAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(metadata); LoadBalancerMetadataItem expectedItem = null; foreach (LoadBalancerMetadataItem item in metadata) { Console.WriteLine(" {0}: {1} = {2}", item.Id, item.Key, item.Value); LoadBalancerMetadataItem singleItem = await provider.GetLoadBalancerMetadataItemAsync(tempLoadBalancer.Id, item.Id, cancellationTokenSource.Token); Assert.AreEqual(item.Id, singleItem.Id); Assert.AreEqual(item.Key, singleItem.Key); Assert.AreEqual(item.Value, singleItem.Value); if (item.Key == expectedKey) expectedItem = item; } Assert.IsNotNull(expectedItem); Assert.AreEqual(expectedKey, expectedItem.Key); Assert.AreEqual(expectedValue, expectedItem.Value); string updatedValue = "My new value."; await provider.UpdateLoadBalancerMetadataItemAsync(tempLoadBalancer.Id, expectedItem.Id, updatedValue, cancellationTokenSource.Token); // verify that the update command did not place the load balancer in the "PendingUpdate" state Assert.AreEqual(LoadBalancerStatus.Active, (await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token)).Status); expectedItem = await provider.GetLoadBalancerMetadataItemAsync(tempLoadBalancer.Id, expectedItem.Id, cancellationTokenSource.Token); Assert.IsNotNull(expectedItem); Assert.AreEqual(expectedKey, expectedItem.Key); Assert.AreEqual(updatedValue, expectedItem.Value); string expectedSecondKey = "key2"; Dictionary<string, string> updatedMetadata = new Dictionary<string, string> { { expectedSecondKey, expectedValue } }; IEnumerable<LoadBalancerMetadataItem> updateMetadataItems = await provider.AddLoadBalancerMetadataAsync(tempLoadBalancer.Id, updatedMetadata, cancellationTokenSource.Token); LoadBalancerMetadataItem secondItem = updateMetadataItems.SingleOrDefault(); Assert.IsNotNull(secondItem); Assert.AreEqual(expectedSecondKey, secondItem.Key); Assert.AreEqual(expectedValue, secondItem.Value); await provider.RemoveLoadBalancerMetadataItemAsync(tempLoadBalancer.Id, new[] { expectedItem.Id, secondItem.Id }, cancellationTokenSource.Token); metadata = await provider.ListLoadBalancerMetadataAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(metadata); Assert.IsFalse(metadata.Any()); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestSetContentCaching() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: false, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // verify initially false bool contentCaching = await provider.GetContentCachingAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsFalse(contentCaching); // set to true await provider.SetContentCachingAsync(tempLoadBalancer.Id, true, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); contentCaching = await provider.GetContentCachingAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsTrue(contentCaching); // set to true again await provider.SetContentCachingAsync(tempLoadBalancer.Id, true, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); contentCaching = await provider.GetContentCachingAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsTrue(contentCaching); // set to false await provider.SetContentCachingAsync(tempLoadBalancer.Id, false, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); contentCaching = await provider.GetContentCachingAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsFalse(contentCaching); // set to false again await provider.SetContentCachingAsync(tempLoadBalancer.Id, false, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); contentCaching = await provider.GetContentCachingAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsFalse(contentCaching); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestUpdateLoadBalancer() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); string loadBalancerRename = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: null, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.IsNotNull(tempLoadBalancer); Assert.AreEqual(loadBalancerName, tempLoadBalancer.Name); LoadBalancerUpdate updatedConfiguration = new LoadBalancerUpdate(name: loadBalancerRename); await provider.UpdateLoadBalancerAsync(tempLoadBalancer.Id, updatedConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); LoadBalancer renamed = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(renamed); Assert.AreEqual(tempLoadBalancer.Id, renamed.Id); Assert.AreEqual(loadBalancerRename, renamed.Name); await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestConnectionThrottleConfiguration() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: null, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Status); Assert.IsNull(tempLoadBalancer.ConnectionThrottles); Console.WriteLine("Reported by create:"); Console.WriteLine(JsonConvert.SerializeObject(tempLoadBalancer.ConnectionThrottles, Formatting.Indented)); ConnectionThrottles throttles = await provider.ListThrottlesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Console.WriteLine("After create:"); Console.WriteLine(JsonConvert.SerializeObject(throttles, Formatting.Indented)); int maxConnectionRate = 3; int maxConnections = 2; int minConnections = 1; TimeSpan rateInterval = TimeSpan.FromSeconds(5); throttles = new ConnectionThrottles(maxConnectionRate, maxConnections, minConnections, rateInterval); await provider.UpdateThrottlesAsync(tempLoadBalancer.Id, throttles, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); throttles = await provider.ListThrottlesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.AreEqual(maxConnectionRate, throttles.MaxConnectionRate); Assert.AreEqual(maxConnections, throttles.MaxConnections); Assert.AreEqual(minConnections, throttles.MinConnections); Assert.AreEqual(rateInterval, throttles.RateInterval); Console.WriteLine("After update:"); Console.WriteLine(JsonConvert.SerializeObject(throttles, Formatting.Indented)); await provider.RemoveThrottlesAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); throttles = await provider.ListThrottlesAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Console.WriteLine("After removal:"); Console.WriteLine(JsonConvert.SerializeObject(throttles, Formatting.Indented)); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestAccessLists() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // verify initially null IEnumerable<NetworkItem> accessList = await provider.ListAccessListAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(accessList); Assert.IsFalse(accessList.Any()); // allow docs.rackspace.com IPHostEntry resolved = await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("docs.rackspace.com", null, null), Dns.EndGetHostEntry); NetworkItem firstNetworkItem = new NetworkItem(resolved.AddressList[0], AccessType.Allow); await provider.CreateAccessListAsync(tempLoadBalancer.Id, firstNetworkItem, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); //List<NetworkItem> expected = new List<NetworkItem> { firstNetworkItem }; LoadBalancer loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(loadBalancer.AccessList); Assert.AreEqual(1, loadBalancer.AccessList.Count); Assert.AreEqual(firstNetworkItem.Address, loadBalancer.AccessList[0].Address); Assert.AreEqual(firstNetworkItem.AccessType, loadBalancer.AccessList[0].AccessType); //for (int i = 0; i < expected.Count; i++) //{ // Assert.AreEqual(expected[i].Address, loadBalancer.AccessList[i].Address); // Assert.AreEqual(expected[i].AccessType, loadBalancer.AccessList[i].AccessType); //} // allow developer.rackspace.com // deny google.com, yahoo.com, microsoft.com, amazon.com NetworkItem[] batch = new[] { new NetworkItem( (await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("google.com", null, null), Dns.EndGetHostEntry)).AddressList[0], AccessType.Deny), new NetworkItem( (await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("developer.rackspace.com", null, null), Dns.EndGetHostEntry)).AddressList[0], AccessType.Allow), new NetworkItem( (await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("yahoo.com", null, null), Dns.EndGetHostEntry)).AddressList[0], AccessType.Deny), new NetworkItem( (await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("microsoft.com", null, null), Dns.EndGetHostEntry)).AddressList[0], AccessType.Deny), new NetworkItem( (await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("amazon.com", null, null), Dns.EndGetHostEntry)).AddressList[0], AccessType.Deny), }; await provider.CreateAccessListAsync(tempLoadBalancer.Id, batch, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); //expected.AddRange(batch.AsEnumerable().Reverse()); loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(loadBalancer.AccessList); Assert.AreEqual(6, loadBalancer.AccessList.Count); //for (int i = 0; i < expected.Count; i++) //{ // Assert.AreEqual(expected[i].Address, loadBalancer.AccessList[i].Address); // Assert.AreEqual(expected[i].AccessType, loadBalancer.AccessList[i].AccessType); //} // remove a single item from the middle of the access list: developer.rackspace.com await provider.RemoveAccessListAsync(tempLoadBalancer.Id, loadBalancer.AccessList[2].Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); //expected.RemoveAt(2); loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(loadBalancer.AccessList); Assert.AreEqual(5, loadBalancer.AccessList.Count); //for (int i = 0; i < expected.Count; i++) //{ // Assert.AreEqual(expected[i].Address, loadBalancer.AccessList[i].Address); // Assert.AreEqual(expected[i].AccessType, loadBalancer.AccessList[i].AccessType); //} // remove two items from the middle of the access list: developer.rackspace.com await provider.RemoveAccessListRangeAsync(tempLoadBalancer.Id, new[] { loadBalancer.AccessList[0].Id, loadBalancer.AccessList[2].Id }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); //expected.RemoveAt(2); //expected.RemoveAt(0); loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(loadBalancer.AccessList); Assert.AreEqual(3, loadBalancer.AccessList.Count); //for (int i = 0; i < expected.Count; i++) //{ // Assert.AreEqual(expected[i].Address, loadBalancer.AccessList[i].Address); // Assert.AreEqual(expected[i].AccessType, loadBalancer.AccessList[i].AccessType); //} // clear the access list await provider.ClearAccessListAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // clear the access list again try { try { await provider.ClearAccessListAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } catch (WebException ex) { throw new AggregateException(ex); } } catch (AggregateException aggregate) { aggregate.Flatten().Handle( ex => { WebException webException = ex as WebException; if (webException == null) return false; HttpWebResponse response = webException.Response as HttpWebResponse; if (response == null) return false; Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); return true; }); } /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestModifyErrorPage() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(30)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: null, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Status); Console.WriteLine("Error page:"); string defaultErrorPage = await provider.GetErrorPageAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); string customErrorPage = "Some custom error..."; await provider.SetErrorPageAsync(tempLoadBalancer.Id, customErrorPage, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); LoadBalancer details = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.AreEqual(LoadBalancerStatus.Active, details.Status); Assert.AreEqual(customErrorPage, await provider.GetErrorPageAsync(tempLoadBalancer.Id, cancellationTokenSource.Token)); await provider.RemoveErrorPageAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); details = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.AreEqual(LoadBalancerStatus.Active, details.Status); Assert.AreEqual(defaultErrorPage, await provider.GetErrorPageAsync(tempLoadBalancer.Id, cancellationTokenSource.Token)); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestHealthMonitorConnection() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("LDAP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // verify initially null Assert.IsNull(tempLoadBalancer.HealthMonitor); Assert.IsNull(await provider.GetHealthMonitorAsync(tempLoadBalancer.Id, cancellationTokenSource.Token)); // configure the health monitor int attemptsBeforeDeactivation = 3; TimeSpan timeout = TimeSpan.FromSeconds(30); TimeSpan delay = TimeSpan.FromSeconds(30); HealthMonitor monitor = new ConnectionHealthMonitor(attemptsBeforeDeactivation, timeout, delay); await provider.SetHealthMonitorAsync(tempLoadBalancer.Id, monitor, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // set the health monitor again await provider.SetHealthMonitorAsync(tempLoadBalancer.Id, monitor, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // verify the health monitor HealthMonitor healthMonitor = await provider.GetHealthMonitorAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsInstanceOfType(healthMonitor, typeof(ConnectionHealthMonitor)); Assert.AreEqual(HealthMonitorType.Connect, healthMonitor.Type); Assert.AreEqual(attemptsBeforeDeactivation, healthMonitor.AttemptsBeforeDeactivation); Assert.AreEqual(timeout, healthMonitor.Timeout); Assert.AreEqual(delay, healthMonitor.Delay); // verify the information in the load balancer details LoadBalancer loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.AreEqual(tempLoadBalancer.Id, loadBalancer.Id); Assert.IsInstanceOfType(loadBalancer.HealthMonitor, typeof(ConnectionHealthMonitor)); Assert.AreEqual(HealthMonitorType.Connect, loadBalancer.HealthMonitor.Type); Assert.AreEqual(attemptsBeforeDeactivation, loadBalancer.HealthMonitor.AttemptsBeforeDeactivation); Assert.AreEqual(timeout, loadBalancer.HealthMonitor.Timeout); Assert.AreEqual(delay, loadBalancer.HealthMonitor.Delay); // remove the health monitor await provider.RemoveHealthMonitorAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); // remove the health monitor again try { try { await provider.RemoveHealthMonitorAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } catch (WebException ex) { throw new AggregateException(ex); } } catch (AggregateException aggregate) { aggregate.Flatten().Handle( ex => { WebException webException = ex as WebException; if (webException == null) return false; HttpWebResponse response = webException.Response as HttpWebResponse; if (response == null) return false; Assert.AreEqual((HttpStatusCode)422, response.StatusCode); return true; }); } /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestAddNodes() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IPHostEntry entryA = await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("docs.rackspace.com", null, null), Dns.EndGetHostEntry); IPHostEntry entryB = await Task.Factory.FromAsync<IPHostEntry>(Dns.BeginGetHostEntry("developer.rackspace.com", null, null), Dns.EndGetHostEntry); IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer tempLoadBalancer = await provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Status); NodeConfiguration[] nodeConfigurations = new[] { new NodeConfiguration(entryA.AddressList[0], 80, NodeCondition.Enabled, NodeType.Primary, null), new NodeConfiguration(entryB.AddressList[0], 80, NodeCondition.Enabled, NodeType.Primary, null) }; IEnumerable<Node> nodes = await provider.AddNodeRangeAsync(tempLoadBalancer.Id, nodeConfigurations, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Node[] nodesArray = nodes.ToArray(); Assert.AreEqual(2, nodesArray.Length); Assert.AreEqual(NodeStatus.Online, nodesArray[0].Status); Assert.AreEqual(NodeStatus.Online, nodesArray[1].Status); if (nodeConfigurations[0].Address == nodesArray[1].Address) nodesArray[1] = Interlocked.Exchange(ref nodesArray[0], nodesArray[1]); Assert.AreEqual(nodeConfigurations[0].Address, nodesArray[0].Address); Assert.AreEqual(nodeConfigurations[1].Address, nodesArray[1].Address); LoadBalancer loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); Assert.IsNotNull(loadBalancer.Nodes); Assert.AreEqual(2, loadBalancer.Nodes.Count); Node[] listNodes = ListAllLoadBalancerNodes(provider, tempLoadBalancer.Id, null, cancellationTokenSource.Token).ToArray(); Assert.IsNotNull(listNodes); Assert.AreEqual(2, listNodes.Length); await provider.RemoveNodeRangeAsync(tempLoadBalancer.Id, nodesArray.Select(i => i.Id), AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token); if (loadBalancer.Nodes != null) Assert.AreEqual(0, loadBalancer.Nodes.Count); /* Cleanup */ await provider.RemoveLoadBalancerAsync(tempLoadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestRemoveLoadBalancerRange() { ILoadBalancerService provider = CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(30)))) { IEnumerable<LoadBalancingProtocol> protocols = await provider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); string loadBalancerName = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: null, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); Task<LoadBalancer> tempLoadBalancer = provider.CreateLoadBalancerAsync(configuration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); string loadBalancer2Name = CreateRandomLoadBalancerName(); LoadBalancerConfiguration configuration2 = new LoadBalancerConfiguration( name: loadBalancer2Name, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.ServiceNet) }, halfClosed: null, accessList: null, algorithm: LoadBalancingAlgorithm.RoundRobin, connectionLogging: null, contentCaching: null, connectionThrottle: null, healthMonitor: null, metadata: null, timeout: null, sessionPersistence: null); Task<LoadBalancer> tempLoadBalancer2 = provider.CreateLoadBalancerAsync(configuration2, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); await Task.Factory.ContinueWhenAll(new Task[] { tempLoadBalancer, tempLoadBalancer2 }, TaskExtrasExtensions.PropagateExceptions); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer.Result.Status); Assert.AreEqual(LoadBalancerStatus.Active, tempLoadBalancer2.Result.Status); /* Cleanup */ await provider.RemoveLoadBalancerRangeAsync(new[] { tempLoadBalancer.Result.Id, tempLoadBalancer2.Result.Id }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }
public async Task TestCreatePtrRecords() { string domainName = CreateRandomDomainName(); string loadBalancerName = UserLoadBalancerTests.CreateRandomLoadBalancerName(); IDnsService provider = CreateProvider(); ILoadBalancerService loadBalancerProvider = UserLoadBalancerTests.CreateProvider(); using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TestTimeout(TimeSpan.FromSeconds(60)))) { IEnumerable<LoadBalancingProtocol> protocols = await loadBalancerProvider.ListProtocolsAsync(cancellationTokenSource.Token); LoadBalancingProtocol httpProtocol = protocols.First(i => i.Name.Equals("HTTP", StringComparison.OrdinalIgnoreCase)); LoadBalancerConfiguration loadBalancerConfiguration = new LoadBalancerConfiguration( name: loadBalancerName, nodes: null, protocol: httpProtocol, virtualAddresses: new[] { new LoadBalancerVirtualAddress(LoadBalancerVirtualAddressType.Public) }, algorithm: LoadBalancingAlgorithm.RoundRobin); LoadBalancer loadBalancer = await loadBalancerProvider.CreateLoadBalancerAsync(loadBalancerConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.IsNotNull(loadBalancer.VirtualAddresses); Assert.IsTrue(loadBalancer.VirtualAddresses.Count > 0); string originalData = loadBalancer.VirtualAddresses[0].Address.ToString(); string originalName = string.Format("www.{0}", domainName); string updatedName = string.Format("www2.{0}", domainName); string originalCommentValue = "Integration test record"; string updatedCommentValue = "Integration test record 2"; TimeSpan? originalTimeToLive; TimeSpan? updatedTimeToLive = TimeSpan.FromMinutes(12); DnsDomainRecordConfiguration[] recordConfigurations = { new DnsDomainRecordConfiguration( type: DnsRecordType.Ptr, name: string.Format("www.{0}", domainName), data: originalData, timeToLive: null, comment: originalCommentValue, priority: null) }; string serviceName = "cloudLoadBalancers"; Uri deviceResourceUri = await ((UserLoadBalancerTests.TestCloudLoadBalancerProvider)loadBalancerProvider).GetDeviceResourceUri(loadBalancer, cancellationTokenSource.Token); DnsJob<DnsRecordsList> recordsResponse = await provider.AddPtrRecordsAsync(serviceName, deviceResourceUri, recordConfigurations, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); Assert.IsNotNull(recordsResponse.Response); Assert.IsNotNull(recordsResponse.Response.Records); DnsRecord[] records = recordsResponse.Response.Records.ToArray(); Assert.AreEqual(recordConfigurations.Length, records.Length); originalTimeToLive = records[0].TimeToLive; Assert.AreNotEqual(originalTimeToLive, updatedTimeToLive); Assert.AreEqual(originalData, records[0].Data); Assert.AreEqual(originalTimeToLive, records[0].TimeToLive); Assert.AreEqual(originalCommentValue, records[0].Comment); foreach (var record in records) { Console.WriteLine(); Console.WriteLine("Record: {0} ({1})", record.Name, record.Id); Console.WriteLine(); Console.WriteLine(await JsonConvert.SerializeObjectAsync(record, Formatting.Indented)); } // update the comment and verify nothing else changed DnsDomainRecordUpdateConfiguration recordUpdateConfiguration = new DnsDomainRecordUpdateConfiguration(records[0], originalName, originalData, comment: updatedCommentValue); await provider.UpdatePtrRecordsAsync(serviceName, deviceResourceUri, new[] { recordUpdateConfiguration }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); DnsRecord updatedRecord = await provider.ListPtrRecordDetailsAsync(serviceName, deviceResourceUri, records[0].Id, cancellationTokenSource.Token); Assert.IsNotNull(updatedRecord); Assert.AreEqual(originalData, updatedRecord.Data); Assert.AreEqual(originalName, updatedRecord.Name); Assert.AreEqual(originalTimeToLive, updatedRecord.TimeToLive); Assert.AreEqual(updatedCommentValue, updatedRecord.Comment); // update the TTL and verify nothing else changed recordUpdateConfiguration = new DnsDomainRecordUpdateConfiguration(records[0], originalName, originalData, timeToLive: updatedTimeToLive); await provider.UpdatePtrRecordsAsync(serviceName, deviceResourceUri, new[] { recordUpdateConfiguration }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); updatedRecord = await provider.ListPtrRecordDetailsAsync(serviceName, deviceResourceUri, records[0].Id, cancellationTokenSource.Token); Assert.IsNotNull(updatedRecord); Assert.AreEqual(originalData, updatedRecord.Data); Assert.AreEqual(originalName, updatedRecord.Name); Assert.AreEqual(updatedTimeToLive, updatedRecord.TimeToLive); Assert.AreEqual(updatedCommentValue, updatedRecord.Comment); // update the name and verify nothing else changed recordUpdateConfiguration = new DnsDomainRecordUpdateConfiguration(records[0], updatedName, originalData); await provider.UpdatePtrRecordsAsync(serviceName, deviceResourceUri, new[] { recordUpdateConfiguration }, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); updatedRecord = await provider.ListPtrRecordDetailsAsync(serviceName, deviceResourceUri, records[0].Id, cancellationTokenSource.Token); Assert.IsNotNull(updatedRecord); Assert.AreEqual(originalData, updatedRecord.Data); Assert.AreEqual(updatedName, updatedRecord.Name); Assert.AreEqual(updatedTimeToLive, updatedRecord.TimeToLive); Assert.AreEqual(updatedCommentValue, updatedRecord.Comment); // remove the PTR record // TODO: verify result? await provider.RemovePtrRecordsAsync(serviceName, deviceResourceUri, loadBalancer.VirtualAddresses[0].Address, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); /* Cleanup */ await loadBalancerProvider.RemoveLoadBalancerAsync(loadBalancer.Id, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null); } }