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