public async Task TestAddNode()
{
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: 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 nodeConfiguration = new NodeConfiguration(entry.AddressList[0], 80, NodeCondition.Enabled, NodeType.Primary, null);
Node node = await provider.AddNodeAsync(tempLoadBalancer.Id, nodeConfiguration, AsyncCompletionOption.RequestCompleted, cancellationTokenSource.Token, null);
Assert.AreEqual(NodeStatus.Online, node.Status);
Assert.AreEqual(nodeConfiguration.Address, node.Address);
LoadBalancer loadBalancer = await provider.GetLoadBalancerAsync(tempLoadBalancer.Id, cancellationTokenSource.Token);
Assert.IsNotNull(loadBalancer.Nodes);
Assert.AreEqual(1, loadBalancer.Nodes.Count);
Node[] listNodes = ListAllLoadBalancerNodes(provider, tempLoadBalancer.Id, null, cancellationTokenSource.Token).ToArray();
Assert.IsNotNull(listNodes);
Assert.AreEqual(1, listNodes.Length);
Node getNode = await provider.GetNodeAsync(tempLoadBalancer.Id, listNodes[0].Id, cancellationTokenSource.Token);
Assert.IsNotNull(getNode);
Assert.AreEqual(node.Id, getNode.Id);
await provider.RemoveNodeAsync(tempLoadBalancer.Id, node.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 static Node AddNode(this ILoadBalancerService service, LoadBalancerId loadBalancerId, NodeConfiguration nodeConfiguration)
{
if (service == null)
throw new ArgumentNullException("service");
try
{
return service.AddNodeAsync(loadBalancerId, nodeConfiguration, AsyncCompletionOption.RequestSubmitted, CancellationToken.None, null).Result;
}
catch (AggregateException ex)
{
ReadOnlyCollection<Exception> innerExceptions = ex.Flatten().InnerExceptions;
if (innerExceptions.Count == 1)
throw innerExceptions[0];
throw;
}
}
