/// <summary>
/// Register new component in problem instance
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, MessageType messageType, TimeSpan timout)
{
Register msg = MessageSerialization.Deserialize<Register>(message);
if (msg == null || msg.SolvableProblems == null)// || msg.SolvableProblems.Where(p => p.ToLower().Contains("dvrp")).Count() == 0)
return;
DvrpProblem.WaitEvent.WaitOne();
ulong id = DvrpProblem.CreateComponentID();
DvrpProblem.ComponentsID.Add(id);
if (msg.Type == RegisterType.ComputationalNode)
{
DvrpProblem.Nodes.Add(id, msg);
}
else
{
DvrpProblem.Tasks.Add(id, msg);
DvrpProblem.ProblemsDividing.Add(id, new List<ulong>());
DvrpProblem.SolutionsMerging.Add(id, new List<ulong>());
}
DvrpProblem.ComponentsLastStatus.Add(id, DateTime.UtcNow);
RegisterResponse reponse = new RegisterResponse() { Id = id, Timeout = timout.ToString()};
networkAdapter.Send(reponse);
DvrpProblem.WaitEvent.Set();
}
/// <summary>
/// Response for clients solution request
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timeout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, MessageType messageType, TimeSpan timeout)
{
SolutionRequest request = MessageSerialization.Deserialize<SolutionRequest>(message);
if (request == null)
return;
DvrpProblem.WaitEvent.WaitOne();
if (!DvrpProblem.Problems.ContainsKey(request.Id))
{
DvrpProblem.WaitEvent.Set();
return;
}
if (DvrpProblem.ProblemSolutions.ContainsKey(request.Id))
{
Solutions solution = DvrpProblem.ProblemSolutions[request.Id];
DvrpProblem.ProblemsID.Remove(request.Id);
DvrpProblem.Problems.Remove(request.Id);
DvrpProblem.ProblemSolutions.Remove(request.Id);
networkAdapter.Send(solution);
DvrpProblem.WaitEvent.Set();
return;
}
SolveRequest problem = DvrpProblem.Problems[request.Id];
Solutions response = new Solutions();
response.Id = request.Id;
response.ProblemType = problem.ProblemType;
response.CommonData = problem.Data;
List<SolutionsSolution> solutionList = new List<SolutionsSolution>();
if (DvrpProblem.PartialSolutions.ContainsKey(request.Id))
solutionList.AddRange(DvrpProblem.PartialSolutions[request.Id]);
if (DvrpProblem.PartialProblems.ContainsKey(request.Id))
foreach (var element in DvrpProblem.PartialProblems[request.Id])
if (element.Value > 0)
{
SolutionsSolution sol = new SolutionsSolution();
sol.TaskId = element.Key.TaskId;
sol.Data = element.Key.Data;
sol.Type = SolutionsSolutionType.Ongoing;
solutionList.Add(sol);
}
if (solutionList.Count > 0)
response.Solutions1 = solutionList.ToArray();
else
response.Solutions1 = new SolutionsSolution[] { new SolutionsSolution { Data = new byte[1] } };
networkAdapter.Send(response);
DvrpProblem.WaitEvent.Set();
}
/// <summary>
/// Register new problem from client
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timeout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, MessageType messageType, TimeSpan timeout)
{
SolveRequest request = MessageSerialization.Deserialize<SolveRequest>(message);
if (request == null || request.Data == null)// || !request.ProblemType.ToLower().Contains("dvrp"))
return;
DvrpProblem.WaitEvent.WaitOne();
ulong id = DvrpProblem.CreateProblemID();
DvrpProblem.ProblemsID.Add(id);
DvrpProblem.Problems.Add(id, request);
SolveRequestResponse response = new SolveRequestResponse() { Id = id };
networkAdapter.Send(response);
DvrpProblem.WaitEvent.Set();
}
/// <summary>
/// Registers divided problem into smaller problems from task
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, Common.MessageType messageType, TimeSpan timout)
{
SolvePartialProblems partial = MessageSerialization.Deserialize<SolvePartialProblems>(message);
if (partial == null || partial.PartialProblems == null)
return;
DvrpProblem.WaitEvent.WaitOne();
if(!DvrpProblem.PartialProblems.ContainsKey(partial.Id))
DvrpProblem.PartialProblems.Add(partial.Id, new List<KeyValuePair<SolvePartialProblemsPartialProblem, ulong>>());
foreach(var partialProblem in partial.PartialProblems)
DvrpProblem.PartialProblems[partial.Id].Add(new KeyValuePair<SolvePartialProblemsPartialProblem, ulong>(partialProblem, 0));
foreach (var list in DvrpProblem.ProblemsDividing.Values)
if (list.Remove(partial.Id))
break;
DvrpProblem.WaitEvent.Set();
}
/// <summary>
/// Registers new solutions from either node or task
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, Common.MessageType messageType, TimeSpan timout)
{
Solutions sol = MessageSerialization.Deserialize<Solutions>(message);
DvrpProblem.WaitEvent.WaitOne();
if (sol == null || sol.Solutions1 == null || !DvrpProblem.Problems.ContainsKey(sol.Id))
{
DvrpProblem.WaitEvent.Set();
return;
}
if (sol.Solutions1.First().Type == SolutionsSolutionType.Final)
{
if (!DvrpProblem.ProblemSolutions.ContainsKey(sol.Id))
DvrpProblem.ProblemSolutions.Add(sol.Id, sol);
DvrpProblem.PartialSolutions.Remove(sol.Id);
foreach (var list in DvrpProblem.SolutionsMerging.Values)
if (list.Remove(sol.Id))
break;
}
else
{
if (!DvrpProblem.PartialSolutions.ContainsKey(sol.Id))
DvrpProblem.PartialSolutions.Add(sol.Id, new List<SolutionsSolution>());
DvrpProblem.PartialSolutions[sol.Id].AddRange(sol.Solutions1);
foreach (var solution in sol.Solutions1)
DvrpProblem.PartialProblems[sol.Id].RemoveAll(p => p.Key.TaskId == solution.TaskId);
if (DvrpProblem.PartialProblems[sol.Id].Count == 0)
DvrpProblem.PartialProblems.Remove(sol.Id);
}
DvrpProblem.WaitEvent.Set();
}
/// <summary>
/// Sends partial solutions to task (if any is available)
/// </summary>
public static void Work(ulong taskId, ServerNetworkAdapter networkAdapter)
{
if (DvrpProblem.ProblemsDividing[taskId].Count > 0 || DvrpProblem.SolutionsMerging[taskId].Count > 0)
return;
ulong problemId = 0;
var problems = new List<ulong>(DvrpProblem.ProblemsID);
foreach (var list in DvrpProblem.ProblemsDividing.Values)
foreach (var el in list)
problems.Remove(el);
foreach (var list in DvrpProblem.SolutionsMerging.Values)
foreach (var el in list)
problems.Remove(el);
foreach (var id in problems)
if (!DvrpProblem.PartialProblems.ContainsKey(id) && DvrpProblem.PartialSolutions.ContainsKey(id) && !DvrpProblem.ProblemSolutions.ContainsKey(id))
{
problemId = id;
break;
}
if (problemId == 0)
return;
var partialSolutions = DvrpProblem.PartialSolutions[problemId];
SolveRequest problem = DvrpProblem.Problems[problemId];
Solutions response = new Solutions();
response.Id = problemId;
response.ProblemType = problem.ProblemType;
response.CommonData = problem.Data;
response.Solutions1 = partialSolutions.ToArray();
if (networkAdapter.Send(response))
DvrpProblem.SolutionsMerging[taskId].Add(problemId);
}
/// <summary>
/// Keeps alive component, which sent status message
/// </summary>
/// <param name="networkAdapter"></param>
/// <param name="message"></param>
/// <param name="messageType"></param>
/// <param name="timeout"></param>
public void HandleMessage(ServerNetworkAdapter networkAdapter, string message, MessageType messageType, TimeSpan timeout)
{
Status msg = MessageSerialization.Deserialize<Status>(message);
if (msg == null)
return;
DvrpProblem.WaitEvent.WaitOne();
if (!DvrpProblem.ComponentsID.Contains(msg.Id))
{
DvrpProblem.WaitEvent.Set();
return;
}
DvrpProblem.ComponentsLastStatus[msg.Id] = DateTime.UtcNow;
if(DvrpProblem.Nodes.ContainsKey(msg.Id))
NodeWorker.Work(msg.Id, networkAdapter);
else if (DvrpProblem.Tasks.ContainsKey(msg.Id))
{
TaskMergeWorker.Work(msg.Id, networkAdapter);
TaskDivideWorker.Work(msg.Id, networkAdapter);
}
DvrpProblem.WaitEvent.Set();
}
/// <summary>
/// Sends problem to task (if any is available)
/// </summary>
public static void Work(ulong taskId, ServerNetworkAdapter networkAdapter)
{
if (DvrpProblem.ProblemsDividing[taskId].Count > 0 || DvrpProblem.SolutionsMerging[taskId].Count > 0)
return;
ulong problemId = 0;
var problems = new List<ulong>(DvrpProblem.ProblemsID);
foreach (var list in DvrpProblem.ProblemsDividing.Values)
foreach (var el in list)
problems.Remove(el);
foreach (var list in DvrpProblem.SolutionsMerging.Values)
foreach (var el in list)
problems.Remove(el);
foreach (var id in problems)
if (!DvrpProblem.PartialProblems.ContainsKey(id) && !DvrpProblem.PartialSolutions.ContainsKey(id) && !DvrpProblem.ProblemSolutions.ContainsKey(id))
{
problemId = id;
break;
}
if (problemId == 0)
return;
var pr = DvrpProblem.Problems[problemId];
DivideProblem div = new DivideProblem();
div.Id = problemId;
div.ProblemType = pr.ProblemType;
div.Data = pr.Data;
div.ComputationalNodes = (ulong)DvrpProblem.Nodes.Count;
if (networkAdapter.Send(div))
DvrpProblem.ProblemsDividing[taskId].Add(problemId);
}
/// <summary>
/// Sends partial problem to client (if any is available)
/// </summary>
public static void Work(ulong nodeId, ServerNetworkAdapter networkAdapter)
{
foreach (var list in DvrpProblem.PartialProblems.Values)
foreach (var el in list)
if (el.Value == nodeId)
return;
ulong problemId = 0;
KeyValuePair<SolvePartialProblemsPartialProblem, ulong> partialProblem = new KeyValuePair<SolvePartialProblemsPartialProblem, ulong>();
foreach (var list in DvrpProblem.PartialProblems)
{
partialProblem = list.Value.FirstOrDefault(p => p.Value == 0);
if (partialProblem.Key != null)
{
list.Value.Remove(partialProblem);
problemId = list.Key;
break;
}
}
if (partialProblem.Key == null)
return;
var msg = new SolvePartialProblems();
msg.Id = problemId;
msg.CommonData = DvrpProblem.Problems[problemId].Data;
msg.ProblemType = DvrpProblem.Problems[problemId].ProblemType;
msg.SolvingTimeout = DvrpProblem.Problems[problemId].SolvingTimeout;
msg.SolvingTimeoutSpecified = DvrpProblem.Problems[problemId].SolvingTimeoutSpecified;
msg.PartialProblems = new SolvePartialProblemsPartialProblem[] { partialProblem.Key };
if (networkAdapter.Send(msg))
DvrpProblem.PartialProblems[problemId].Add(new KeyValuePair<SolvePartialProblemsPartialProblem, ulong>(partialProblem.Key, nodeId));
}
private void HandleConnection(object o)
{
Socket soc = (Socket)o;
Stream stream = new NetworkStream(soc);
stream.ReadTimeout = 1000 * 5;
try
{
ServerNetworkAdapter networkAdapter = new ServerNetworkAdapter(stream);
bool stopRead = false;
StringBuilder sb = new StringBuilder();
string msg = string.Empty;
while (!stopRead)
{
try
{
byte[] buffer = new byte[1024];
stream.Read(buffer, 0, buffer.Length);
msg = MessageSerialization.GetString(buffer).Replace("\0", string.Empty).Trim();
sb.Append(msg);
if (msg == "")
stopRead = true;
}
catch (Exception e)
{
stopRead = true;
}
}
msg = sb.ToString();
Console.WriteLine(@"Odebrano:
{0}", msg);
MessageType msgType = MessageTypeConverter.ConvertToMessageType(msg);
IMessageStrategy strategy = strategyFactory.GetMessageStrategy(msgType);
if (strategy != null)
strategy.HandleMessage(networkAdapter, msg, msgType, timeout);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
stream.Close();
soc.Close();
}
}