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;
}
