///////////////////////// copy & Load ////////////////////////////////
public CopyStructMetadata Copy(NamespaceManager namespaceManager, List <int> sectionsToSend)
{
CopyStructMetadata dataStruct = new CopyStructMetadata( );
dataStruct.DataServerTable = new List <DataserverInfo>(_dataServerTable.ToArray( ));
dataStruct.MetaTable = GetParcialMetaTable(namespaceManager, sectionsToSend);
dataStruct.Used = new List <string>(_used);
dataStruct.RandomGenerator = _randomFileNameGenerator;
return(dataStruct);
}
public void LoadFromStructMetadataCore(CopyStructMetadata dataStruct)
{
_dataServerTable = new List <DataserverInfo>(dataStruct.DataServerTable);
foreach (KeyValuePair <string, MetadataEntry> metadataEntry in dataStruct.MetaTable)
{
MetadataEntry ignore;
_metaTable.TryRemove(metadataEntry.Key, out ignore);
_metaTable.TryAdd(metadataEntry.Key, metadataEntry.Value);
}
_used = new List <string>(dataStruct.Used);
_randomFileNameGenerator = dataStruct.RandomGenerator;
}
////////////////////////// COPY MANAGEMENT ////////////////////////////////////////////////
public static bool UpdateServer(CopyStructMetadata metaCopyStruct)
{
Console.WriteLine("Start loading process");
//Actualizar o espaco de nomes em atraso
core.LoadFromStructMetadataCore(metaCopyStruct);
//Fazer o maximo dos vectores para manter sempre o estado mais actualizado
long[] currentStatus = GetQueueStateVector();
for (int i = 0; i < currentStatus.Length; i++)
{
currentStatus[i] = Math.Max(currentStatus[i], metaCopyStruct.StatusVector[i]);
}
NamespaceManager.SetQueueStateVector(currentStatus);
Console.WriteLine("Load done to status:" + ArrayToString(currentStatus));
return(true);
}
private Boolean UpdateFromServers(List <int> serverIds)
{
foreach (int serverId in serverIds)
{
Console.WriteLine("Copy from : " + serverId);
IMetaToMeta server = MetadataServer.ConnectToMetaserver(serverId);
//Request copy from master
try
{
CopyStructMetadata dataStruct = server.RequestUpdate(MetadataServer.GetQueueStateVector(), MetadataServer.ThisMetaserverId);
//Update the server
MetadataServer.UpdateServer(dataStruct);
}
catch (SocketException)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Compare our status with the requester status.
/// Send only the sections which we have more recent
/// and if he has a more recent sections, than, send request
/// too.
/// </summary>
/// <param name="sourceStatus"></param>
/// <returns></returns>
public CopyStructMetadata RequestUpdate(long[] sourceStatus, int sourceID)
{
long[] currentStatus = GetQueueStateVector();
Console.WriteLine("Start Copy Sending Process");
Console.WriteLine("My state:" + ArrayToString(currentStatus));
Console.WriteLine("Requester state:" + ArrayToString(sourceStatus));
Boolean needUpdate = false;
List <int> sectionsToSend = new List <int>();
//Comparar o array recebido com o nosso
for (int i = 0; i < currentStatus.Length; i++)
{
if (currentStatus[i] < sourceStatus[i])
{
needUpdate = true;
}
//If we have more recent version, than update source status
if (currentStatus[i] > sourceStatus[i])
{
sectionsToSend.Add(i);
sourceStatus[i] = currentStatus[i];
}
}
//Request core the sections left
CopyStructMetadata metaCopyStruct = core.Copy(NamespaceManager, sectionsToSend);
//Attach our state
metaCopyStruct.StatusVector = sourceStatus;
//If need update, enviar o pedido de update (sourceId)
if (needUpdate)
{
Console.WriteLine("I need update too, lets ask to new peer to update me too");
RequestUpdateDelegate exec = new RequestUpdateDelegate(RequestDirectUpdate);
exec.Invoke(sourceID);
Console.WriteLine("Sending Copy");
}
return(metaCopyStruct);
}
