//Enters reader mode and if it found same valid tuple it enters write mode to remove it
public TupleClass takeLeader(TupleClass tuple)
{
tupleSpaceLock.EnterUpgradeableReadLock();
try {
TupleClass res = new TupleClass();
foreach (TupleClass el in tupleSpace)
{
if (el.Matches(tuple))
{
tupleSpaceLock.EnterWriteLock();
try {
res = el;
tupleSpace.Remove(el);
Console.WriteLine("Operation: Took " + res.ToString() + " tuple space size: " + tupleSpace.Count + "\n");
return(res);
}
finally {
tupleSpaceLock.ExitWriteLock();
}
}
}
Console.WriteLine("Operation: Took " + res.ToString() + " tuple space size: " + tupleSpace.Count + "\n");
return(res); //no match
}
finally
{
tupleSpaceLock.ExitUpgradeableReadLock();
}
}
private void takeRemove(TupleClass tupleToDelete)
{
setView();
WaitHandle[] handles = new WaitHandle[numServers];
IAsyncResult[] asyncResults = new IAsyncResult[numServers];
for (int i = 0; i < numServers; i++)
{
IServerService remoteObject = view[i];
takeRemoveDelegate takeRemDel = new takeRemoveDelegate(remoteObject.TakeRemove);
IAsyncResult ar = takeRemDel.BeginInvoke(tupleToDelete, url, nonce, null, null);
asyncResults[i] = ar;
handles[i] = ar.AsyncWaitHandle;
}
int ntimeouts = 0;
if (!WaitHandle.WaitAll(handles, 1000))
{
for (int k = 0; k < numServers; k++)
{
if (handles[k].WaitOne(0) == false)
{
ntimeouts++;
}
}
}
if (ntimeouts > numServers / 2)
{
takeRemove(tupleToDelete);
}
}
//Enters write mode in the tupleSpaceLock
public void writeLeader(TupleClass tuple)
{
tupleSpaceLock.EnterWriteLock();
tupleSpace.Add(tuple);
Console.WriteLine("Operation: Added " + tuple.ToString() + "\n");
tupleSpaceLock.ExitWriteLock();
}
public override void Write(TupleClass tuple)
{
checkFrozen();
WaitHandle[] handles = new WaitHandle[numServers];
try {
for (int i = 0; i < numServers; i++)
{
IServerService remoteObject = view[i];
writeDelegate writeDel = new writeDelegate(remoteObject.Write);
IAsyncResult ar = writeDel.BeginInvoke(tuple, url, nonce, null, null);
handles[i] = ar.AsyncWaitHandle;
}
if (!WaitHandle.WaitAll(handles, 1000))
{
setView();
Write(tuple);
}
else
{
nonce++;
}
}
catch (SocketException) {
Console.WriteLine("Error in write. Trying again...");
setView();
Write(tuple);
}
}
public TupleClass read(TupleClass tuple)
{
TupleClass resTuple = null;
while (resTuple == null)
{
Console.WriteLine("Operation: Read" + tuple.ToString() + "\n");
tupleSpaceLock.EnterReadLock();
try {
Regex capital = new Regex(@"[A-Z]");
lock (tupleSpace) {
foreach (TupleClass t in tupleSpace)
{
if (t.Matches(tuple))
{
resTuple = t;
break;
}
}
}
}
finally {
tupleSpaceLock.ExitReadLock();
}
if (resTuple == null)
{
lock (dummyObjForLock) {
Monitor.Wait(dummyObjForLock);
}
}
}
return(resTuple);
}
//Enters reader mode and if it found same valid tuple it enters write mode to remove it
public TupleClass takeLeader(TupleClass tuple, int term)
{
tupleSpaceLock.EnterUpgradeableReadLock();
try {
TupleClass res = new TupleClass();
foreach (TupleClass el in tupleSpace)
{
if (el.Matches(tuple))
{
tupleSpaceLock.EnterWriteLock();
try {
TakeEntry entry = new TakeEntry(tuple, term, getLogIndex(), "take");
addEntrytoLog(entry);
res = el;
tupleSpace.Remove(el);
Console.WriteLine("Operation: Took " + res.ToString() + "\n");
return(res);
}
finally {
tupleSpaceLock.ExitWriteLock();
}
}
}
Console.WriteLine("Operation: Took " + res.ToString() + "\n");
return(res); //no match
}
finally
{
tupleSpaceLock.ExitUpgradeableReadLock();
}
}
public override TupleClass take(TupleClass tuple)
{
checkFrozen();
try {
TupleClass res = _view[0].take(tuple, url, nonce);
nonce++;
if (res.tuple.Count == 0)
{
Thread.Sleep(500);
_view = getView(_view);
return(take(tuple));
}
return(res);
}
catch (ElectionException) {
Thread.Sleep(500);
_view = getView(_view);
return(take(tuple));
}
catch (SocketException) {
_view = getView(_view);
return(take(tuple));
}
}
public override TupleClass Read(TupleClass tuple)
{
checkFrozen();
setView();
WaitHandle[] handles = new WaitHandle[numServers];
IAsyncResult[] asyncResults = new IAsyncResult[numServers];
try {
for (int i = 0; i < numServers; i++)
{
IServerService remoteObject = view[i];
readDelegate readDel = new readDelegate(remoteObject.Read);
IAsyncResult ar = readDel.BeginInvoke(tuple, url, nonce, null, null);
asyncResults[i] = ar;
handles[i] = ar.AsyncWaitHandle;
}
int indxAsync = WaitHandle.WaitAny(handles, 1000);
if (indxAsync == WaitHandle.WaitTimeout)
{
Thread.Sleep(200);
return(Read(tuple));
}
else //TODO se o retorno for nulo temos de ir ver outra resposta
{
IAsyncResult asyncResult = asyncResults[indxAsync];
readDelegate readDel = (readDelegate)((AsyncResult)asyncResult).AsyncDelegate;
TupleClass resTuple = readDel.EndInvoke(asyncResult);
nonce++;
return(resTuple);
}
}
catch (SocketException) {
Console.WriteLine("Error in read. Trying again...");
return(Read(tuple));
}
}
public void CanBeUsedAcrossAssemblies()
{
var tupleGenerator = new TupleClass();
var tuple = tupleGenerator.TupleMethod();
var tupleElement = tuple.Alpha;
Assert.AreEqual("1", tuple.Alpha);
}
public override List <TupleClass> read(TupleClass tuple, string url, long nonce)
{
try {
return(_server.readLeader(tuple, true));
}
catch (ElectionException e) {
throw e;
}
}
public List <TupleClass> read(TupleClass tuple, string clientUrl, long nonce)
{
try {
return(_state.read(tuple, clientUrl, nonce));
}
catch (ElectionException e) {
throw e;
}
}
public void write(TupleClass tuple, string clientUrl, long nonce)
{
try {
_state.write(tuple, clientUrl, nonce);
}
catch (ElectionException e) {
throw e;
}
}
public TupleClass take(TupleClass tuple, string clientUrl, long nonce)
{
try {
return(_state.take(tuple, clientUrl, nonce));
}
catch (ElectionException e) {
throw e;
}
}
//public?
private void executeOperation(string commandLine)
{
TupleClass tuple;
TupleClass response;
string[] commandItems = commandLine.Split(new char[] { ' ' }, 2);
switch (commandItems[0])
{
case "add":
tuple = new TupleClass(commandItems[1]);
Console.WriteLine("Operation: " + commandLine + "\n");
_tupleSpaceAPI.write(tuple);
break;
case "read":
tuple = new TupleClass(commandItems[1]);
Console.WriteLine("Operation: " + commandLine);
response = _tupleSpaceAPI.read(tuple);
Console.Write("Response: ");
if (response.Size == 0)
{
Console.WriteLine("No match found\n");
}
else
{
Console.WriteLine(response.ToString() + "\n");
}
break;
case "take":
tuple = new TupleClass(commandItems[1]);
Console.WriteLine("Operation: " + commandLine);
response = _tupleSpaceAPI.take(tuple);
Console.Write("Response: ");
if (response.Size == 0)
{
Console.WriteLine("No match found\n");
}
else
{
Console.WriteLine(response.ToString() + "\n");
}
break;
case "wait":
System.Threading.Thread.Sleep(int.Parse(commandItems[1]));
Console.WriteLine("Operation: " + commandLine + "\n");
break;
}
}
public override TupleClass take(TupleClass tuple, string url, long nonce)
{
TupleClass realTuple = _server.readLeader(tuple, false);
timer.Interval = wait;
TupleClass res = _server.takeLeader(tuple, _term);
pulseAppendEntry();
return(res);
}
public TupleClass Read(TupleClass tuple, string clientUrl, long nonce)
{
_server.checkFrozen();
Interlocked.Increment(ref numRequests);
int r = random.Next(_min_delay, _max_delay);
Console.WriteLine("Read Network Delay: " + r.ToString());
Thread.Sleep(r);
Interlocked.Decrement(ref numRequests);
return(_server.read(tuple));
}
public void TakeRemove(TupleClass tuple, string clientUrl, long nonce)
{
_server.checkFrozen();
Interlocked.Increment(ref numRequests);
if (validRequest(clientUrl, nonce)) //success
{
int r = random.Next(_min_delay, _max_delay);
Console.WriteLine("TakeRemove Network Delay: " + r.ToString());
Thread.Sleep(r);
_server.takeRemove(tuple, clientUrl);
}
Interlocked.Decrement(ref numRequests);
}
public List <TupleClass> TakeRead(TupleClass tuple, string clientUrl)
{
_server.checkFrozen();
Interlocked.Increment(ref numRequests);
List <TupleClass> responseTuple = new List <TupleClass>();
int r = random.Next(_min_delay, _max_delay);
Console.WriteLine("TakeRead Network Delay: " + r.ToString());
Thread.Sleep(r);
responseTuple = _server.takeRead(tuple, clientUrl);
Interlocked.Decrement(ref numRequests);
return(responseTuple);
}
public override TupleClass take(TupleClass tuple, string clientUrl, long nonce)
{
try {
Console.WriteLine("Take called in follower");
return(_leaderRemote.take(tuple, clientUrl, nonce));
}
catch (ElectionException e) {
throw e;
}
catch (SocketException) {
return(take(tuple, clientUrl, nonce));
}
}
public override TupleClass take(TupleClass tuple, string url, long nonce)
{
TupleClass realTuple = _server.readLeader(tuple, false)[0];
TakeEntry entry = new TakeEntry(tuple, _term, _server.getLogIndex(), "take");
//arranjar lock para o log e tuplespace(?)
_server.addEntrytoLog(entry);
timer.Interval = wait;
pulseAppendEntry();
return(_server.takeLeader(tuple));
}
public override void write(TupleClass tuple, string clientUrl, long nonce)
{
try {
Console.WriteLine("Write called in follower");
_leaderRemote.write(tuple, clientUrl, nonce);
}
catch (ElectionException e) {
throw e;
}
catch (SocketException) {
write(tuple, clientUrl, nonce);
}
}
public override List <TupleClass> read(TupleClass tuple, string clientUrl, long nonce)
{
try {
Console.WriteLine("Read in follower");
return(_leaderRemote.read(tuple, clientUrl, nonce));
}
catch (ElectionException e) {
throw e;
}
catch (SocketException) {
//TODO
throw new NotImplementedException();
}
}
public void write(TupleClass tuple)
{
Console.WriteLine("Operation: Write" + tuple.ToString() + "\n");
tupleSpaceLock.EnterWriteLock();
try {
tupleSpace.Add(tuple);
}
finally {
tupleSpaceLock.ExitWriteLock();
}
lock (dummyObjForLock) {
Monitor.PulseAll(dummyObjForLock);
}
}
public void write(TupleClass tuple, string clientUrl, long nonce)
{
_server.checkFrozen();
try {
if (validRequest(clientUrl, nonce))
{
int r = random.Next(_min_delay, _max_delay);
Thread.Sleep(r);
_server.write(tuple, clientUrl, nonce);
}
}
catch (ElectionException e) {
throw e;
}
}
//TODO falta utilizar nounce
public override void write(TupleClass tuple, string url, long nonce)
{
try {
WriteEntry entry = new WriteEntry(tuple, _term, _server.getLogIndex(), "write");
//arranjar lock para o log
_server.addEntrytoLog(entry);
timer.Interval = wait;
pulseAppendEntry();
_server.writeLeader(tuple);
}
catch (ElectionException e) {
throw e;
}
}
public override void write(TupleClass tuple)
{
checkFrozen();
_view = getView(_view);
try {
_view[0].write(tuple, url, nonce);
nonce++;
}
catch (ElectionException) {
Thread.Sleep(500);
write(tuple);
}
catch (SocketException) {
write(tuple);
}
}
public void takeRemove(TupleClass tuple, string clientURL)
{
foreach (TupleClass el in tupleSpace)
{
if (tuple.Equals(el))
{
tupleSpaceLock.EnterWriteLock();
tupleSpace.Remove(el);
tupleSpaceLock.ExitWriteLock();
lock (toTakeSubset) {
toTakeSubset.Remove(clientURL);
}
break;
}
}
}
public override void write(TupleClass tuple)
{
checkFrozen();
try {
serverRemoteObject.write(tuple, url, nonce);
nonce++;
}
catch (ElectionException) {
Thread.Sleep(500);
write(tuple);
}
catch (SocketException) {
//TODO
throw new NotImplementedException();
}
}
public override TupleClass take(TupleClass tuple)
{
checkFrozen();
try {
TupleClass res = serverRemoteObject.take(tuple, url, nonce);
nonce++;
return(res);
}
catch (ElectionException) {
Thread.Sleep(500);
return(take(tuple));
}
catch (SocketException) {
//TODO
throw new NotImplementedException();
}
}
public List <TupleClass> takeRead(TupleClass tuple, string clientURL)
{
Console.WriteLine("Operation: Take" + tuple.ToString() + "\n");
List <TupleClass> res = new List <TupleClass>();
Regex capital = new Regex(@"[A-Z]");
List <TupleClass> allTuples = new List <TupleClass>();
lock (toTakeSubset) { //Prevent a take from searching for tuples when another take is already doing it
if (toTakeSubset.ContainsKey(clientURL))
{
toTakeSubset.Remove(clientURL);
}
foreach (List <TupleClass> list in toTakeSubset.Values)
{
foreach (var y in list)
{
allTuples.Add(y);
}
}
foreach (TupleClass el in tupleSpace.ToList())
{
if (el.Matches(tuple) && !allTuples.Contains(el)) //ignores blocked tuples
{
res.Add(el);
}
else if (el.Matches(tuple) && allTuples.Contains(el))
{
return(new List <TupleClass>());
}
}
if (res.Count != 0)
{
toTakeSubset.Add(clientURL, res);
}
}
if (res.Count == 0)
{
return(new List <TupleClass>());
}
else
{
return(res);
}
}
