public void Remove(Tuple tuple) { Console.WriteLine("Remove o tuplo: " + tuple); View actualView = this.GetView(); List <ITupleSpaceXL> serversObj = new List <ITupleSpaceXL>(); ITupleSpaceXL tupleSpace = null; //save remoting objects of all members of the view foreach (string serverPath in actualView.Servers) { try { tupleSpace = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), serverPath); tupleSpace.ItemCount(); //just to check availability of the server } catch (Exception) { tupleSpace = null; } if (tupleSpace != null) { serversObj.Add(tupleSpace); } } foreach (ITupleSpaceXL server in serversObj) { try { RemoteAsyncSecondPhaseDelegate RemoteDel = new RemoteAsyncSecondPhaseDelegate(server.remove); IAsyncResult RemAr = RemoteDel.BeginInvoke(tuple, _workerId, null, null); } catch (Exception) { } } Console.WriteLine("** FRONTEND REMOVE: Just removed " + tuple); }
public void SimpleParserWithWildCardsTest() { ParseTree tree = _parser.Parse(INST_2); Assert.IsNotNull(tree); Tuple t = (Tuple)tree.Eval(null); Assert.IsNotNull(t); Assert.AreEqual(_tuple1, t); }
private static Tuple checkTupleSyntax(Parser parser, string input) { ParseTree tree = parser.Parse(input); Tuple tuple = null; tuple = (Tuple)tree.Eval(null); if (tuple == null) { Console.WriteLine("### ERROR: Invalid tuple syntax representation"); } return(tuple); }
public void TestInitialize() { _fields = new List <object>(); _fields2 = new List <object>(); _fields.Add("dog"); _fields.Add("brown"); _tuple1 = new Tuple(_fields); _scanner = new Scanner(); _parser = new Parser(_scanner); }
public void Write(Tuple tuple) { ITupleSpace tupleSpace = null; foreach (string i in this.GetView()) { try { tupleSpace = (ITupleSpace)Activator.GetObject(typeof(ITupleSpace), i); tupleSpace.ItemCount(); tupleSpace.write(tuple); }catch (Exception) { Console.WriteLine("Server with address: " + i + "has crashed"); } } }
/// <summary> /// Callback function to process read's server' replies /// <param name="IAsyncResult"A AsyncResult Delgate Object.</param> /// </summary> public static void CallbackRead(IAsyncResult ar) { RemoteAsyncReadDelegate del = (RemoteAsyncReadDelegate)((AsyncResult)ar).AsyncDelegate; lock (ReadLock) { //Only care about one reply, ignore others if (_responseRead == null) { _responseRead = del.EndInvoke(ar); readHandles[0].Set(); } } }
public void ParseStringAndObjectTest() { ParseTree tree = _parser.Parse(INST_3); Assert.IsNotNull(tree); Tuple t = (Tuple)tree.Eval(null); Assert.IsNotNull(t); _fields2.Add("dog"); _fields2.Add(new DADTestA(1, "Cat")); _tuple2 = new Tuple(_fields2); Assert.AreEqual(_tuple2.GetNumberOfFields(), t.GetNumberOfFields()); Assert.AreEqual(_tuple2, t); }
public Tuple Take(Tuple tuple) { ITupleSpace tupleSpace = null; foreach (string i in this.GetView()) { try { tupleSpace = (ITupleSpace)Activator.GetObject(typeof(ITupleSpace), i); tupleSpace.ItemCount(); Tuple response = null; response = tupleSpace.take(tuple); if (response != null) { return(response); } }catch (Exception) { Console.WriteLine("Server with address: " + i + "has crashed"); } } return(null); }
public void ParseEqualsTest() { ParseTree tree1 = _parser.Parse(INST_4); Assert.IsNotNull(tree1); Tuple t1 = (Tuple)tree1.Eval(null); Assert.IsNotNull(t1); ParseTree tree2 = _parser.Parse(INST_5); Assert.IsNotNull(tree2); Tuple t2 = (Tuple)tree2.Eval(null); Assert.IsNotNull(t2); Assert.AreNotEqual(t1, t2); Assert.AreNotEqual(t2, t1); }
/// <summary> /// Execute an operation based on a parsed instruction. /// </summary> /// <param name="operation">Operation type (e.g. read, add, write, begin-repeat)</param> /// <param name="input">A complete string instruction</param> /// <param name="parser">An instance of the parser</param> /// <param name="frontEnd">An instance of the frontEnd (could be SMR ou XL).</param> /// <param name="prompt">A default string which are printed as prompt label.</param> private static void ExecuteOperation(string operation, string input, Parser parser, IFrontEnd frontEnd, string prompt) { Tuple tuple = null; switch (operation) { case "read": tuple = checkTupleSyntax(parser, input); Console.WriteLine("Tuple received: " + frontEnd.Read(tuple)); _counter++; break; case "add": tuple = checkTupleSyntax(parser, input); frontEnd.Write(tuple); _counter++; break; case "take": tuple = checkTupleSyntax(parser, input); Console.WriteLine("Tuple received: " + frontEnd.Take(tuple)); _counter++; break; case "begin-repeat": try { int times = Int32.Parse(input.Split(' ')[1]); if (times <= 0) { Console.WriteLine("### ERROR: Invalid begin-repeat arg: must be a positive integer!"); } else { _counter++; List <string> inputs = new List <string>(); while (true) { string innerInput = lines[_counter]; string innerOperation; //Only when end is provided we execute the all body of begin-repeat if (innerInput == "end-repeat") { for (int i = 0; i < times; i++) { foreach (string storedInput in inputs) { innerOperation = storedInput.Split(' ')[0]; ExecuteOperation(innerOperation, storedInput, parser, frontEnd, prompt); } } break; } else { inputs.Add(innerInput); _counter++; } } } } catch (Exception e) { Console.WriteLine("### ERROR: Invalid begin-repeat arg"); Console.WriteLine(e.StackTrace); } break; case "wait": try { int seconds = Int32.Parse(input.Split(' ')[1]); if (seconds <= 0) { Console.WriteLine("### ERROR: Invalid wait arg: must be a positive number!"); } else { Console.WriteLine("I'm waiting ..."); Thread.Sleep(seconds); Console.WriteLine("Finished waiting!"); _counter++; } } catch (Exception) { Console.WriteLine("### ERROR: Invalid wait arg"); } break; default: Console.WriteLine("### ERROR: Invalid command"); break; } }
public void Write(Tuple tuple) { bool ViewOutOfDate = true; while (ViewOutOfDate) { _responseWrite = new List <bool>(); View actualView = this.GetView(); int numberServers = actualView.Count(); numServers = numberServers; writeHandles = new AutoResetEvent[numberServers]; Console.WriteLine(actualView); for (int i = 0; i < numberServers; i++) { writeHandles[i] = new AutoResetEvent(false); } //List<ITupleSpaceXL> serversObj = new List<ITupleSpaceXL>(); List <string> toRemove = new List <string>(); foreach (string serverPath in actualView.Servers) { try { ITupleSpaceXL server = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), serverPath); RemoteAsyncWriteDelegate RemoteDel = new RemoteAsyncWriteDelegate(server.write); a++; AsyncCallback RemoteCallback = new AsyncCallback(CallbackWrite); IAsyncResult RemAr = RemoteDel.BeginInvoke(_workerId, _requestId, tuple, _view, CallbackWrite, null); } catch (System.Net.Sockets.SocketException) { Console.WriteLine("** FRONTEND WRITE: Could not call write on server"); } } WaitHandle.WaitAll(writeHandles, 2000); //When some server joins the view while the operation is taking place //Because some machine on my view crashed while the operation was taking place if (_responseWrite.Count != _view.Servers.Count) { writeCounter = 0; foreach (string s in _view.Servers) { try { ITupleSpaceXL tupleSpace = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), s); tupleSpace.checkView(); } catch (Exception) { Console.WriteLine("Server " + s + " is dead."); } } if (_responseWrite.Count > 0) { ViewOutOfDate = false; } } else { if (_responseWrite.Contains(false) == true) { Console.WriteLine("** FRONTEND WRITE: View has been changed"); } else { ViewOutOfDate = false; } } _requestId++; } Console.WriteLine("** FRONTEND WRITE: Just wrote " + tuple + " a = " + a); }
public Tuple Take(Tuple tuple) { bool ViewOutOfDate = true; while (ViewOutOfDate) { View actualView = this.GetView(); int numberServers = actualView.Servers.Count; numServers = numberServers; takeHandles = new AutoResetEvent[numberServers]; for (int i = 0; i < actualView.Servers.Count; i++) { takeHandles[i] = new AutoResetEvent(false); } Console.WriteLine("Vou tentar take: " + tuple); List <string> toRemove = new List <string>(); _responseTake = new List <List <Tuple> >(); foreach (string serverPath in actualView.Servers) { try { ITupleSpaceXL server = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), serverPath); RemoteAsyncTakeDelegate RemoteDel = new RemoteAsyncTakeDelegate(server.take); AsyncCallback RemoteCallback = new AsyncCallback(CallbackTake); IAsyncResult RemAr = RemoteDel.BeginInvoke(_workerId, _requestId, tuple, _view, CallbackTake, null); ViewOutOfDate = false; } catch (System.Net.Sockets.SocketException) { Console.WriteLine("** FRONTEND TAKE: Could not call take on server " + serverPath); } } //miguel: this only works in perfect case //TODO: One machine belonging to the view has just crashed WaitHandle.WaitAll(takeHandles, 10000); if (_responseTake.Count != _view.Servers.Count) { takeCounter = 0; foreach (string s in _view.Servers) { try { ITupleSpaceXL tupleSpace = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), s); tupleSpace.checkView(); } catch (Exception) { Console.WriteLine("Server " + s + " is dead."); } } if (_responseTake.Count > 0) { ViewOutOfDate = false; } } else { if (_responseTake.Contains(null) == true) { Console.WriteLine("** FRONTEND TAKE: View has been changed."); _requestId++; } else { ViewOutOfDate = false; } } } //Performs the intersection of all responses and decide using TupleSelection Tuple tup = TupleSelection(Intersection(_responseTake)); if (tup == null) { Remove(null); } //Tuple tup is now selected lets remove if (tup != null) { Remove(tup); } _requestId++; if (tup != null) { Console.WriteLine("** FRONTEND TAKE: Here is a response: " + tup); } else { Console.WriteLine("** FRONTEND TAKE: Here is a NULL response"); } return(tup); }
public Tuple Read(Tuple tuple) { readHandles = new AutoResetEvent[1]; readHandles[0] = new AutoResetEvent(false); View actualView = this.GetView(); List <ITupleSpaceXL> serversObj = new List <ITupleSpaceXL>(); List <string> toRemove = new List <string>(); ITupleSpaceXL tupleSpace = null; _responseRead = null; //save remoting objects of all members of the view foreach (string serverPath in actualView.Servers) { try { tupleSpace = (ITupleSpaceXL)Activator.GetObject(typeof(ITupleSpaceXL), serverPath); tupleSpace.ItemCount(); //just to check availability of the server } catch (System.Net.Sockets.SocketException) { tupleSpace = null; toRemove.Add(serverPath); } if (tupleSpace != null) { serversObj.Add(tupleSpace); } } if (serversObj.Count > 0) { foreach (string crashed in toRemove) { //only one can crash so serverObj is obviously online _view = serversObj[0].Remove(crashed); } } else { Console.WriteLine("All servers are dead! Exiting..."); Environment.Exit(1); } foreach (ITupleSpaceXL server in serversObj) { try { RemoteAsyncReadDelegate RemoteDel = new RemoteAsyncReadDelegate(server.read); AsyncCallback RemoteCallback = new AsyncCallback(CallbackRead); IAsyncResult RemAr = RemoteDel.BeginInvoke(tuple, CallbackRead, null); } catch (System.Net.Sockets.SocketException) { Console.WriteLine("** FRONTEND READ: Cannot invoke read on server!"); } } while (_responseRead == null) { Console.WriteLine("** FRONTEND READ: Not yet receive any reply let me wait..."); WaitHandle.WaitAny(readHandles); } _requestId++; Console.WriteLine("** FRONTEND READ: Here is a response: " + _responseRead); return(_responseRead); }