public ServerStateData <TServer> TryAddServer(TServer server, FeedbackLevel loadLevel, int loadLevelWeight)
{
// check if the server instance was already added
if (this.serverList.ContainsKey(server))
{
log.WarnFormat("LoadBalancer already contains server {0}", server);
return(null);
}
var serverState = new ServerStateData <TServer>(server)
{
LoadLevel = loadLevel,
Weight = loadLevelWeight,
Priority = this.Priority
};
this.serverList.Add(server, serverState);
// we add new server to reserve only when it should be increased by 1
// let's say we had 9 server and ratio is 0.2, then reserve will contain 1 server
// we add new server. 10*0.2 == 2. 2 - resevedServersCount(1) == 1. and -1 will gives us almost 0. so we increase amount of reserved servers
if (Math.Abs(this.reserveRatio * this.serverList.Count - this.reservedServersCount - 1) < 0.0001)
{
serverState.MarkReserved();
++this.reservedServersCount;
}
this.UpdateServerReturnThreshold();
return(serverState);
}
private void fillVerText()
{
serStat = ClientEnvironment.ServerStateService.GetState();
string uri = GetUrl(RemotingServices.GetObjectUri((MarshalByRefObject)ClientEnvironment.ServerStateService));
lb_ver.Items.Add(Localizer.GetLocalized("ClientVer") + " " + ClientEnvironment.ClientVerision);
lb_ver.Items.Add(Localizer.GetLocalized("AppserVer") + " " + serStat.ServerVersion);
lb_ver.Items.Add(Localizer.GetLocalized("DBVer") + " " + serStat.DbVersion);
lb_ver.Items.Add(Localizer.GetLocalized("HostURL") + " " + uri);
}
public void UpdateTotalWorkload(ServerStateData <TServer> server, FeedbackLevel oldLoadLevel, FeedbackLevel newLoadLevel)
{
this.totalWorkload -= (int)oldLoadLevel;
this.totalWorkload += (int)newLoadLevel;
if (!server.IsInReserve)
{
this.serversInUseWorkload -= (int)oldLoadLevel;
this.serversInUseWorkload += (int)newLoadLevel;
}
}
private void RemoveFromAvailableServers(ServerStateData <TServer> serverState)
{
if (serverState.Node == null)
{
return;
}
this.serversInUseWeight -= serverState.Weight;
this.availableServers.Remove(serverState.Node);
serverState.Node = null;
}
public ServerStateData GetState()
{
ServerStateData state = new ServerStateData();
state.TotalMemory = GC.GetTotalMemory(false);
state.ServerVersion = ServerEnvironment.ServerVersion.ToString();
state.DbVersion = ServerEnvironment.DbProperties.GetDbVersion();
return(state);
}
public void ReturnServerIntoReserve(ServerStateData <TServer> server)
{
server.IsInReserve = true;
--this.serversUsedFromReserveCount;
if (log.IsDebugEnabled)
{
log.DebugFormat("Server is taken from reserve. Server:{0}, servers count:{1}, Reserved:{2}, in Reserve:{3}",
server, this.serverList.Count, this.reservedServersCount, this.reservedServersCount - this.serversUsedFromReserveCount);
}
this.serversInUseWorkload -= (int)server.LoadLevel;
}
public ServerStateData <TServer> UpdateReserve(ServerStateData <TServer> server)
{
if (server.IsReserved)
{
return(null);
}
var reserve = this.serverList.Where(s => s.Value.IsReserved);
var firstInReserve = reserve.FirstOrDefault().Value;
if (firstInReserve == null || server.Server.CompareTo(firstInReserve.Server) == -1)
{
return(null);
}
server.MarkReserved();
firstInReserve.MarkReserved(false);
return(firstInReserve);
}
public void RemoveServer(ServerStateData <TServer> server, out ServerStateData <TServer> fromReserve)
{
this.serverList.Remove(server.Server);
fromReserve = null;
if (server.IsReserved)
{
--this.reservedServersCount;
if (!server.IsInReserve)
{
--this.serversUsedFromReserveCount;
}
// we take first not reserved server to mark it as reserved if we need to increase reserve.
// var lastNotReserved = this.serverList.LastOrDefault(s => !s.Value.IsReserved && s.Value.IsInAvailableList);
var lastNotReserved = this.serverList.LastOrDefault(s => !s.Value.IsReserved);
if (this.reserveRatio * this.serverList.Count - this.reservedServersCount >= 1.0)
{
// All not reserved servers are in available list of LoadBalancer
// so we do not return it through fromReserve
lastNotReserved.Value.IsReserved = true;
++this.reservedServersCount;
//this server were in available list. so, we think it is used
++this.serversUsedFromReserveCount;
}
}
else if (this.reserveRatio * this.serverList.Count - this.reservedServersCount < 0.0)
{
var serverState = this.serverList.FirstOrDefault(s => s.Value.IsReserved).Value;
if (serverState != null)
{
// we managed to find reserved (not involved/used) server in reserve
serverState.MarkReserved(false);
fromReserve = serverState;
}
--this.reservedServersCount;
}
this.UpdateServerReturnThreshold();
}
public bool TryGetServer(TServer server, out ServerStateData <TServer> serverState)
{
return(this.serverList.TryGetValue(server, out serverState));
}
private void AddToAvailableServers(ServerStateData <TServer> serverState)
{
this.serversInUseWeight += serverState.Weight;
serverState.Node = this.availableServers.AddLast(serverState);
}
