public override List <DIDATuple> SendMatchingTuples(DIDATuple didaTuple)
{
List <DIDATuple> matchingTuples = GetMatchingTuples(didaTuple);
Utils.Print($" [*] Sending Matching Tuples for {didaTuple.ToString()}. Found {matchingTuples.Count()}.", verbose: Verbose);
return(matchingTuples);
}
private void BroadcastAdd(DIDATuple didaAdd)
{
string mypath = System.Reflection.Assembly.GetEntryAssembly().Location;
string finalpath = mypath.Substring(0, mypath.Length - 10);
string newpath = Path.GetFullPath(Path.Combine(finalpath, @"..\..\"));
string pathToList = newpath + "ListaServers.txt";
string[] lines = System.IO.File.ReadAllLines(pathToList);
foreach (string line in lines)
{
//port : name
string[] args = line.Split(':');
int server_port = Int32.Parse(args[0]);
string server_name = args[1];
if (didaAdd.getName() != server_name)
{
try
{
string url = "tcp://localhost:" + server_port + "/" + server_name;
TcpClientChannel channelnovo = new TcpClientChannel(server_name, null);
ChannelServices.RegisterChannel(channelnovo, false);
IServerInterface servernovo = (IServerInterface)Activator.GetObject(typeof(IServerInterface), url);
servernovo.Add(didaAdd);
ChannelServices.UnregisterChannel(channelnovo);
}
catch
{
}
}
}
}
public bool Add(DIDATuple didaAdd)
{
Type typeFirstElem = didaAdd.GetTupleList()[0].GetType();
if (tupleSpace.ContainsKey(typeFirstElem.ToString()))
{
//UPDATE AO DICIONARIO
List <DIDATuple> oldDidaList = new List <DIDATuple>();
bool result = tupleSpace.TryGetValue(typeFirstElem.ToString(), out oldDidaList);
if (result)
{
oldDidaList.Add(didaAdd);
}
size++;
}
else
{
//Adicionar ao Dicionario
List <DIDATuple> newDidaList = new List <DIDATuple>();
newDidaList.Add(didaAdd);
tupleSpace.Add(typeFirstElem.ToString(), newDidaList);
size++;
}
return(true);
}
internal ReplyData Take(RequestData requestData)
{
foreach (var entry in tupleSpace)
{
DIDATuple tuple = (DIDATuple)((List <object>)entry)[0];
string workerLock = (string)((List <object>)entry)[1];
if (workerLock == null)
{
continue;
}
// If locked by client
if (workerLock.Equals(requestData.ClientId))
{
// If it is the tuple to remove, removes it from the tupleSpace, else removes the lock
if (tuple.Matches(requestData.TupleData))
{
object toRemove = entry;
tupleSpace.TryTake(out toRemove);
return(new AckReply(requestData.RequestId));
}
else
{
object toRemoveLock = entry;
if (tupleSpace.TryPeek(out toRemoveLock))
{
((List <object>)toRemoveLock)[1] = null;
}
}
}
}
return(new AckReply(requestData.RequestId));
}
public IDIDATuple Add(IDIDATuple didatuple, bool fromXLBroadcast)
{
bool ackFromServers = false;
DIDATuple didaAdd = null;
if (!fromXLBroadcast)
{
//broadCast to all servers
ackFromServers = BroadcastAdd((DIDATuple)didatuple);
}
if (ackFromServers || fromXLBroadcast)
{
didaAdd = (DIDATuple)didatuple;
tupleSpace.Add(didaAdd);
size++;
Console.Write("Client added new tuple : ");
this.PrintTuple(didaAdd);
}
else
{
Add(didatuple, false);
}
return(didaAdd);
}
internal ReplyData Lock(RequestData requestData)
{
List <DIDATuple> tupleSetToSend = new List <DIDATuple>();
bool refused = false;
foreach (var entry in tupleSpace)
{
DIDATuple tuple = (DIDATuple)((List <object>)entry)[0];
string workerLock = (string)((List <object>)entry)[1];
// If unlocked and it matches the template it locks the tuple
if (tuple.Matches(requestData.TupleData))
{
if (workerLock != null)
{
refused = true;
continue;
}
object toLock = entry;
if (tupleSpace.TryPeek(out toLock))
{
((List <object>)toLock)[1] = requestData.ClientId;
tupleSetToSend.Add(tuple);
}
}
}
if (refused)
{
return(new LockRefusedReply(requestData.RequestId));
}
return(new TupleSetReply(requestData.RequestId, tupleSetToSend));
}
public override void Take(DIDATuple tuple)
{
Utils.Print(" [*] Waiting for response from server for <TAKE> operation...");
int replicasCount = backgroundClientView.ReplicasList.Count;
responseCounter = replicasCount; // The SMR Server Sequencer doesn't answer, but is in the view.
CallServers(tuple, EOperationType.Take);
}
public void ConsumeRequest(DIDATuple tuple, EXuLiskovOperation operation)
{
Utils.Print(" [*] Recieved new request...", verbose: Verbose);
EOperationType requestOperation = GetPrimitiveOperationType(operation);
RequestData requestData = new RequestData(++requestCounter, backgroundClientView.ViewId, ClientId, $"tcp://localhost:{ClientPort}", tuple, requestOperation);
XuLiskovRequest request = new XuLiskovRequest(requestData, operation);
ExecuteConsumption(request, operation);
}
public RequestData(int requestId, int viewId, string clientId, string clientUrl, DIDATuple tuple, EOperationType operationType)
{
RequestId = requestId;
ViewId = viewId;
ClientId = clientId;
ClientURL = clientUrl;
TupleData = tuple;
Operation = operationType;
}
internal ReplyData Read(RequestData requestData)
{
foreach (var entry in tupleSpace)
{
DIDATuple tuple = (DIDATuple)((List <object>)entry)[0];
if (tuple.Matches(requestData.TupleData))
{
return(new TupleReply(requestData.RequestId, tuple));
}
}
return(new NoTupleFoundReply(requestData.RequestId));
}
private List <DIDATuple> GetMatchingTuples(DIDATuple didaTuple)
{
List <DIDATuple> matchingTuples = new List <DIDATuple>();
foreach (var entry in tupleSpace)
{
DIDATuple tuple = (DIDATuple)((List <object>)entry)[0];
if (tuple.Matches(didaTuple))
{
matchingTuples.Add(tuple);
}
}
return(matchingTuples);
}
private bool BroadcastRemove(DIDATuple didatuple, string[] lines)
{
int numberOfActiveServers = 1;
bool ack = false;
int numberOfAcks = 1;
do
{
foreach (string line in lines)
{
//port : name : priority
string[] args = line.Split(':');
int server_port = Int32.Parse(args[0]);
string server_name = args[1];
if (didatuple.getName() != server_name)
{
try
{
string url = "tcp://localhost:" + server_port + "/" + server_name;
TcpClientChannel channelnovo = new TcpClientChannel(server_name, null);
ChannelServices.RegisterChannel(channelnovo, false);
IServerInterface servernovo = (IServerInterface)Activator.GetObject(typeof(IServerInterface), url);
ack = servernovo.XLBroadcastRemove(didatuple);
ChannelServices.UnregisterChannel(channelnovo);
if (ack)
{
numberOfAcks++;
}
else
{
break;
}
numberOfActiveServers++;
}
catch (Exception e)
{
}
}
}
} while (numberOfAcks != numberOfActiveServers);
return(true);
}
public void PrintTuple(DIDATuple didatuple)
{
int tuplesize = didatuple.GetTupleList().Count;
for (int i = 0; i < tuplesize; i++)
{
if (i == tuplesize - 1)
{
Console.Write(didatuple.GetTupleList()[i]);
Console.WriteLine("");
}
else
{
Console.Write(didatuple.GetTupleList()[i]);
Console.Write(",");
}
}
}
private void CallServers(DIDATuple tuple, EOperationType requestOperation)
{
Utils.Print("[*] Requesting servers...", verbose: Verbose);
RequestData requestData = new RequestData(++requestCounter, backgroundClientView.ViewId, ClientId, $"tcp://localhost:{ClientPort}", tuple, requestOperation);
List <ServerData> replicasList = backgroundClientView.ReplicasList;
allResponsesEvent.Reset();
int replicasCount = replicasList.Count;
var tasks = new Task <ReplyData> [replicasCount];
for (int i = 0; i < replicasCount; i++)
{
ServerData serverData = replicasList[i];
tasks[i] = Task.Run(() => ExecuteRemoteOperation(serverData, requestData));
}
Task.WaitAny(tasks);
HandleResponses(requestData);
}
internal ReplyData Unlock(RequestData requestData)
{
foreach (var entry in tupleSpace)
{
DIDATuple tuple = (DIDATuple)((List <object>)entry)[0];
string workerLock = (string)((List <object>)entry)[1];
// If locked by client and it is the tuple to unlock, removes the lock
if (workerLock.Equals(requestData.ClientId) && tuple.Matches(requestData.TupleData))
{
object toRemoveLock = entry;
if (tupleSpace.TryPeek(out toRemoveLock))
{
((List <object>)toRemoveLock)[1] = null;
}
}
}
return(new AckReply(requestData.RequestId));
}
public bool Remove(DIDATuple didaTake)
{
Type typeFirstElem = didaTake.GetTupleList()[0].GetType();
List <DIDATuple> listToReturn = new List <DIDATuple>();
if (tupleSpace.ContainsKey(typeFirstElem.ToString()))
{
listToReturn = tupleSpace[typeFirstElem.ToString()];
tupleSpace.Remove(typeFirstElem.ToString());
listToReturn.Remove(didaTake);
tupleSpace.Add(typeFirstElem.ToString(), listToReturn);
return(true);
}
return(false);
}
public DIDATuple Read(DIDATuple didaRead)
{
Type typeFirstElem = didaRead.GetTupleList()[0].GetType();
if (tupleSpace.ContainsKey(typeFirstElem.ToString()))
{
List <DIDATuple> didaList = new List <DIDATuple>();
bool result = tupleSpace.TryGetValue(typeFirstElem.ToString(), out didaList);
if (result)
{
foreach (DIDATuple didaTuple in didaList)
{
if (didaTuple.CompareParams(didaRead))
{
return(didaTuple);
}
}
}
}
return(null);
}
private IDIDATuple Add(IDIDATuple didatuple, bool fromUnfreeze)
{
DIDATuple didaAdd = (DIDATuple)didatuple;
if ((pending.Count == 0 && isfrozen == false) || fromUnfreeze)
{
tupleSpace.Add(didaAdd);
numOps++;
size++;
Console.Write("Client added new tuple : ");
this.PrintTuple(didaAdd);
//se tiver algum client a espera deste tuplo
foreach (KeyValuePair <string, DIDATuple> elem in queuedClients)
{
if (elem.Value.CompareParams(didaAdd))
{
notifyClient(elem.Key);
}
}
if (didaAdd.getBroadme())
{
didaAdd.setBroadme(false);
this.BroadcastAdd(didaAdd);
}
return(didaAdd);
}
else
{
Console.Write("Client added new tuple inserted to the queue : ");
this.PrintTuple(didaAdd);
pending.Enqueue(new KeyValuePair <string, DIDATuple>("add", didaAdd));
return(null);
}
}
private IDIDATuple Read(IDIDATuple didatuple, string name, int port, bool fromXLBroadcast)
{
//MULTICAST TO ALL SERVERS - TODO
//
lock (this)
{
DIDATuple didaResult = tupleSpace.Read((DIDATuple)didatuple);
if (didaResult != null)
{
return(didaResult);
}
else
{
if (!fromXLBroadcast)
{
//broadCast to all servers
return(BroadcastRead((DIDATuple)didatuple));
}
}
}
return(null);
}
public List <IDIDATuple> Take(DIDATuple didaTake)
{
Type typeFirstElem = didaTake.GetTupleList()[0].GetType();
List <IDIDATuple> listToReturn = new List <IDIDATuple>();
if (tupleSpace.ContainsKey(typeFirstElem.ToString()))
{
List <DIDATuple> didaList = new List <DIDATuple>();
bool result = tupleSpace.TryGetValue(typeFirstElem.ToString(), out didaList);
if (result)
{
foreach (DIDATuple didaTuple in didaList)
{
if (didaTuple.CompareParams(didaTake))
{
listToReturn.Add(didaTake);
}
}
}
}
return(listToReturn);
}
private DIDATuple GetRandomIntersectedTuple(List <List <DIDATuple> > lists)
{
List <DIDATuple> intersectList = lists[0];
for (int i = 1; i < lists.Count(); i++)
{
foreach (DIDATuple tuple in lists[i])
{
if (!intersectList.Contains(tuple))
{
intersectList.Remove(tuple);
}
}
}
if (intersectList.Count() == 0)
{
return(null);
}
Random ran = new Random();
DIDATuple takeTuple = intersectList[ran.Next(0, intersectList.Count())];
return(takeTuple);
}
public void SimulateDelay(IDIDATuple x)
{
DIDATuple didat = (DIDATuple)x;
string name = didat.getName();
string mypath = System.Reflection.Assembly.GetEntryAssembly().Location;
string finalpath = mypath.Substring(0, mypath.Length - 10);
string newpath = Path.GetFullPath(Path.Combine(finalpath, @"..\..\"));
string pathToDelay = newpath + name + "Delay.txt";
string[] lines = System.IO.File.ReadAllLines(pathToDelay);
foreach (string line in lines)
{
//min : max
string[] args = line.Split(':');
MinDelay = Int32.Parse(args[0]);
MaxDelay = Int32.Parse(args[1]);
}
Random r = new Random();
int delay = r.Next(MinDelay, MaxDelay);
this.Wait(delay);
}
internal ReplyData Take(RequestData requestData)
{
ViewManager viewM = viewManager;
View view = viewM.GetView();
ServerData leaderData = view.Find(view.ManagerUId);
if (leaderData.Equals(ServerData)) // As the View Leader.
{
receiveTakeTupleFromLeader.Reset();
List <List <DIDATuple> > serversMatchingTuples = new List <List <DIDATuple> >();
List <ServerData> replicasList = viewManager.GetKnownReplicas();
Utils.Print($" [*] SMR Server Leader: Calling {replicasList.Count()} servers.", verbose: Verbose);
foreach (ServerData serverData in replicasList)
{
if (!serverData.Equals(leaderData))
{
string serverProxyURL = $"tcp://{serverData.ServerURL}/{serverData.ServerName}";
ISMRServerService serverProxy = (ISMRServerService)Activator.GetObject(typeof(ISMRServerService), serverProxyURL);
try
{
List <DIDATuple> matchingTuples = serverProxy.SendMatchingTuples(requestData.TupleData);
serversMatchingTuples.Add(matchingTuples);
}
catch (SocketException)
{
viewManager.TryViewChange(viewManager.GetKnownReplicas());
}
}
}
serversMatchingTuples.Add(GetMatchingTuples(requestData.TupleData));
PrintTuplesListsList(serversMatchingTuples);
DIDATuple takeTuple = GetRandomIntersectedTuple(serversMatchingTuples);
if (takeTuple == null)
{
return(new NoTupleFoundReply(requestData.RequestId));
}
Utils.Print($" [*] SMR Server Leader: Taking {takeTuple}.", verbose: Verbose);
// Removed tuple from all replicas.
foreach (ServerData serverData in replicasList)
{
string serverProxyURL = $"tcp://{serverData.ServerURL}/{serverData.ServerName}";
ISMRServerService serverProxy = (ISMRServerService)Activator.GetObject(typeof(ISMRServerService), serverProxyURL);
RequestData leaderTakeRequestData = new RequestData(0, 0, "", "", takeTuple, EOperationType.Take);
try
{
serverProxy.ReceiveTakeTuple(leaderTakeRequestData);
}
catch (SocketException)
{
viewManager.TryViewChange(viewManager.GetKnownReplicas());
}
}
object toRemove = takeTuple;
if (tupleSpace.TryTake(out toRemove))
{
return(new TupleReply(requestData.RequestId, takeTuple));
}
else
{
return(new NoTupleFoundReply(requestData.RequestId)); // Should be impossible to execute this else.
}
}
// As a follower.
else
{
receiveTakeTupleFromLeader.WaitOne(); // Waits for the signal of when the Take Tuple arrives.
// After receiving the Tuple from the Leader, for the Take Operation.
DIDATuple takeTuple = takeTupleFromLeader.TupleData;
Utils.Print($" [*] SMR Server: Taking {takeTuple}.", verbose: Verbose);
if (takeTuple == null)
{
return(new NoTupleFoundReply(requestData.RequestId));
}
object toRemove = takeTuple;
if (tupleSpace.TryTake(out toRemove))
{
return(new TupleReply(requestData.RequestId, takeTuple));
}
else
{
return(new NoTupleFoundReply(requestData.RequestId)); // Should be impossible to execute this else.
}
// Add send Leader an Ack.
}
}
public override void Write(DIDATuple tuple)
{
backgroundClient.Write(tuple);
}
public abstract List <DIDATuple> SendMatchingTuples(DIDATuple didaTuple);
public override void Read(DIDATuple tuple)
{
backgroundClient.Read(tuple);
}
public virtual void Take(DIDATuple template)
{
backgroundClient.Take(template);
}
public virtual void Read(DIDATuple template)
{
backgroundClient.Read(template);
}
public virtual void Write(DIDATuple tuple)
{
backgroundClient.Write(tuple);
}
public override void Take(DIDATuple tuple)
{
backgroundClient.Take(tuple);
}
