private void BalanceEntries(MetadataEntry currentEntry, RequestBalancing balanceRequest)
{
Console.WriteLine("Ballance entries please");
MetadataEntry newEntry = currentEntry.Clone();
switch (balanceRequest.Writes)
{
case BalancingStatus.Excess:
newEntry.NBDataServers++;
newEntry.ReadQuorum++;
break;
case BalancingStatus.Few:
break;
case BalancingStatus.Ok:
break;
}
switch (balanceRequest.Reads)
{
case BalancingStatus.Excess:
newEntry.NBDataServers++;
newEntry.WriteQuorum++;
break;
case BalancingStatus.Few:
break;
case BalancingStatus.Ok:
break;
}
int difference = newEntry.NBDataServers - currentEntry.NBDataServers;
//Update values
currentEntry.NBDataServers = newEntry.NBDataServers;
currentEntry.ReadQuorum = newEntry.ReadQuorum;
currentEntry.WriteQuorum = newEntry.WriteQuorum;
if (difference < 0)
{
KeyValuePair <ServerId, String>[] entriesList = currentEntry.ServerFileList.ToArray( );
ConcurrentDictionary <ServerId, String> newlist = new ConcurrentDictionary <ServerId, string>( );
//Temos de alocar menos servidores
for (int i = 0; i < currentEntry.NBDataServers; i++)
{
//Reduce list
newlist.TryAdd(entriesList[i].Key, entriesList[i].Value);
}
//TODO Delete files on dataservers
}
if (difference > 0)
{
//Temos de alocar mais servidores
CopyEntryBetweenDataservers(currentEntry);
}
}
public void Balancing(RequestBalancing entry)
{
if (LoadBalancer.Enabled)
{
//New balancing thread to wait for close
new BalacingThreadDel(BalancingThread).BeginInvoke(entry, null, null);
//Continue
}
}
private void BalancingThread(RequestBalancing newEntry)
{
//Mutex locker = new Mutex( false, newEntry.FileName );
MetadataEntry currentEntry;
EventWaitHandle monitor = new EventWaitHandle(true, EventResetMode.AutoReset, "padi" + MetadataServer.ThisMetaserverId + newEntry.FileName + "balancing");
while (LoadBalancer.Enabled)
{
Console.WriteLine("Balacing operation start ");
monitor.WaitOne( );
Console.WriteLine("Balacing operation unlocked ");
//locker.WaitOne( );
Console.WriteLine("Ballancer Thread checking ");
Boolean status = _metaTable.TryGetValue(newEntry.FileName, out currentEntry);
if (status == false)
{
//Ficheiro foi eliminado
//locker.ReleaseMutex( );
return;
}
if (!currentEntry.IsOpen( ))
{
BalanceEntries(currentEntry, newEntry);
// locker.ReleaseMutex( );
return;
}
//FILE IS OPEN YET, IF YES, WAIT
//locker.ReleaseMutex( );
Console.WriteLine("Balacing operation locked: ");
monitor.WaitOne( );
Console.WriteLine("Balacing operation unlocked");
monitor.Set( );
}
}
private static MetaserverResponse Balancing(MetaRequest request)
{
Console.WriteLine("New balancing message");
if (!LoadBalancer.Enabled)
{
Console.WriteLine("Load balance not enable");
return(new MetaserverResponse(ResponseStatus.Success, request, ThisMetaserverId));
}
Console.WriteLine("Load balance enable");
RequestBalancing balancingRequest = (RequestBalancing)request;
MetaserverResponse response;
try
{
core.Balancing(balancingRequest);
response = new MetaserverResponse(ResponseStatus.Success, request, ThisMetaserverId);
}
catch (Exception ex)
{
response = new MetaserverResponse(ResponseStatus.Exception, request, ThisMetaserverId);
response.Exception = new PadiException(PadiExceptiontType.Balancing, ex.Message);
}
return(response);
}
private void BalancerEngine(Dictionary <DataserverInfo, ICollection <LocalFileStatistics> > globalState, long totalReadsSystem, long totalWritesSystem, long totalFiles, int numServers)
{
long avgTraffic = (totalReadsSystem + totalWritesSystem) / numServers;
long avgWrite = totalWritesSystem / numServers;
long avgRead = totalReadsSystem / numServers;
//Reads+Writes
Dictionary <String, RequestBalancing> entriesToChange = new Dictionary <string, RequestBalancing>( );
foreach (KeyValuePair <DataserverInfo, ICollection <LocalFileStatistics> > serverStaticsPair in globalState)
{
// PROCESSAR O SERVIDOR COMO QUEIRAMOS
foreach (LocalFileStatistics file in serverStaticsPair.Value)
{
String filename = file.filename;
RequestBalancing status = new RequestBalancing(filename);
long writeDiff = file.writeTraffic - avgWrite;
if (writeDiff > avgWrite * TOLERANCE)
{
//Escritas em excesso
status.Writes = BalancingStatus.Excess;
}
if (writeDiff < (-avgWrite * TOLERANCE))
{
//Menos escritas que o normal
status.Writes = BalancingStatus.Few;
}
long readDiff = file.readTraffic - avgRead;
if (readDiff > avgRead * TOLERANCE)
{
//Leituras em excesso
status.Reads = BalancingStatus.Excess;
}
if (readDiff < (-avgRead * TOLERANCE))
{
//Menos Leituras que o normal
status.Reads = BalancingStatus.Few;
}
//Was updated?
if (status.Reads == BalancingStatus.Ok && status.Writes == BalancingStatus.Ok)
{
continue;
}
if (entriesToChange.ContainsKey(filename))
{
//TODO NORMALIZE (se ja existe, outros servidores tambem estao mal)
}
else
{
entriesToChange.Add(filename, status);
}
}
}
foreach (RequestBalancing request in entriesToChange.Values)
{
connectionToMeta.SendRequestToMetaserver(request);
}
}
