public void BalancerOptionsIsNotValidWithoutUris()
{
var options = new BalancerOptions();
Action test = () => options.CheckValidity();
test.Should().Throw<InvalidConstraintException>();
}
public LoadBalancerService(IEndpointWatcher watcher,
IOptions <BalancerOptions> options,
ILogger <LoadBalancerService> logger,
ILoadManager loadManager)
{
_watcher = watcher;
_options = options.Value;
_logger = logger;
_loadManager = loadManager;
}
public KubernetesEndpointWatcher(IWebHostEnvironment env,
IOptions <BalancerOptions> options,
ILogger <KubernetesEndpointWatcher> logger)
{
_options = options.Value;
_logger = logger;
_endpointEntries = Array.Empty <EndpointEntry>();
try
{
_k8sClient = new Kubernetes(KubernetesClientConfiguration.InClusterConfig());
InitializeWatcherAsync().Wait();
_logger.LogDebug("Connected to K8s, watcher initialized");
}
catch (KubeConfigException x) when(PredefinedConfiguration.HasPredefinedConfiguration(x, env))
{
_k8sClient = null;
_endpointEntries = PredefinedConfiguration.GetEndpointEntries(env);
_logger.LogDebug($"Can not connect to K8s, using predefined configuration");
}
}
/// <summary>
/// Request count implementation
/// </summary>
/// <param name="balancerData"></param>
/// <param name="options"></param>
/// <returns></returns>
private Node RequestCount(BalancerData balancerData, BalancerOptions options)
{
var key = balancerData.Scores.OrderByDescending(x => x.Value).FirstOrDefault().Key;
return(options.Nodes[key]);
if (balancerData.Scores[key] + 1 < long.MaxValue)
{
balancerData.Scores[key]++;
}
else
{
//If i'm going outside long range I need a reset.
//i'm the lower value, so if I'm not able to increments all other have my same value (if not, they had ben triggered this previously)
for (int i = 0; i < balancerData.Scores.Count; i++)
{
balancerData.Scores[i] = 0;
}
}
}
public async override Task InvokeImpl(HttpContext context, string host, VHostOptions vhost, IConfigurationSection settings)
{
BalancerOptions options = new BalancerOptions();
settings.Bind("Settings:Balancer", options);
BalancerData balancerData = null;
if (!data.ContainsKey(host))
{
balancerData = data[host] = new BalancerData();
for (int i = 0; i < options.Nodes.Length; i++)
{
balancerData.Scores[i] = 0;
}
}
else
{
balancerData = data[host];
}
//Different logic basing on algoritm
//TODO: make it generic using interface\implementation for algoritm
if (options.Policy == "RoundRobin")
{
context.Items["bal-destination"] = RoundRobin(balancerData, options);
}
else if (options.Policy == "RequestCount")
{
context.Items["bal-destination"] = RequestCount(balancerData, options);
}
//Alter request
context.Request.Headers["X-Forwarded-For"] = context.Connection.RemoteIpAddress.ToString();
context.Request.Headers["X-Forwarded-Proto"] = context.Request.Protocol.ToString();
int port = context.Request.Host.Port ?? (context.Request.IsHttps ? 443 : 80);
context.Request.Headers["X-Forwarded-Port"] = port.ToString();
}
public Balancer(IOptions <BalancerOptions> settings)
{
options = settings.Value;
}
/// <summary>
/// Roud robin implementation
/// </summary>
/// <param name="balancerData"></param>
/// <param name="options"></param>
/// <returns></returns>
private object RoundRobin(BalancerData balancerData, BalancerOptions options)
{
balancerData.LastServed = (balancerData.LastServed + 1) % options.Nodes.Length;
return(options.Nodes[balancerData.LastServed]);
}
