public void TestConfigInit()
{
var balancer = new LoadBalancerRoundRobin();
Assert.AreEqual(LoadBalancerRoundRobin._workerHostNamePrefix, "workernode");
Assert.AreEqual(LoadBalancerRoundRobin._workerRestEndpointPort, 8090);
Assert.AreEqual(LoadBalancerRoundRobin._refreshInterval.TotalMilliseconds, 10.0);
}
public void TestConfigInit()
{
var balancer = new LoadBalancerRoundRobin();
Assert.Equal("workernode", LoadBalancerRoundRobin._workerHostNamePrefix);
Assert.Equal(8090, LoadBalancerRoundRobin._workerRestEndpointPort);
Assert.Equal(10.0, LoadBalancerRoundRobin._refreshInterval.TotalMilliseconds);
}
public void TestConfigInit()
{
var balancer = new LoadBalancerRoundRobin();
Assert.AreEqual(LoadBalancerRoundRobin._workerHostNamePrefix, "workernode");
Assert.AreEqual(LoadBalancerRoundRobin._workerRestEndpointPort, 8090);
Assert.AreEqual(LoadBalancerRoundRobin._refreshInterval.TotalMilliseconds, 10.0);
}
public void TestLoadBalancerConfigInitialization()
{
var stringConfigInitial = Guid.NewGuid().ToString();
var stringConfigDefault = Guid.NewGuid().ToString();
var stringConfigExpected = "LoadBalancerTestConfigValue";
var stringConfigValidKey = "LoadBalancerTestConfigString";
var stringConfigInvalidKey = "LoadBalancerTestConfigStringInvalid";
var stringReadInvalid = stringConfigInitial;
stringReadInvalid =
LoadBalancerRoundRobin.ReadFromConfig(stringConfigInvalidKey, string.Copy, stringConfigDefault);
Assert.Equal(stringReadInvalid, stringConfigDefault);
var stringReadValid = stringConfigInitial;
stringReadValid =
LoadBalancerRoundRobin.ReadFromConfig(stringConfigValidKey, string.Copy, stringConfigDefault);
Assert.Equal(stringReadValid, stringConfigExpected);
var rnd = new Random();
var intConfigInitial = rnd.Next();
var intConfigDefault = rnd.Next();
var intConfigExpected = 10;
var intConfigValidKey = "LoadBalancerTestConfigInt";
var intConfigInvalidKey = "LoadBalancerTestConfigIntInvalid";
var intReadInvalid = intConfigInitial;
intReadInvalid = LoadBalancerRoundRobin.ReadFromConfig(intConfigInvalidKey, int.Parse, intConfigDefault);
Assert.Equal(intReadInvalid, intConfigDefault);
var intReadValid = intConfigInitial;
intReadValid = LoadBalancerRoundRobin.ReadFromConfig(intConfigValidKey, int.Parse, intConfigDefault);
Assert.Equal(intReadValid, intConfigExpected);
var doubleConfigInitial = rnd.NextDouble();
var doubleConfigDefault = rnd.NextDouble();
var doubleConfigExpected = 20.0;
var doubleConfigValidKey = "LoadBalancerTestConfigDouble";
var doubleConfigInvalidKey = "LoadBalancerTestConfigDoubleInvalid";
var doubleReadInvalid = doubleConfigInitial;
doubleReadInvalid =
LoadBalancerRoundRobin.ReadFromConfig(doubleConfigInvalidKey, double.Parse, doubleConfigDefault);
Assert.Equal(doubleReadInvalid, doubleConfigDefault);
var doubleReadValid = doubleConfigInitial;
doubleReadValid =
LoadBalancerRoundRobin.ReadFromConfig(doubleConfigValidKey, double.Parse, doubleConfigDefault);
Assert.Equal(doubleReadValid, doubleConfigExpected);
}
public void TestFailedEndpointsExpiry()
{
var numServers = 5;
Uri activeEndpoint;
var expectedNumFailedEndpoints = 0;
var expectedNumAvailableEndpoints = numServers;
var balancer = new LoadBalancerRoundRobin(numServers);
Assert.Equal(10.0, LoadBalancerRoundRobin._refreshInterval.TotalMilliseconds);
for (var i = 0; i < numServers; i++)
{
activeEndpoint = balancer.GetEndpoint();
Assert.NotNull(activeEndpoint);
balancer.RecordFailure(activeEndpoint);
expectedNumFailedEndpoints++;
expectedNumAvailableEndpoints--;
}
var endpointsInfoList =
(balancer._endpointIgnorePolicy as IgnoreFailedEndpointsPolicy)._endpoints.Values.ToArray();
var failedBefore = Array.FindAll(endpointsInfoList,
x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Failed);
var availableBefore = Array.FindAll(endpointsInfoList,
x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Available);
Assert.Equal(failedBefore.Length, numServers);
Assert.Empty(availableBefore);
Thread.Sleep(100);
var endpoint = balancer.GetEndpoint();
Assert.NotNull(endpoint);
balancer.RecordSuccess(endpoint);
endpointsInfoList =
(balancer._endpointIgnorePolicy as IgnoreFailedEndpointsPolicy)._endpoints.Values.ToArray();
var failedAfter = Array.FindAll(endpointsInfoList,
x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Failed);
var availableAfter = Array.FindAll(endpointsInfoList,
x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Available);
Assert.Equal(failedAfter.Length, numServers - 1);
Assert.Single(availableAfter);
}
public void TestLoadBalancerDomainInit()
{
int numServers = 10;
string testDomain = "test.fakedomain.com";
var balancer = new LoadBalancerRoundRobin(numServers, testDomain);
string[] endpoints = balancer._allEndpoints.Select(u => u.ToString()).OrderBy(s => s).ToArray();
for (int i = 0; i < endpoints.Length; i++)
{
string expected = string.Format("http://{0}{1}.{2}:{3}/", LoadBalancerRoundRobin._workerHostNamePrefix, i, testDomain, LoadBalancerRoundRobin._workerRestEndpointPort);
Assert.AreEqual(expected, endpoints[i]);
}
}
public void TestLoadBalancerConcurrency()
{
int numServers = 20;
var balancer = new LoadBalancerRoundRobin(numServers);
var uniqueEndpointsFetched = new ConcurrentDictionary <string, bool>();
Parallel.For(0, numServers, (i) =>
{
var endpoint = balancer.GetEndpoint();
Assert.IsNotNull(endpoint);
balancer.RecordSuccess(endpoint);
Assert.IsFalse(uniqueEndpointsFetched.ContainsKey(endpoint.OriginalString));
Assert.IsTrue(uniqueEndpointsFetched.TryAdd(endpoint.OriginalString, true));
});
}
public void TestLoadBalancerEndpointsInitialization()
{
int numServers = 4;
var balancer = new LoadBalancerRoundRobin(numRegionServers: numServers);
Assert.AreEqual(balancer.GetNumAvailableEndpoints(), numServers);
var expectedServersList = BuildServersList(numServers);
var actualServersList = new List<string>();
foreach (var endpoint in balancer._allEndpoints)
{
actualServersList.Add(endpoint.OriginalString);
}
Assert.IsTrue(CompareLists(actualServersList, expectedServersList));
}
public void TestLoadBalancerEndpointsInitialization()
{
int numServers = 4;
var balancer = new LoadBalancerRoundRobin(numRegionServers: numServers);
Assert.AreEqual(balancer.GetNumAvailableEndpoints(), numServers);
var expectedServersList = BuildServersList(numServers);
var actualServersList = new List <string>();
foreach (var endpoint in balancer._allEndpoints)
{
actualServersList.Add(endpoint.OriginalString);
}
Assert.IsTrue(CompareLists(actualServersList, expectedServersList));
}
public void TestLoadBalancerRoundRobin()
{
int numServers = 10;
var balancer = new LoadBalancerRoundRobin(numServers);
int initRRIdx = balancer._endpointIndex;
for (int i = 0; i < 2 * numServers; i++)
{
Uri selectedEndpoint = null;
selectedEndpoint = balancer.GetEndpoint();
var expectedRRIdx = (initRRIdx + i) % numServers;
var expectedEndpoint = balancer._allEndpoints[expectedRRIdx];
Assert.IsTrue(selectedEndpoint.OriginalString.Equals(expectedEndpoint.OriginalString));
balancer.RecordSuccess(selectedEndpoint);
}
}
public void TestLoadBalancerIgnorePolicy()
{
int numServers = 10;
int numBlackListedServers = 8;
var balancer = new LoadBalancerRoundRobin(numServers);
var blackListedServersList = BuildServersList(numBlackListedServers);
balancer._endpointIgnorePolicy = new IgnoreBlackListedEndpointsPolicy(blackListedServersList);
for (int i = 0; i < 2 * numServers; i++)
{
Uri selectedEndpoint = null;
selectedEndpoint = balancer.GetEndpoint();
var selectedEndpointFoundInBlackList = blackListedServersList.Find(x => x.Equals(selectedEndpoint.OriginalString));
Assert.IsNull(selectedEndpointFoundInBlackList);
balancer.RecordSuccess(selectedEndpoint);
}
}
public void TestFailedEndpointsExpiry()
{
int numServers = 5;
Uri activeEndpoint;
int expectedNumFailedEndpoints = 0;
int expectedNumAvailableEndpoints = numServers;
var balancer = new LoadBalancerRoundRobin(numRegionServers: numServers);
Assert.AreEqual(LoadBalancerRoundRobin._refreshInterval.TotalMilliseconds, 10.0);
for (int i = 0; i < numServers; i++)
{
activeEndpoint = balancer.GetEndpoint();
Assert.IsNotNull(activeEndpoint);
balancer.RecordFailure(activeEndpoint);
expectedNumFailedEndpoints++;
expectedNumAvailableEndpoints--;
}
var endpointsInfoList = (balancer._endpointIgnorePolicy as IgnoreFailedEndpointsPolicy)._endpoints.Values.ToArray();
var failedBefore = Array.FindAll(endpointsInfoList, x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Failed);
var availableBefore = Array.FindAll(endpointsInfoList, x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Available);
Assert.AreEqual(failedBefore.Length, numServers);
Assert.AreEqual(availableBefore.Length, 0);
Thread.Sleep(100);
var endpoint = balancer.GetEndpoint();
Assert.IsNotNull(endpoint);
balancer.RecordSuccess(endpoint);
endpointsInfoList = (balancer._endpointIgnorePolicy as IgnoreFailedEndpointsPolicy)._endpoints.Values.ToArray();
var failedAfter = Array.FindAll(endpointsInfoList, x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Failed);
var availableAfter = Array.FindAll(endpointsInfoList, x => x.State == IgnoreFailedEndpointsPolicy.EndpointState.Available);
Assert.AreEqual(failedAfter.Length, numServers - 1);
Assert.AreEqual(availableAfter.Length, 1);
}
public void TestLoadBalancerIgnorePolicy()
{
int numServers = 10;
int numBlackListedServers = 8;
var balancer = new LoadBalancerRoundRobin(numServers);
var blackListedServersList = BuildServersList(numBlackListedServers);
balancer._endpointIgnorePolicy = new IgnoreBlackListedEndpointsPolicy(blackListedServersList);
for (int i = 0; i < 2 * numServers; i++)
{
Uri selectedEndpoint = null;
selectedEndpoint = balancer.GetEndpoint();
var selectedEndpointFoundInBlackList = blackListedServersList.Find(x => x.Equals(selectedEndpoint.OriginalString));
Assert.IsNull(selectedEndpointFoundInBlackList);
balancer.RecordSuccess(selectedEndpoint);
}
}
public void TestLoadBalancerConcurrency()
{
int numServers = 20;
var balancer = new LoadBalancerRoundRobin(numServers);
var uniqueEndpointsFetched = new ConcurrentDictionary<string, bool>();
Parallel.For(0, numServers, (i) =>
{
var endpoint = balancer.GetEndpoint();
Assert.IsNotNull(endpoint);
balancer.RecordSuccess(endpoint);
Assert.IsFalse(uniqueEndpointsFetched.ContainsKey(endpoint.OriginalString));
Assert.IsTrue(uniqueEndpointsFetched.TryAdd(endpoint.OriginalString, true));
});
}
public void TestLoadBalancerDomainInit()
{
int numServers = 10;
string testDomain = "test.fakedomain.com";
var balancer = new LoadBalancerRoundRobin(numServers, testDomain);
string[] endpoints = balancer._allEndpoints.Select(u => u.ToString()).OrderBy(s => s).ToArray();
for (int i = 0; i < endpoints.Length; i++)
{
string expected = string.Format("http://{0}{1}.{2}:{3}/", LoadBalancerRoundRobin._workerHostNamePrefix, i, testDomain, LoadBalancerRoundRobin._workerRestEndpointPort);
Assert.AreEqual(expected, endpoints[i]);
}
}
public void TestLoadBalancerRoundRobin()
{
int numServers = 10;
var balancer = new LoadBalancerRoundRobin(numServers);
int initRRIdx = balancer._endpointIndex;
for (int i = 0; i < 2 * numServers; i++)
{
Uri selectedEndpoint = null;
selectedEndpoint = balancer.GetEndpoint();
var expectedRRIdx = (initRRIdx + i) % numServers;
var expectedEndpoint = balancer._allEndpoints[expectedRRIdx];
Assert.IsTrue(selectedEndpoint.OriginalString.Equals(expectedEndpoint.OriginalString));
balancer.RecordSuccess(selectedEndpoint);
}
}
