static void Main(string[] args) { try { NetworkClient nc = new NetworkClient("localhost", 22222); if (nc == null) { Console.WriteLine("RemoteTester: NetworkClient object equals to null"); return; } byte[] data = new Register(NodeType.ComputationalNode, 1, new List<string>() { "test1", "test2" }).GetXmlData(); byte[] bytes = nc.Work(data); if (bytes != null) { XMLParser parser = new XMLParser(bytes.ToArray()); Console.WriteLine((parser.Message as RegisterResponse).Id); Console.WriteLine((parser.Message as RegisterResponse).Timeout); } else Console.WriteLine("RemoteTester: bytes equals to null"); } catch (Exception e) { Console.WriteLine(e.Message); } }
/// <summary> /// Rejestracja komponentu u CS /// </summary> /// <returns></returns> public bool Register() { try { Register register_message = new Register(type, computational_power, problem_names); byte[] register_response = client.Work(register_message.GetXmlData()); XMLParser parser = new XMLParser(register_response); if (parser.MessageType == MessageTypes.RegisterResponse) { RegisterResponse register_response_msg = parser.Message as RegisterResponse; id = register_response_msg.Id; timeout = register_response_msg.Timeout; timeout_in_ms = (timeout.Hour * 3600 + timeout.Minute * 60 + timeout.Second) * 1000 + timeout.Millisecond; Console.WriteLine("Received register values: id = {0}, timeout = {1} ms", id, timeout_in_ms); } else { Console.WriteLine("SolverNode: registration failed"); return false; } return true; } catch { Console.WriteLine("Register failure"); return false; } }
public void SolutionRequestParseTest() { //Arrange SolutionRequest sr = new SolutionRequest(123); byte[] data = sr.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.SolutionRequest, parser.MessageType); Assert.AreEqual(sr.Id, ((SolutionRequest)parser.Message).Id); }
public void RegisterParseTest() { //Arrange Register register = new Register(NodeType.TaskManager, 120, new List<string>() { "abc", "def" }); byte[] data = register.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.Register, parser.MessageType); Register result = (Register)parser.Message; Assert.AreEqual(result.ParallelThreads, register.ParallelThreads); Assert.AreEqual(result.Type, register.Type); }
public void DivideProblemParseTest() { //Arrange DivideProblem dp = new DivideProblem("name", 123, new byte[] { 1, 2, 3 }, 123); byte[] data = dp.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.DivideProblem, parser.MessageType); DivideProblem result = (DivideProblem)parser.Message; Assert.AreEqual(dp.Id, result.Id); Assert.AreEqual(dp.ProblemType, result.ProblemType); Assert.AreEqual(dp.ComputationalNodes, result.ComputationalNodes); Assert.AreEqual(dp.Data.Length, result.Data.Length); }
public void RegisterResponseParseTest() { //Arrange RegisterResponse registerResponse = new RegisterResponse(120, new TimeSpan(12,12,12)); byte[] data = registerResponse.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.RegisterResponse, parser.MessageType); RegisterResponse result = (RegisterResponse)parser.Message; Assert.AreEqual(registerResponse.Id, result.Id); Assert.AreEqual(registerResponse.Timeout.Hour, result.Timeout.Hour); Assert.AreEqual(registerResponse.Timeout.Minute, result.Timeout.Minute); Assert.AreEqual(registerResponse.Timeout.Second, result.Timeout.Second); Assert.AreEqual(registerResponse.Timeout.Millisecond, result.Timeout.Millisecond); }
public void SolutionsParseTest() { //Arrange Solutions s = new Solutions("name", 123, new byte[] { 1, 3, 5 }, new Solution[] { new Solution(null, false, SolutionType.Ongoing, 100, new byte[]{ 1, 2}), new Solution(123, true, SolutionType.Partial, 400, new byte[]{ 3, 5, 7, 8}) }); byte[] data = s.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.Solutions, parser.MessageType); Solutions rs = (Solutions)parser.Message; Assert.AreEqual(s.CommonData.Length, rs.CommonData.Length); Assert.AreEqual(s.Id, rs.Id); Assert.AreEqual(s.ProblemType, rs.ProblemType); Assert.AreEqual(s.SolutionsList.Count, rs.SolutionsList.Count); Solution sol = s.SolutionsList[0]; Solution rsol = rs.SolutionsList[0]; Assert.AreEqual(sol.ComputationsTime, rsol.ComputationsTime); Assert.AreEqual(sol.Data.Length, rsol.Data.Length); Assert.AreEqual(sol.TaskId, rsol.TaskId); Assert.AreEqual(sol.TimeoutOccured, rsol.TimeoutOccured); Assert.AreEqual(sol.Type, rsol.Type); }
public void StatusParseTest() { //Arrange Status s = new Status(123, new List<ComputationalThread>() { new ComputationalThread(ComputationalThreadState.Busy, 100, 300, 200, "name"), new ComputationalThread(ComputationalThreadState.Idle, 200, null, null, "name2")}); byte[] data = s.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.Status, parser.MessageType); Status rs = (Status)parser.Message; Assert.AreEqual(s.Id, rs.Id); Assert.AreEqual(s.Threads.Count, rs.Threads.Count); ComputationalThread t = s.Threads[0]; ComputationalThread rt = rs.Threads[0]; Assert.AreEqual(t.HowLong, rt.HowLong); Assert.AreEqual(t.ProblemInstanceId, rt.ProblemInstanceId); Assert.AreEqual(t.State, rt.State); Assert.AreEqual(t.TaskId, rt.TaskId); }
public void SolveRequestWithTimeoutParseTest() { //Arrange SolveRequest sr = new SolveRequest("name", new byte[] { 1, 2 }, 123); byte[] data = sr.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.SolveRequest, parser.MessageType); SolveRequest result = (SolveRequest)parser.Message; Assert.AreEqual(sr.ProblemType, result.ProblemType); Assert.AreEqual(sr.Data.Length, result.Data.Length); Assert.AreEqual(sr.SolvingTimeout, result.SolvingTimeout); }
/// <summary> /// Pobiera status przetwarzania problemu i wyswietla na konsole /// </summary> public void getProblemStatus() { SolutionRequest solution_request = new SolutionRequest(problem_id); byte[] solution_response = client.Work(solution_request.GetXmlData()); if (solution_response != null) { XMLParser parser = new XMLParser(solution_response); if (parser.MessageType == MessageTypes.Solutions) { Solutions solutions_status = parser.Message as Solutions; if (solutions_status != null) { Console.WriteLine("Odebrano ID: {0}, problem {1}", solutions_status.Id, solutions_status.ProblemType); string computing_status = null; if (solutions_status.SolutionsList != null && solutions_status.SolutionsList.Count() == 0) Console.WriteLine("Solution status received: no solutions available on the list"); else foreach (Solution s in solutions_status.SolutionsList) { switch (s.Type) { case SolutionType.Final: computing_status = "Final"; SolutionContainer a = (SolutionContainer)new BinaryFormatter().Deserialize(new MemoryStream(s.Data)); Console.WriteLine(); Console.WriteLine("MinCost = " + a.MinCost); Console.WriteLine(); foreach (var q in a.MinPath) { foreach (var w in q) Console.Write(w + ", "); Console.WriteLine(); } Console.WriteLine(); foreach (var q in a.Times) { foreach (var w in q) Console.Write(w + ", "); Console.WriteLine(); } TimeSpan ts = new TimeSpan((long)s.ComputationsTime*10000000); Console.WriteLine("Time: " + ts.ToString()); break; case SolutionType.Ongoing: computing_status = "OnGoing"; break; case SolutionType.Partial: computing_status = "Partial"; break; } Console.WriteLine("Task Id: {0}, computation status: {1}", s.TaskId, computing_status); } } } } else { Console.WriteLine("ComputationalClient: check solutions status failed"); } }
public void SolvePartialProblemsParseTest() { //Arrange SolvePartialProblems spp = new SolvePartialProblems("name", 123, new byte[] { 1, 2, 3 }, null, new List<PartialProblem>() { new PartialProblem(123, new byte[]{ 1, 2, 3, 4}), new PartialProblem(321, new byte[]{ 4, 3, 2, 1}) }); byte[] data = spp.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.SolvePartialProblems, parser.MessageType); SolvePartialProblems result = (SolvePartialProblems)parser.Message; Assert.AreEqual(spp.CommonData.Length, result.CommonData.Length); Assert.AreEqual(spp.Id, result.Id); Assert.AreEqual(spp.PartialProblems.Count, result.PartialProblems.Count); Assert.AreEqual(spp.ProblemType, result.ProblemType); Assert.IsNull(result.SolvingTimeout); PartialProblem p = spp.PartialProblems[0]; PartialProblem rp = spp.PartialProblems[0]; Assert.AreEqual(p.TaskId, rp.TaskId); Assert.AreEqual(p.Data.Length, rp.Data.Length); }
public void SendStatusMessage() { Status status_msg = new Status(id, threads); Console.WriteLine("CN: sending status message..."); byte[] response = client.Work(status_msg.GetXmlData()); if (response == null) { Console.WriteLine("CN: response is equal to null"); } else { XMLParser parser = new XMLParser(response); switch (parser.MessageType) { case MessageTypes.SolvePartialProblems: // Thread problem_solve_thread = new Console.WriteLine("CN: Received solve partial problems message"); SolveProblem((SolvePartialProblems)parser.Message); break; default: Console.WriteLine("Different message than SolvePartialProblems received"); Console.WriteLine(parser.MessageType); break; } } }
/// <summary> /// Handler wywoływany przez klasę nasłuchującą. /// </summary> /// <param name="data">Odebrane dane w postaci binarnej.</param> /// <param name="ctx">Kontekst połączenia. Można wysłać przez niego odpowiedź do klienta który wysłal dane</param> private void ConnectionHandler(byte[] data, ConnectionContext ctx) { XMLParser parser; try { parser = new XMLParser(data); } catch (Exception e) { debug.Print("Received invalid message!"); ctx.Send(null); return; } MessageObject response = null; switch (parser.MessageType) { case MessageTypes.Register: debug.Print("Received 'Register' message."); response = RegisterNewNode(parser.Message); break; case MessageTypes.SolveRequest: debug.Print("Received 'SolveRequest' message."); response = RegisterNewProblem(parser.Message); break; case MessageTypes.Status: debug.Print("Received 'Status' message."); response = UpdateAndGiveData(parser.Message); break; case MessageTypes.SolutionRequest: debug.Print("Received 'SolutionRequest' message."); response = SendSolution(parser.Message); break; case MessageTypes.SolvePartialProblems: debug.Print("Received 'SolvePartialProblems' message."); GetDividedProblem(parser.Message); break; case MessageTypes.Solutions: debug.Print("Received 'Solutions' message."); GetSolutions(parser.Message); break; } ctx.Send(response == null ? null : response.GetXmlData()); }
public void ServerRegisterMsgTest() { int port = 22222; Server srv = new Server(port, new TimeSpan(0, 0, 10)); Task t = Task.Factory.StartNew(srv.Start); byte[] data = new Register(NodeType.ComputationalNode, 1, new List<string>() { "test1", "test2" }).GetXmlData(); byte[] bytes = null; XMLParser parser = null; // *** Valid port and address *** NetworkClient nc = new NetworkClient("localhost", port); NetworkClient nc2 = new NetworkClient("localhost", port); Assert.IsNotNull(srv); Assert.IsNotNull(nc); Assert.IsNotNull(nc2); // first cli bytes = nc.Work(data); Assert.IsNotNull(bytes); parser = new XMLParser(bytes); Assert.IsNotNull(parser); Assert.AreEqual(parser.MessageType, MessageTypes.RegisterResponse); // first cli, trying to connect second time bytes = nc.Work(data); Assert.IsNotNull(bytes); parser = new XMLParser(bytes); Assert.IsNotNull(parser); Assert.AreEqual(parser.MessageType, MessageTypes.RegisterResponse); // second cli bytes = nc2.Work(data); Assert.IsNotNull(bytes); parser = new XMLParser(bytes); Assert.IsNotNull(parser); Assert.AreEqual(parser.MessageType, MessageTypes.RegisterResponse); srv.Stop(); t.Wait(); // *** Valid port and address (srv is stopped) bytes = nc.Work(data); Assert.IsNull(bytes); // *** invalid port number *** srv = new Server(-1, new TimeSpan(0, 0, 10)); t = Task.Factory.StartNew(srv.Start); bytes = nc.Work(data); Assert.IsNull(bytes); srv.Stop(); t.Wait(); }
public void SolveRequestResponseParseTest() { //Arrange SolveRequestResponse srr = new SolveRequestResponse(123); byte[] data = srr.GetXmlData(); //Act XMLParser parser = new XMLParser(data); //Assert Assert.IsNotNull(parser); Assert.AreEqual(MessageTypes.SolveRequestResponse, parser.MessageType); Assert.AreEqual(srr.Id, ((SolveRequestResponse)parser.Message).Id); }
public void SendStatusMessage() { Status status_msg = new Status(id, threads); Console.WriteLine("TM: sending status message..."); byte[] response = client.Work(status_msg.GetXmlData()); if (response == null) { Console.WriteLine("TM: response is set to null"); } else { XMLParser parser = new XMLParser(response); switch (parser.MessageType) { case MessageTypes.DivideProblem: Console.WriteLine("TM divides and send problem to CS"); DivideProblem msg = (DivideProblem)parser.Message; ComputationalThread ct = threads.Find(x => x.State == ComputationalThreadState.Idle); threads.Remove(ct); ComputationalThread new_thread = new ComputationalThread(ComputationalThreadState.Busy, 0, msg.Id, 1, msg.ProblemType); threads.Add(new_thread); Thread t = new Thread(() => DivideThreadFunc(msg, new_thread)); t.Start(); break; case MessageTypes.Solutions: Console.WriteLine("TM: try merge solutions is starting"); Solutions sol_msg = (Solutions)parser.Message; Console.WriteLine("TM try to Merge solution of the problem with id = {0} into final", sol_msg.Id); //check if solved problems number is equal to if (!PartialSolutions.ContainsKey(sol_msg.Id)) PartialSolutions.Add(sol_msg.Id, new List<byte[]>()); SolverRegisteredProblem p = ongoing_problems.Find(x => sol_msg.Id == x.ProblemId); if (p != null) { foreach (Solution s in sol_msg.SolutionsList) { if (s.Data != null) { p.MarkAsSolved((ulong)s.TaskId); PartialSolutions[sol_msg.Id].Add(s.Data); p.SetComputationsTime(s.ComputationsTime); } } } else Console.WriteLine("Not foung Solver registered problem"); if (p != null && p.IsProblemSolved()) { ongoing_problems.Remove(p); Console.WriteLine("TM: Ready to merge solution"); //one common solution ComputationalThread sol_ct = threads.Find(x => x.State == ComputationalThreadState.Idle); threads.Remove(sol_ct); ComputationalThread new_sol_thread = new ComputationalThread(ComputationalThreadState.Busy, p.computation_time, sol_msg.Id, 1, sol_msg.ProblemType); threads.Add(new_sol_thread); Thread sol_t = new Thread(() => MergeThreadFunc(sol_msg, new_sol_thread)); sol_t.Start(); } else { client.Work(sol_msg.GetXmlData()); } break; default: Console.WriteLine("received other message: " + response.GetType().ToString()); client.Work(status_msg.GetXmlData()); break; } } }
/// <summary> /// Rejestruje problem umieszczony w pliku o podanej sciezce w Serwerze /// </summary> /// <param name="problem_data_filepath">sciezka do pliku XML z danymi problemu</param> /// <returns> wartosc boolowska - czy problem zostal zarejestrowany pomyslnie</returns> public bool registerProblem(string problem_data_filepath) { // XmlDocument problem_data_xml = new XmlDocument(); MemoryStream ms = new MemoryStream(); System.IO.File.OpenRead(problem_data_filepath).CopyTo(ms); byte[] data = ms.ToArray(); SolveRequest solve_request = new SolveRequest(problem_type, /*problem_*/data,solving_timeout); byte[] register_response = client.Work(solve_request.GetXmlData()); if (register_response != null) { XMLParser parser = new XMLParser(register_response); if (parser.MessageType == MessageTypes.SolveRequestResponse) { SolveRequestResponse register_response_msg = parser.Message as SolveRequestResponse; problem_id = register_response_msg.Id; } } else { Console.WriteLine("ComputationalClient: problem registration failed"); return false; } Console.WriteLine("Problem registered with id = {0}", problem_id); return true; }