public PollingServerListUpdater(LoadBalancerConfig config, ILogger logger)
{
_config = config;
_timer = new Timer(async s =>
{
if (UpdateAction == null || Processing)
{
return;
}
Processing = true;
try
{
await UpdateAction();
}
catch (Exception e)
{
logger.LogWarning(e, "Failed one update cycle");
}
finally
{
Processing = false;
}
}, null, -1, -1);
}
public async Task <Response> InstallModule(V1Deployment moduleDeployment, LoadBalancerConfig loadBalancerConfig, string nameSpace = "default")
{
// First check if the moduleDeployment is already deployed in the system
var modules = await GetDeployment(moduleDeployment.Metadata.Name);
if (modules != null)
{
// There is already a module running under the specified deploymentName
return(Response.Unsuccessful($"There is already a module running under the specified deploymentName: {moduleDeployment}"));
}
try
{
await _client.CreateNamespacedDeploymentWithHttpMessagesAsync(moduleDeployment, nameSpace);
if (loadBalancerConfig.NeedLoadBalancer)
{
var port = await FetchAvailablePort();
var targetPort = loadBalancerConfig.TargetPort == 0 ? 80 : loadBalancerConfig.TargetPort;
await _client.CreateNamespacedServiceWithHttpMessagesAsync(
CreateV1Service(moduleDeployment.Metadata.Name, ServiceType.LoadBalancer, targetPort : targetPort, port), nameSpace);
}
}
catch (Exception e)
{
return(Response.Unsuccessful(e.Message));
}
return(Response.Success());
}
public ApplicationRequestRoutingLoadBalancer(LoadBalancerConfig settings)
{
_settings = settings;
_user = new DeploymentUserConfig {
UserName = settings.UserName, Password = settings.Password
};
_server = new ServerConfig {
DeploymentUser = _user, Name = _settings.Name
};
}
public ModuleManagerConfig(Id taskId, ModuleReplicas moduleReplicas, ModuleName moduleName, ImageName imageName, LoadBalancerConfig loadBalancerConfig, Func <Id, ILogHandler, Task> successCallback, Func <Id, ILogHandler, Task> failureCallback, Func <Id, ILogHandler, Task> updateCallback)
{
TaskId = taskId;
LoadBalancerConfig = loadBalancerConfig;
_moduleReplicas = moduleReplicas;
_moduleName = moduleName;
_imageName = imageName;
SuccessCallback = successCallback;
FailureCallback = failureCallback;
UpdateCallback = updateCallback;
}
//"test_env_FARM"
public AceLoadBalancer_Anm_v41(LoadBalancerConfig lbConfig)
{
var binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
var remoteAddress = new EndpointAddress(lbConfig.Name);
_proxy = new OperationManagerClient(binding, remoteAddress);
_username = lbConfig.UserName;
_password = lbConfig.Password;
ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
}
public RequestInstallModule(string imageName, int moduleReplicas, string moduleName, LoadBalancerConfig loadBalancerConfig)
{
if (loadBalancerConfig == null)
{
throw new Exception("loadBalancerConfig may not be null");
}
ImageName = new ImageName(imageName);
ModuleReplicas = new ModuleReplicas(moduleReplicas);
ModuleName = new ModuleName(moduleName);
LoadBalancerConfig = loadBalancerConfig;
}
public void Test()
{
var config = new LoadBalancerConfig
{
Name = "https://10.64.6.74:8443/anm/OperationManager",
UserName = "******",
Password = "******"
};
var loadBalancer = new AceLoadBalancer_Anm_v41(config);
var status = new StatusReporter();
loadBalancer.BringOffline("z63os2swb01-t", "test_env_FARM", LoadBalancerSuspendMethod.Suspend, status);
}
private bool DrawConfigEditor(LoadBalancerConfig cfg)
{
bool changed = false;
EditorGUILayout.BeginVertical("Box");
var interval = EditorGUILayout.FloatField("Update Interval", cfg.updateInterval);
if (cfg.updateInterval != interval)
{
cfg.updateInterval = interval;
changed = true;
}
var auto = EditorGUILayout.Toggle("Auto Adjust", cfg.autoAdjust);
if (cfg.autoAdjust != auto)
{
cfg.autoAdjust = auto;
changed = true;
}
if (!auto)
{
var maxUpdates = EditorGUILayout.IntField("Max Updates Per Frame", cfg.maxUpdatesPerFrame);
if (cfg.maxUpdatesPerFrame != maxUpdates)
{
cfg.maxUpdatesPerFrame = maxUpdates;
changed = true;
}
var maxUpdateTime = EditorGUILayout.IntField("Max Update Time In Milliseconds Per Update", cfg.maxUpdateTimeInMillisecondsPerUpdate);
if (cfg.maxUpdateTimeInMillisecondsPerUpdate != maxUpdateTime)
{
cfg.maxUpdateTimeInMillisecondsPerUpdate = maxUpdateTime;
changed = true;
}
}
EditorGUILayout.EndVertical();
return(changed);
}
private void Awake()
{
List <LoadBalancerPerformanceVisualizer.PerformanceData> performanceDatas = new List <LoadBalancerPerformanceVisualizer.PerformanceData>();
LoadBalancerComponent component = base.GetComponent <LoadBalancerComponent>();
if (component != null)
{
LoadBalancerConfig[] loadBalancerConfigArray = component.configurations;
for (int i = 0; i < (int)loadBalancerConfigArray.Length; i++)
{
LoadBalancerConfig loadBalancerConfig = loadBalancerConfigArray[i];
performanceDatas.Add(new LoadBalancerPerformanceVisualizer.PerformanceData(loadBalancerConfig.associatedLoadBalancer, loadBalancerConfig.targetLoadBalancer));
}
}
else
{
Debug.LogWarning("LoadBalancer Performance Visualizer must reside on the same GameObject as the Load Balancer.");
base.enabled = false;
}
this._data = performanceDatas.ToArray();
}
public HaProxyLoadBalancer(LoadBalancerConfig config)
{
_config = config;
if (config.CustomConfig == null)
{
throw new ConDepLoadBalancerException("No config found in section CustomConfig under load balancer. HaProxy requires CustomConfig for at least SnmpEndpoint.");
}
if (config.CustomConfig.SnmpEndpoint == null)
{
throw new ConDepLoadBalancerException("No SnmpEndpoint exist in configuration. Please add this under CustomConfig.");
}
_snmpEndpoint = config.CustomConfig.SnmpEndpoint;
_scope = config.CustomConfig.Scope ?? "root";
_snmpPort = config.CustomConfig.SnmpPort ?? 161;
_snmpCommunity = config.CustomConfig.SnmpCommunity ?? "public";
_waitTimeInSecondsAfterSettingServerStateToOffline = config.CustomConfig.WaitTimeInSecondsAfterSettingServerStateToOffline ?? config.CustomConfig.WaitTimeInSecondsAfterMaintenanceModeChanged ?? 5;
_waitTimeInSecondsAfterSettingServerStateToOnline = config.CustomConfig.WaitTimeInSecondsAfterSettingServerStateToOnline ?? config.CustomConfig.WaitTimeInSecondsAfterMaintenanceModeChanged ?? 5;
}
public ConfigurationBasedServerList(LoadBalancerConfig settings)
{
_settings = settings;
}
private void Initialize(LoadBalancerConfig loadBalancerConfig)
{
InitializeMinAvailableServerCountProperty();
_loadBalancerRuleFactoryManager = new DefaultLoadBalancerRuleFactoryManager(this);
if (loadBalancerConfig.RuleFactory != null)
{
_loadBalancerRuleFactoryManager.RegisterLoadBalancerRuleFactory(loadBalancerConfig.RuleFactory);
}
ServerSourceFilter = new DefaultServerSourceFilter(this);
ServerSourceManager = new DefaultServerSourceManager(this);
ServerSourceMonitor = new DefaultServerSourceMonitor(this);
LoadBalancer = new DefaultLoadBalancer(this);
ServerSourceFilter.OnChange += (o, e) =>
{
ServerSourceManager.Backup(ServerSourceFilter.LoadBalancerRoutes);
};
ServerSourceMonitor.ServerStatusChange += (o, e) =>
{
ServerSourceFilter.Refresh();
ServerSourceManager.Backup(ServerSourceFilter.LoadBalancerRoutes);
};
if (ServerSource is IDynamicServerSource)
{
((IDynamicServerSource)ServerSource).OnChange += (o, e) =>
{
ServerSourceFilter.LoadBalancerRoutes = ServerSource.LoadBalancerRoutes;
};
}
if (loadBalancerConfig.ServerSourceRestoreEventHandler != null)
{
ServerSourceManager.OnServerSourceRestore += loadBalancerConfig.ServerSourceRestoreEventHandler;
}
if (loadBalancerConfig.SeekRouteEventHandler != null)
{
ServerSourceFilter.OnSeekRoute += loadBalancerConfig.SeekRouteEventHandler;
}
var routes = ServerSource.LoadBalancerRoutes;
var servers = new List <Server>();
if (routes != null)
{
routes.ForEach(route => servers.AddRange(route.Servers));
}
if (servers.Count == 0)
{
routes = ServerSourceManager.Restore();
routes.ForEach(route => servers.AddRange(route.Servers));
var localCache = string.Join("\n", servers);
_logger.Warn("Server list is null! Load server list from local cache." + localCache, AdditionalInfo);
}
if (servers.Count != 0)
{
ServerSourceManager.Backup(ServerSourceFilter.LoadBalancerRoutes);
}
ServerSourceFilter.LoadBalancerRoutes = routes;
ServerSourceMonitor.MonitorServers();
}
public DefaultLoadBalancerContext(LoadBalancerManager loadBalancerManager, string loadBalancerId, LoadBalancerConfig loadBalancerConfig)
{
LoadBalancerManager = loadBalancerManager;
ConfigurationManager = loadBalancerManager.LoadBalancerManagerConfig.ConfigurationManager;
EventMetricManager = loadBalancerManager.LoadBalancerManagerConfig.EventMetricManager;
AuditMetricManager = loadBalancerManager.LoadBalancerManagerConfig.AuditMetricManager;
StatusMetricManager = loadBalancerManager.LoadBalancerManagerConfig.StatusMetricManager;
ManagerId = loadBalancerManager.ManagerId;
LoadBalancerId = loadBalancerId;
Ping = loadBalancerConfig.Ping;
ServerSource = loadBalancerConfig.ServerSource;
AdditionalInfo = new Dictionary <string, string>()
{
{ "LoadBalancerKey", LoadBalancerKey }
};
Initialize(loadBalancerConfig);
}
/// <inheritdoc/>
public FastConsulServerListUpdater(string clientName, IServiceProvider services, LoadBalancerConfig config, ILogger logger) : base(config, logger)
{
_clientName = clientName;
_logger = services.GetRequiredService <ILogger <FastConsulServerListUpdater> >();
var consulDiscoveryOptionsAccessor = services.GetRequiredService <IOptions <ConsulDiscoveryOptions> >();
_consulClient = services.GetRequiredService <ConsulClient>();
_consulDiscoveryOptions = consulDiscoveryOptionsAccessor.Value;
}
public LoadBalancer(LoadBalancerConfig config)
{
_config = config;
}
public LoadBalancerLookup(LoadBalancerConfig loadBalancerSettings)
{
_loadBalancerSettings = loadBalancerSettings;
}
public void WeightedRoundRobinTest()
{
int serverCount = 10;
int repeatTimes = 100;
int repeatInterval = 0;
int threadCount = 20;
int serverSumCount = 0;
string loadBalancerId = MethodInfo.GetCurrentMethod().Name;
IConfiguration configuration = ObjectFactory.CreateAppSettingConfiguration();
var configurationSource = ObjectFactory.CreateDefaultConfigurationSource(0, "App.config", configuration);
var configurationManager = ObjectFactory.CreateDefaultConfigurationManager(configurationSource);
Dictionary <int, AtomicInteger> indexCountMapping = new Dictionary <int, AtomicInteger>();
List <ServerGroup> serverGroups = new List <ServerGroup>();
for (int i = 0; i < serverCount; i++)
{
var metadata = new Dictionary <string, string>();
metadata["Index"] = i.ToString();
var server = new Server("Server_" + i, metadata);
serverGroups.Add(new ServerGroup(server.ServerId, i, new List <Server>()
{
server
}));
indexCountMapping[i] = 0;
serverSumCount += i;
}
var ping = new TruePing();
var serverSource = new DefaultDynamicServerSource(serverGroups);
var factory = LoadBalancerManager.GetManager("soa", new LoadBalancerManagerConfig(configurationManager));
var loadBalancerConfig = new LoadBalancerConfig(ping, serverSource);
var loadBalancer = factory.GetLoadBalancer(loadBalancerId, loadBalancerConfig);
var defaultLoadBalancer = ((DefaultLoadBalancer)loadBalancer).LoadBalancerContext;
Action action = () =>
{
for (int i = 0; i < repeatTimes; i++)
{
for (int j = 0; j < serverSumCount; j++)
{
var requestContext = loadBalancer.GetRequestContext(requestConfig);
int index = int.Parse(requestContext.Server.Metadata["Index"]);
indexCountMapping[index].IncrementAndGet();
if (repeatInterval > 0)
{
Thread.Sleep(repeatInterval);
}
}
}
};
List <Task> tasks = new List <Task>();
for (int i = 0; i < threadCount; i++)
{
tasks.Add(Task.Factory.StartNew(action));
}
Task.WaitAll(tasks.ToArray());
foreach (var item in indexCountMapping)
{
Assert.AreEqual(item.Key * repeatTimes * threadCount, item.Value.Value, item.Key.ToString());
}
}
public void WeightedRoundRobinWithSpecificWeightTest()
{
int serverCount = 10;
int repeatTimes = 100;
int repeatInterval = 0;
int threadCount = 20;
int serverSumCount = 0;
string loadBalancerId = MethodInfo.GetCurrentMethod().Name;
IConfiguration configuration = ObjectFactory.CreateAppSettingConfiguration();
var configurationSource = ObjectFactory.CreateDefaultConfigurationSource(0, "App.config", configuration);
var configurationManager = ObjectFactory.CreateDefaultConfigurationManager(configurationSource);
Dictionary <int, AtomicInteger> indexCountMapping = new Dictionary <int, AtomicInteger>();
List <ServerGroup> serverGroups = new List <ServerGroup>();
List <Server> servers = new List <Server>();
for (int i = 0; i < serverCount; i++)
{
var metadata = new Dictionary <string, string>();
metadata["Index"] = i.ToString();
var server = new Server("Server_" + i, metadata);
servers.Add(server);
serverGroups.Add(new ServerGroup(server.ServerId, i, new List <Server>()
{
server
}));
indexCountMapping[i] = 0;
serverSumCount += i;
}
LoadBalancerRoute route0 = new LoadBalancerRoute("default", serverGroups);
ServerGroup route1Group0 = new ServerGroup("group0", 2, new List <Server>()
{
servers[0]
});
ServerGroup route1Group1 = new ServerGroup("group1", 1, new List <Server>()
{
servers[1]
});
LoadBalancerRoute route1 = new LoadBalancerRoute("route1", new List <ServerGroup>()
{
route1Group0, route1Group1
});
ServerGroup route2Group0 = new ServerGroup("group0", 2, new List <Server>()
{
servers[0]
});
ServerGroup route2Group1 = new ServerGroup("group1", 3, new List <Server>()
{
servers[1]
});
LoadBalancerRoute route2 = new LoadBalancerRoute("route2", new List <ServerGroup>()
{
route2Group0, route2Group1
});
LoadBalancerRequestConfig route1Config = new LoadBalancerRequestConfig(new List <LoadBalancerRouteConfig>()
{
new LoadBalancerRouteConfig("route1", 1, false)
});
LoadBalancerRequestConfig route2Config = new LoadBalancerRequestConfig(new List <LoadBalancerRouteConfig>()
{
new LoadBalancerRouteConfig("route2", 1, false)
});
int server0Count = route1Group0.Weight + route2Group0.Weight;
int server1Count = route1Group1.Weight + route2Group1.Weight;
int route1RequestCount = route1Group0.Weight + route1Group1.Weight;
int route2RequestCount = route2Group0.Weight + route2Group1.Weight;
var ping = new TruePing();
var serverSource = new DefaultDynamicServerSource(new List <LoadBalancerRoute>()
{
route0, route1, route2
});
var factory = LoadBalancerManager.GetManager("soa", new LoadBalancerManagerConfig(configurationManager));
var loadBalancerConfig = new LoadBalancerConfig(ping, serverSource);
var loadBalancer = factory.GetLoadBalancer(loadBalancerId, loadBalancerConfig);
var defaultLoadBalancer = ((DefaultLoadBalancer)loadBalancer).LoadBalancerContext;
Action action = () =>
{
for (int i = 0; i < repeatTimes; i++)
{
for (int j = 0; j < serverSumCount; j++)
{
var requestContext = loadBalancer.GetRequestContext(requestConfig);
int index = int.Parse(requestContext.Server.Metadata["Index"]);
indexCountMapping[index].IncrementAndGet();
if (repeatInterval > 0)
{
Thread.Sleep(repeatInterval);
}
}
for (int j = 0; j < route1RequestCount; j++)
{
var requestContext = loadBalancer.GetRequestContext(route1Config);
int index = int.Parse(requestContext.Server.Metadata["Index"]);
indexCountMapping[index].IncrementAndGet();
if (repeatInterval > 0)
{
Thread.Sleep(repeatInterval);
}
}
for (int j = 0; j < route2RequestCount; j++)
{
var requestContext = loadBalancer.GetRequestContext(route2Config);
int index = int.Parse(requestContext.Server.Metadata["Index"]);
indexCountMapping[index].IncrementAndGet();
if (repeatInterval > 0)
{
Thread.Sleep(repeatInterval);
}
}
}
};
List <Task> tasks = new List <Task>();
for (int i = 0; i < threadCount; i++)
{
tasks.Add(Task.Factory.StartNew(action));
}
Task.WaitAll(tasks.ToArray());
foreach (var item in indexCountMapping)
{
if (item.Key == 0)
{
Assert.AreEqual((item.Key + server0Count) * repeatTimes * threadCount, item.Value.Value, item.Key.ToString());
}
else if (item.Key == 1)
{
Assert.AreEqual((item.Key + server1Count) * repeatTimes * threadCount, item.Value.Value, item.Key.ToString());
}
else
{
Assert.AreEqual(item.Key * repeatTimes * threadCount, item.Value.Value, item.Key.ToString());
}
}
}
