/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
public void Communicate(Message message)
{
lock (this)
{
while (!client.Connected)
{
SmartConsole.PrintLine("Lost connection, reconnecting...", SmartConsole.DebugLevel.Advanced);
client.Connect();
}
// Send to server
client.Send(message);
// Wait for response
List <Message> responseMessage = client.ReceiveMessages();
for (int i = 0; i < responseMessage.Count; i++)
{
// handle response
// This is wrong Socket, but we dont use it anyway.
MessagePackage package = new MessagePackage(responseMessage[i], client.Socket);
messageHandler.HandleMessage(package);
}
}
}
/// <summary>
/// SolveRequest is sent by Computational Client
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolveRequestMessage(MessagePackage messagePackage)
{
SolveRequestMessage message = (SolveRequestMessage)messagePackage.Message;
InformBackup(message);
// if the cluster can solve this problem
if (clientTracker.CanSolveProblem(message.ProblemType))
{
Task task = new Task((int)systemTracker.GetNextTaskID(), message.ProblemType,
message.Data);
taskTracker.AddTask(task);
if (Server.primaryMode)
{
NoOperationMessage responseNoOp = new NoOperationMessage(clientTracker.BackupServers);
SolveRequestResponseMessage response = new SolveRequestResponseMessage((ulong)task.ID);
List <Message> messages = new List <Message>();
messages.Add(responseNoOp);
messages.Add(response);
server.Send(messagePackage.Socket, messages);
SmartConsole.PrintLine("Sent a SolveRequestResponse Message", SmartConsole.DebugLevel.Basic);
}
}
else
{
//TODO RESPONSE MESSAGE
Console.Write(" >> TM ERROR\n");
}
}
private void handleSolvePartialProblemsMessage(SolvePartialProblemsMessage message)
{
//number of PartialProblems shouldn't be bigger than the number of idle threads.
int numberOfPartialProblems = message.PartialProblems.Count();
int partialProblemCounter = 0;
for (int i = 0; i < systemTracker.Node.ParallelThreads && partialProblemCounter < numberOfPartialProblems; i++)
{
if (systemTracker.Node.TaskThreads[i].StatusThread.State == StatusThreadState.Idle)
{
DVRPSolver dvrpSolver = new DVRPSolver(message.PartialProblems[partialProblemCounter].Data);
systemTracker.Node.TaskThreads[i].StatusThread.State = StatusThreadState.Busy;
systemTracker.Node.TaskThreads[i].CurrentTask = new Cluster.Task((int)message.Id, message.ProblemType,
message.PartialProblems[i].Data)
{
Status = Cluster.TaskStatus.Solving
};
systemTracker.Node.TaskThreads[i].TaskSolver = dvrpSolver;
systemTracker.Node.TaskThreads[i].Thread = new Thread(new ThreadStart(systemTracker.Node.TaskThreads[i].Start));
systemTracker.Node.TaskThreads[i].Thread.Start();
partialProblemCounter++;
SmartConsole.PrintLine("Thread number: " + i + " is solving partial problemŁ " + partialProblemCounter, SmartConsole.DebugLevel.Advanced);
}
}
///WE SHOULD CHECK HERE WHETHER THERE WAS IDLE THREAD AVALIABLE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// start computations
}
private bool registerExistingNode(RegisterMessage message, Socket socket)
{
NetworkNode node = new NetworkNode(message.Type, message.Id, (uint)systemTracker.Timeout, message.ParallelThreads, message.SolvableProblems,
clientTracker.BackupServers);
IPAddress address = (socket.RemoteEndPoint as IPEndPoint).Address;
int port = (ushort)Server.PRIMARY_PORT;
// TODO hack
if (clientTracker.BackupServers.Length == 1)
{
port = (ushort)Server.PRIMARY_PORT2;
}
node.Address = address;
node.Port = (ushort)port;
// Dont inform backup about it self
// It comes naturally in NoOperation message
if (node.Type == RegisterType.CommunicationServer &&
(server.Address.ToString().Equals(address.ToString()) && server.Port == port))
{
return(false);
}
SmartConsole.PrintLine("Backup adding existing node", SmartConsole.DebugLevel.Advanced);
clientTracker.AddNode(node);
return(true);
}
/********************************************************************/
/************************** PRIVATE METHODS *************************/
/********************************************************************/
private void startMessageQueue()
{
SmartConsole.PrintLine("Message Queing Actived", SmartConsole.DebugLevel.Advanced);
while (Active)
{
// should hang
ArrayList socketsToRead = server.SelectForRead();
foreach (Socket socket in socketsToRead)
{
// NEW SENDING MESSAGE
List <Message> messages = server.ReceiveMessages(socket);
for (int i = 0; i < messages.Count; i++)
{
Message message = messages[i];
// Message was null if client disconnected
if (message == null)
{
continue;
}
MessagePackage messageHandler = new MessagePackage(message, socket);
lock (Queue)
{
Queue.Enqueue(messageHandler);
}
}
// END NEW SENDING MESSAGE
}
}
SmartConsole.PrintLine("Message Queing Deactived", SmartConsole.DebugLevel.Advanced);
}
/// <summary>
/// this function is a response to task manager status message
/// </summary>
/// <param name="networkNode"></param>
/// <param name="messagePackage"></param>
private void ReactToTaskManagerStatusMessage(NetworkNode networkNode, MessagePackage messagePackage)
{
//checks if divide or merge solution message has been sent. If not than send noOperation message.
bool hasMessageBeenSent = false;
int numberOfAvaliableThreads = AvaliableThreadsCount(networkNode);
for (int i = 0; i < taskTracker.Tasks.Count && numberOfAvaliableThreads > 0; i++)
{
if (isMessageProblemDividedSent(i, networkNode, messagePackage))
{
hasMessageBeenSent = true;
numberOfAvaliableThreads--;
}
}
// If there are avaliable threads than try to send merge solution message
for (int i = 0; i < taskTracker.Tasks.Count && numberOfAvaliableThreads > 0; i++)
{
if (isMergeSolutionSent(i, networkNode, messagePackage))
{
hasMessageBeenSent = true;
numberOfAvaliableThreads--;
}
}
//if divideProblemMessage hasn't been sent than send noOperationMessage
if (hasMessageBeenSent == false && Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message. 0 tasks to divide or 0 apropriate task managers", SmartConsole.DebugLevel.Basic);
}
}
/// <summary>
/// Solutions is sent by every node to give info
/// about ongoing computations or final solutions
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolutionsMessage(MessagePackage messagePackage)
{
SolutionsMessage message = (SolutionsMessage)messagePackage.Message;
InformBackup(message);
Task task = taskTracker.GetTask((int)message.Id);
//IT HAS TO BE CHANGED AFTER ADDING SUBTASK ID @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
if (message.Solutions[0].Type == SolutionsSolutionType.Final)
{
task.Solutions = message.Solutions;
task.Status = TaskStatus.Merged;
}
else
{
for (int i = 0; i < task.subTasks.Count; i++)
{
if (task.subTasks[i].Status == TaskStatus.Solving)
{
task.subTasks[i].Status = TaskStatus.Solved;
task.subTasks[i].Solutions = message.Solutions;
break;
}
}
}
if (Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message", SmartConsole.DebugLevel.Basic);
}
}
private void handleNoOperationMessage(MessagePackage package)
{
NoOperationMessage message = (NoOperationMessage)package.Message;
clientTracker.BackupServers = message.BackupCommunicationServers;
SmartConsole.PrintLine("Current Backup count: " + clientTracker.BackupServers.Length, SmartConsole.DebugLevel.Basic);
}
private void handleSolverRequestResponseMessage(SolveRequestResponseMessage solveRequestResponseMessage)
{
SmartConsole.PrintLine("Solve request respone message has been received", SmartConsole.DebugLevel.Advanced);
systemTracker.Node.Id = solveRequestResponseMessage.Id;
keepAliveTimer.Start(solveRequestResponseMessage.Id);
}
private void finalSolutionHelper(SolutionsMessage solutionsMessage)
{
//File.Create("Solution.txt");
FileStream fs1 = new FileStream("Solution.txt", FileMode.OpenOrCreate, FileAccess.Write);
StreamWriter writer = new StreamWriter(fs1);
byte[] data = solutionsMessage.Solutions[0].Data;
BinaryFormatter formatter = new BinaryFormatter();
Result finalResults = (Result)formatter.Deserialize(new MemoryStream(data));
SmartConsole.PrintHeader("TASK ID: " + solutionsMessage.Id + " RESULTS");
writer.WriteLine("TASK ID: " + solutionsMessage.Id + " RESULTS");
int[] finalRoute = finalResults.route;
float finalDistance = finalResults.length;
List <int> nextDays = finalResults.nextDay;
SmartConsole.PrintLine("Distance: " + finalDistance, SmartConsole.DebugLevel.Advanced);
writer.WriteLine("Distance: " + finalDistance);
int vehicleIndex = 0;
string msg = "";
for (int i = 0; i < finalRoute.Length; i++)
{
if (finalRoute[i] == -1)
{
msg += "\n";
}
else
{
msg += finalRoute[i] + ", ";
}
}
SmartConsole.PrintLine("Path: \n" + msg, SmartConsole.DebugLevel.Advanced);
writer.Write("Path: \n" + msg);
string nextDayStr = "";
for (int l = 0; l < nextDays.Count; l++)
{
nextDayStr += nextDays[l] + ", ";
}
if (!nextDayStr.Equals(""))
{
SmartConsole.PrintLine("Next Day: \n" + nextDayStr, SmartConsole.DebugLevel.Advanced);
writer.Write("\nNext Day: \n" + nextDayStr);
}
writer.Close();
fs1.Close();
Program.doWork = false;
}
/// <summary>
/// This function is running in another thread. It checks out if the function is timed out or not
/// </summary>
public void CheckNodesTimeOut()
{
while (TimeoutActive)
{
TimeSpan timeDifference;
DateTime currentTime = DateTime.Now;
int minSecMil = currentTime.Minute * 1000 * 60 + currentTime.Second * 1000 + currentTime.Millisecond;
for (int i = 0; i < backupServersList.Count; i++)
{
timeDifference = currentTime.Subtract(backupServersList[i].LastSeen);
if (timeDifference > new TimeSpan(0, 0, (int)backupServersList[i].Timeout * TIMEOUT_SCALLAR))
{
lock (lockObject)
{
SmartConsole.PrintLine("Backup server timeout'ed", SmartConsole.DebugLevel.Advanced);
backupServersList.RemoveAt(i);
RemoveBackupServer(i);
break;
}
}
}
for (int i = 0; i < compNodes.Count; i++)
{
timeDifference = currentTime.Subtract(compNodes[i].LastSeen);
if (timeDifference > new TimeSpan(0, 0, (int)compNodes[i].Timeout * TIMEOUT_SCALLAR))
{
lock (lockObject)
{
SmartConsole.PrintLine("Computational node timeout'ed", SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("CurrentTime: " + currentTime.ToString() + ", Last Seen: " + compNodes[i].LastSeen.ToString(), SmartConsole.DebugLevel.Advanced);
compNodes.RemoveAt(i);
break;
}
}
}
for (int i = 0; i < taskManagers.Count; i++)
{
timeDifference = currentTime.Subtract(taskManagers[i].LastSeen);
if (timeDifference > new TimeSpan(0, 0, (int)taskManagers[i].Timeout * TIMEOUT_SCALLAR))
{
lock (lockObject)
{
SmartConsole.PrintLine("Task manager timeout'ed", SmartConsole.DebugLevel.Advanced);
taskManagers.RemoveAt(i);
break;
}
}
}
Thread.Sleep(500);
}
}
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
/// <summary>
///
/// </summary>
/// <param name="runBoostData">
/// Whether the data should be boosted:
/// We increate amount of observations in order to
/// have a more reliable data set.
/// </param>
public void Compute(bool runBoostData = false)
{
SmartConsole.PrintHeader("PREDICTION STRENGTH");
if (runBoostData)
{
SmartConsole.PrintLine("Running Data Boost ... ", SmartConsole.DebugLevel.Advanced);
boostData();
}
psLogic();
SmartConsole.PrintLine("The best k = " + best_k, SmartConsole.DebugLevel.Advanced);
}
/// <summary>
/// In this function divideProblem message is sent if there is a new task and node is has proper taskSolver.
/// It returns true in case of completition of sending the message.
/// </summary>
/// <param name="numOfTask"></param>
/// <param name="node"></param>
/// <param name="messagePackage"></param>
/// <returns></returns>
private bool isMessageProblemDividedSent(int numOfTask, NetworkNode node, MessagePackage messagePackage)
{
if (taskTracker.Tasks[numOfTask].Status == Cluster.TaskStatus.New && taskTracker.Tasks[numOfTask].Type == node.SolvableProblems[0])
{
DivideProblemMessage divideProblemMessage = new DivideProblemMessage(taskTracker.Tasks[numOfTask].Type, (ulong)taskTracker.Tasks[numOfTask].ID, taskTracker.Tasks[numOfTask].BaseData, (ulong)4, (ulong)node.Id);
taskTracker.Tasks[numOfTask].Status = Cluster.TaskStatus.Dividing;
server.Send(messagePackage.Socket, divideProblemMessage);
SmartConsole.PrintLine("Divide problem message has been sent", SmartConsole.DebugLevel.Advanced);
return(true);
}
return(false);
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
/// <summary>
/// The logic of message processors
/// </summary>
private void startMessageProcessor()
{
SmartConsole.PrintLine("Message Processor Actived", SmartConsole.DebugLevel.Advanced);
while (Active)
{
// TODO busy waiting
if (messageQueue.Queue.Count != 0)
{
MessagePackage package = messageQueue.Queue.Dequeue();
messageHandler.HandleMessage(package);
}
}
SmartConsole.PrintLine("Message Processor Deactived", SmartConsole.DebugLevel.Advanced);
}
/// <summary>
/// function sending PartialProblems message
/// </summary>
/// <param name="numOfTask"></param>
/// <param name="partialList"></param>
/// <param name="messagePackage"></param>
/// <returns></returns>
private bool SendPartialProblemsMessage(int numOfTask, List <PartialProblem> partialList, MessagePackage messagePackage)
{
PartialProblem[] partialProblems = new PartialProblem[partialList.Count];
for (int j = 0; j < partialList.Count; j++)
{
partialProblems[j] = partialList[j];
}
SolvePartialProblemsMessage solvePartialProblemsMessage = new SolvePartialProblemsMessage(taskTracker.Tasks[numOfTask].Type, (ulong)taskTracker.Tasks[numOfTask].ID, taskTracker.Tasks[numOfTask].CommonData, (ulong)4, partialProblems);
server.Send(messagePackage.Socket, solvePartialProblemsMessage);
SmartConsole.PrintLine("Solve Partial Problems Message has been send (to Computational node). Number of subTasks." + partialList.Count, SmartConsole.DebugLevel.Advanced);
return(true);
}
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
/// <summary>
/// Computes the k-means
/// </summary>
/// <returns></returns>
public bool Compute()
{
SmartConsole.PrintHeader("K-MEANS");
if (data.Count < k)
{
SmartConsole.PrintLine("Cluster count is too big for data set, returning false", SmartConsole.DebugLevel.Advanced);
return(false);
}
SmartConsole.PrintLine("The configurations:", SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("k = " + k, SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("max_iter = " + max_iter, SmartConsole.DebugLevel.Advanced);
SmartConsole.PrintLine("distance_tolerance = " + distance_tolerance, SmartConsole.DebugLevel.Advanced);
kmeansLogic();
SmartConsole.PrintLine("K-means finished after " + current_iter + " iterations", SmartConsole.DebugLevel.Advanced);
return(true);
}
private void InformBackup(Message message)
{
s = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
int length = clientTracker.BackupServers.Length;
// If this is primary server and it has atleast one backup
if (Server.primaryMode && length > 0)
{
BackupCommunicationServer bserver = clientTracker.BackupServers[0];
IPAddress address = IPAddress.Parse(bserver.address);
int port = bserver.port;
s.Connect(address, port);
server.Send(s, message);
SmartConsole.PrintLine("Informed Backup Server: " + address.ToString() + ":" + port, SmartConsole.DebugLevel.Advanced);
}
// If this is one of the backups
else
{
// Find yourself, and inform next backup
for (int i = 0; i < length; i++)
{
BackupCommunicationServer bserver = clientTracker.BackupServers[i];
if (server.Address.ToString().Equals(bserver.address) && server.Port == bserver.port)
{
if (i + 1 < length)
{
BackupCommunicationServer bserverToSend = clientTracker.BackupServers[i + 1];
IPAddress address = IPAddress.Parse(bserverToSend.address);
int port = bserverToSend.port;
s.Connect(address, port);
server.Send(s, message);
SmartConsole.PrintLine("Informed Backup Server: " + address.ToString() + ":" + port, SmartConsole.DebugLevel.Advanced);
}
}
}
}
}
/// <summary>
/// Register new node - Primary server job
/// </summary>
private void registerNewNode(RegisterMessage message, Socket socket)
{
// Place holder, have to fetch info from the System.
ulong id = systemTracker.GetNextClientID();
uint timeout = (uint)systemTracker.Timeout;
SmartConsole.PrintLine("Adding new Node", SmartConsole.DebugLevel.Advanced);
NetworkNode node = new NetworkNode(message.Type, id, timeout, message.ParallelThreads, message.SolvableProblems,
clientTracker.BackupServers);
node.LastSeen = DateTime.Now;
// Backup Server
if (node.Type == RegisterType.CommunicationServer)
{
// update Node
IPAddress address = (socket.RemoteEndPoint as IPEndPoint).Address;
int port = (ushort)Server.PRIMARY_PORT;
node.Address = address;
// TODO hack
if (clientTracker.BackupServers.Length == 1)
{
port = (ushort)Server.PRIMARY_PORT2;
}
node.Port = (ushort)port;
}
// Add the node to system
clientTracker.AddNode(node);
RegisterResponseMessage response = new RegisterResponseMessage(id, timeout, clientTracker.BackupServers);
server.Send(socket, response);
RegisterMessage backUpmessage = new RegisterMessage(message.Type, message.ParallelThreads, message.SolvableProblems);
backUpmessage.Id = id;
InformBackup(backUpmessage);
}
private void handleSolutionsMessage(SolutionsMessage solutionsMessage)
{
bool isOnGoing = false;
if (solutionsMessage.Solutions[0].Type == SolutionsSolutionType.Ongoing)
{
SmartConsole.PrintLine("Ongoing computations. Waiting for full solution", SmartConsole.DebugLevel.Basic);
}
else
{
for (int i = 0; i < solutionsMessage.Solutions.Count(); i++)
{
if (solutionsMessage.Solutions[i].Type == SolutionsSolutionType.Ongoing)
{
isOnGoing = true;
break;
}
}
if (isOnGoing)
{
SmartConsole.PrintLine("Ongoing computations. Waiting for full solution", SmartConsole.DebugLevel.Basic);
}
else
{
DateTime nowTime = DateTime.Now;
int deltaSecs = nowTime.Second - Program.COMP_TIME.Second;
int deltaMs = nowTime.Millisecond - Program.COMP_TIME.Millisecond;
string timeStr = "Seconds = " + deltaSecs + ", Milliseconds = " + deltaMs;
SmartConsole.PrintLine("Complete solution has been received", SmartConsole.DebugLevel.Advanced);
finalSolutionHelper(solutionsMessage);
SmartConsole.PrintLine("Computation Time: \n" + timeStr, SmartConsole.DebugLevel.Advanced);
// TODO print solution
keepAliveTimer.Stop();
}
}
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
private void keepAlive(Object source, ElapsedEventArgs e)
{
SmartConsole.PrintLine("Sending Status message", SmartConsole.DebugLevel.Basic);
try
{
Communicate(node.ToStatusMessage());
}
catch (SocketException excep)
{
if (clientTracker.BackupServers.Length == 0)
{
SmartConsole.PrintLine("No other backup server avaiable", SmartConsole.DebugLevel.Advanced);
return;
}
BackupCommunicationServer bserver = clientTracker.BackupServers[0];
// If it is next backup server, switch to primary and remove it from the list
if (server.Address.ToString().Equals(bserver.address) && server.Port == bserver.port)
{
// TODO Switch only if it is next back up in the list, and decreament the list it self
SmartConsole.PrintLine("Switching to primary...", SmartConsole.DebugLevel.Advanced);
// stop the timer
this.Stop();
clientTracker.RemoveBackupServer(0);
lock (backupBlockade)
{
Monitor.Pulse(backupBlockade);
}
return;
}
// connect to next backup server.
else
{
client.Address = IPAddress.Parse(bserver.address);
client.Port = bserver.port;
}
}
}
/// <summary>
/// Status is sent by everyone as Keep-alive message
/// </summary>
/// <param name="messagePackage"></param>
private void handleStatusMessage(MessagePackage messagePackage)
{
StatusMessage message = (StatusMessage)messagePackage.Message;
// check what node
lock (clientTracker.lockObject)
{
NetworkNode networkNode = clientTracker.GetNodeByID(message.Id);
networkNode.LastSeen = DateTime.Now;
UpdateThreadsStatus(networkNode, message);
// inform backup
if (networkNode.Type != RegisterType.CommunicationServer)
{
InformBackup(message);
}
//if status message was send by TaskManager than check if there are any tasks to divide or merge
if (networkNode.Type == RegisterType.TaskManager)
{
//Response to TaskManager statusMessage
ReactToTaskManagerStatusMessage(networkNode, messagePackage);
}
//is staty message was send by computational node than check if there are any partial problems to calculate.
else if (networkNode.Type == RegisterType.ComputationalNode)
{
ReactToComputationalNodeStatusMessage(networkNode, messagePackage);
}
else
{
if (Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message", SmartConsole.DebugLevel.Basic);
}
}
}
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
/*******************************************************************/
/************************* PUBLIC METHODS **************************/
/*******************************************************************/
public void InitiatePrimary(IPAddress address, int port)
{
SmartConsole.PrintHeader("Starting primary server");
SmartConsole.PrintLine("Address: " + address.ToString() + ":" + port, SmartConsole.DebugLevel.Advanced);
// Create overall system tracker
SystemTracker systemTracker = new SystemTracker();
// Create list of all clients
ClientTracker clientTracker = new ClientTracker();
// Start measuring timeout
clientTracker.StartTimeout();
// Task Tracker
TaskTracker taskTracker = new TaskTracker();
// Start network connection
NetworkServer server = new NetworkServer(address, port);
server.Open();
// Create messageHandler
MessageHandler messageHandler = new MessageHandler(systemTracker, clientTracker, taskTracker, server);
// Start message queue
MessageQueue messageQueue = new MessageQueue(server);
messageQueue.Start();
// Start Message processor
CommunicationServer.MessageCommunication.MessageProcessor messageProcessor = new CommunicationServer.MessageCommunication.MessageProcessor(messageQueue, messageHandler);
messageProcessor.Start();
Thread.Sleep(100);
// Start console manager
ConsoleManager consoleManager = new ConsoleManager(server);
consoleManager.Start();
}
/// <summary>
/// this function is a response to Computational Node status message
/// </summary>
/// <param name="networkNode"></param>
/// <param name="messagePackage"></param>
private void ReactToComputationalNodeStatusMessage(NetworkNode networkNode, MessagePackage messagePackage)
{
bool messageCheck = false;
for (int i = 0; i < taskTracker.Tasks.Count; i++)
{
if (taskTracker.Tasks[i].Status == Cluster.TaskStatus.Divided && taskTracker.Tasks[i].Type == networkNode.SolvableProblems[0])
{
// REMEBER TO CHECK IF THERE IS A AVALIABLE THREAD ******************************************************************************************************
// check number of avaliable threads
int avaliableThreads = AvaliableThreadsCount(networkNode);
List <PartialProblem> partialList = new List <PartialProblem>();
for (int j = 0; j < taskTracker.Tasks[i].subTasks.Count && avaliableThreads > 0; j++)
{
if (taskTracker.Tasks[i].subTasks[j].Status == Cluster.TaskStatus.New)
{
avaliableThreads--;
partialList.Add(new PartialProblem((ulong)taskTracker.Tasks[i].ID, taskTracker.Tasks[i].subTasks[j].BaseData, (ulong)(0)));
taskTracker.Tasks[i].subTasks[j].Status = Cluster.TaskStatus.Solving;
// temporary solution @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
}
}
if (partialList.Count > 0)
{
messageCheck = SendPartialProblemsMessage(i, partialList, messagePackage);
}
if (messageCheck)
{
break;
}
}
}
if (messageCheck == false && Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message. 0 subTasks to divide or 0 apropriate computationalNodes", SmartConsole.DebugLevel.Basic);
}
}
/// <summary>
/// in this function solution message with solved partial solution is sent (it checks if all subtasks of task are solved.
/// It returns true in case of completition of sending the message.
/// </summary>
/// <param name="numberOfTask"></param>
/// <param name="node"></param>
/// <param name="messagePackage"></param>
/// <returns></returns>
private bool isMergeSolutionSent(int numberOfTask, NetworkNode node, MessagePackage messagePackage)
{
if (taskTracker.Tasks[numberOfTask].Status != Cluster.TaskStatus.Merging && taskTracker.Tasks[numberOfTask].Status != Cluster.TaskStatus.Merged && taskTracker.Tasks[numberOfTask].subTasks.Count != 0)
{
for (int j = 0; j < taskTracker.Tasks[numberOfTask].subTasks.Count; j++)
{
if (taskTracker.Tasks[numberOfTask].subTasks[j].Status != Cluster.TaskStatus.Solved)
{
return(false);
}
}
}
else
{
return(false);
}
if (taskTracker.Tasks[numberOfTask].Type == node.SolvableProblems[0])
{
taskTracker.Tasks[numberOfTask].Status = Cluster.TaskStatus.Merging;
Solution[] solutions = new Solution[taskTracker.Tasks[numberOfTask].subTasks.Count];
for (int k = 0; k < solutions.Count(); k++)
{
solutions[k] = new Solution(SolutionsSolutionType.Final);
}
for (int j = 0; j < taskTracker.Tasks[numberOfTask].subTasks.Count; j++)
{
solutions[j].Data = taskTracker.Tasks[numberOfTask].subTasks[j].Solutions[0].Data;
}
SolutionsMessage solutionMessage = new SolutionsMessage(taskTracker.Tasks[numberOfTask].Type, (ulong)taskTracker.Tasks[numberOfTask].ID, taskTracker.Tasks[numberOfTask].CommonData, solutions);
server.Send(messagePackage.Socket, solutionMessage);
SmartConsole.PrintLine("Solution Message has been sent to Task Manager", SmartConsole.DebugLevel.Advanced);
return(true);
}
return(false);
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
/// <summary>
/// Runs the algorithm for configuration given by constructor
/// </summary>
private void psLogic()
{
SmartConsole.PrintHeader("PREDICTION STRENGTH");
// 1) get learning and testing set
//
splitTrainingData();
// 2) compute ps for each k and find the best_k
best_k = 1;
double max_strength = 0;
strengths = new double[max_k];
for (int k = start_k; k <= max_k; k++)
{
double strength = psValue(learningSet, testingSet, k);
strengths[k - start_k] = strength;
if (k == start_k)
{
max_strength = strength;
best_k = k;
}
else if (STRENGTH_TOL < strength)
{
max_strength = strength;
best_k = k;
}
SmartConsole.PrintLine("ps(" + k + ") = " + strength, SmartConsole.DebugLevel.Advanced);
}
SmartConsole.PrintHeader("PREDICTION STRENGTH FINISHED: ");
for (int k = start_k; k <= max_k; k++)
{
SmartConsole.PrintLine("ps(" + k + ") = " + strengths[k - start_k], SmartConsole.DebugLevel.Advanced);
}
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
private void keepAliveSolution(Object source, ElapsedEventArgs e)
{
SmartConsole.PrintLine("Sending SolutionRequestMessage", SmartConsole.DebugLevel.Basic);
try
{
messageProcessor.Communicate(solutionRequestMessage);
}
catch (SocketException excep)
{
SmartConsole.PrintLine("Lost connection with primary server, reconnecting to next backup...", SmartConsole.DebugLevel.Advanced);
if (systemTracker.Node.BackupServers.Length == 0)
{
SmartConsole.PrintLine("No other backup server avaiable", SmartConsole.DebugLevel.Advanced);
return;
}
BackupCommunicationServer bserver = systemTracker.Node.BackupServers[0];
// connect to next backup server.
messageProcessor.client.Address = IPAddress.Parse(bserver.address);
messageProcessor.client.Port = bserver.port;
}
}
/// <summary>
/// SolvePartialProblem is sent by TM
/// </summary>
/// <param name="messagePackage"></param>
private void handleSolvePartialProblemsMessage(MessagePackage messagePackage)
{
/* add partial tasks to subTask list in a task */
SolvePartialProblemsMessage message = (SolvePartialProblemsMessage)messagePackage.Message;
InformBackup(message);
Task task = taskTracker.GetTask((int)message.Id);
task.Status = TaskStatus.Divided;
for (int i = 0; i < message.PartialProblems.Count(); i++)
{
Task subTask = new Task((int)message.Id, message.ProblemType, message.PartialProblems[i].Data);
subTask.Status = TaskStatus.New;
task.AddSubTask(subTask);
}
/***********************************************/
if (Server.primaryMode)
{
NoOperationMessage response = new NoOperationMessage(clientTracker.BackupServers);
server.Send(messagePackage.Socket, response);
SmartConsole.PrintLine("Sent a NoOperation Message", SmartConsole.DebugLevel.Basic);
}
}
/*******************************************************************/
/************************ PRIVATE METHODS **************************/
/*******************************************************************/
private void keepAlive(Object source, ElapsedEventArgs e)
{
SmartConsole.PrintLine("Sending Solution Request message", SmartConsole.DebugLevel.Basic);
messageProcessor.Communicate(solutionRequestMessage);
}
static void Main(string[] args)
{
/************ Create node object ************/
RegisterType type = RegisterType.TaskManager;
byte parallelThreads = 5;
string[] problems = { "DVRP" };
NetworkNode node = new NetworkNode(type, parallelThreads, problems);
//NetworkNode node = new NetworkNode();
/************ Setup connection ************/
string inputLine = "";
foreach (string arg in args)
{
inputLine += arg + " ";
}
InputParser inputParser = new InputParser(inputLine);
inputParser.ParseInput();
IPAddress address = inputParser.Address;
int port = inputParser.Port;
SmartConsole.PrintLine("I'm a " + node.Type, SmartConsole.DebugLevel.Advanced);
NetworkClient client = new NetworkClient(address, port);
/************ Setup Logic modules ************/
// system tracker
SystemTracker systemTracker = new SystemTracker(node);
MessageHandler messageHandler = new MessageHandler(systemTracker, client);
MessageProcessor messageProcessor = new MessageProcessor(messageHandler, client, node);
node.MessageProcessor = messageProcessor;
/************ Init all threads ************/
for (int i = 0; i < parallelThreads; i++)
{
node.TaskThreads[i] = new TaskThread(i, problems[0], messageProcessor, (int)node.Id);
}
/************ Register ************/
client.Connect();
SmartConsole.PrintLine("Sending Register message", SmartConsole.DebugLevel.Advanced);
messageProcessor.Communicate(node.ToRegisterMessage());
KeepAliveTimer keepAliveTimer = new KeepAliveTimer(messageProcessor, systemTracker);
/************ Start Logic modules ************/
keepAliveTimer.Start();
Object mutex = new Object();
// TODO Thread pool waiting
lock (mutex)
{
Monitor.Wait(mutex);
}
}
static void Main(string[] args)
{
RegisterType type = RegisterType.ComputationalClient;
byte parallelThreads = 5;
string[] problems = { "DVRP" };
SolveRequestMessage solveRequestMessage = new SolveRequestMessage();
string inputLine = "";
foreach (string arg in args)
{
inputLine += arg + " ";
}
InputParser inputParser = new InputParser(inputLine);
inputParser.ParseInput();
IPAddress address = inputParser.Address;
int port = inputParser.Port;
NetworkNode node = new NetworkNode(type, parallelThreads, problems)
{
Timeout = CLIENT_REQUEST_FREQUENCY
};
SmartConsole.PrintLine("ComputationalClient starting work", SmartConsole.DebugLevel.Advanced);
NetworkClient client = new NetworkClient(address, port);
for (; ;)
{
/*************** Register *****************/
doWork = true;
SmartConsole.PrintLine("Type in a file path", SmartConsole.DebugLevel.Advanced);
String filePath = Console.ReadLine();
solveRequestMessage = loadDataFromDisc(filePath);
/****** setup logic modules *****************/
SystemTracker systemTracker = new SystemTracker(node);
MessageHandler messageHandler = new MessageHandler(systemTracker, client);
MessageProcessor messageProcessor = new MessageProcessor(messageHandler, client, node);
KeepAliveTimer keepAliveTimer = new KeepAliveTimer(messageProcessor, systemTracker);
messageHandler.keepAliveTimer = keepAliveTimer;
node.MessageProcessor = messageProcessor;
/************ send solve request *****************/
client.Connect();
messageProcessor.Communicate(solveRequestMessage);
COMP_TIME = DateTime.Now;
while (doWork)
{
Thread.Sleep(1000);
}
/*Object mutex = new Object();
*
* lock (mutex)
* {
* Monitor.Wait(mutex);
* }*/
}
}