void worker_OnWorkerNotifyEvent(BasicWorker worker, object data)
{
if (OnServerNodeNotifyEvent != null) OnServerNodeNotifyEvent(worker, data);
}
/// <summary>
/// Adds a worker to the Node, the ServerNode will add this worker to the scan.
/// </summary>
/// <param name="worker">Any type derived from BasicWorker.</param>
public void AddWorker(BasicWorker worker)
{
qNodeOpeations.Enqueue(new NodeOperation(NodeOperationEnum.AddWorker, worker));
}
protected void RaiseWorkerNotification(BasicWorker worker, object data)
{
if (OnWorkerNotifyEvent != null) OnWorkerNotifyEvent(worker, data);
}
void ServerNode_OnWorkerLatencyChanged(BasicWorker worker, TimeSpan oldLatency)
{
//if the latnecy of the worker have changed send the worker to node reassignment.
qNodeOpeations.Enqueue(new NodeOperation(NodeOperationEnum.RemoveWorker, worker));
if (OnServerNodeWorkerLatencyChanged != null) OnServerNodeWorkerLatencyChanged(worker, oldLatency);
}
protected void RaiseWorkerLatencyChanged(BasicWorker worker, TimeSpan oldLatency)
{
if (OnWorkerLatencyChanged != null) OnWorkerLatencyChanged(worker, oldLatency);
}
void NewNode_OnServerNodeWorkerLatencyChanged(BasicWorker worker, TimeSpan oldLatency)
{
AddWorker(worker);
if (OnServerNotifyEvent != null) OnServerNotifyEvent.BeginInvoke(worker,
new WorkerLatencyInformationChanged(oldLatency), null, null);
}
void NewNode_OnServerNodeNotifyEvent(BasicWorker worker, object data)
{
if (worker == null) //this means the node is reporting, node id is in the data object.
{
lock (oServerNodesLocker)
{
for(int iScan=0;iScan<serverNodes.Count;iScan++)
{
if(((Guid)data).CompareTo(serverNodes[iScan].NodeId)==0)
{
if (serverNodes[iScan].Idle)
{
serverNodes[iScan].Stop();
serverNodes[iScan].OnServerNodeNotifyEvent -=
new ServerNode.DelegateServerNodeNotification(
NewNode_OnServerNodeNotifyEvent);
serverNodes[iScan].OnServerNodeWorkerLatencyChanged -=
new ServerNode.DelegateServerNodeWorkerLatencyChanged(
NewNode_OnServerNodeWorkerLatencyChanged);
serverNodes.RemoveAt(iScan);
}
break;
}
}
}
}
else if (OnServerNotifyEvent != null) OnServerNotifyEvent.BeginInvoke(worker, data, null, null);
}
/// <summary>
/// Adds a worker to a node from the nodeslist or open a new node for the worker.
/// The action taken depends on the required latnecy of the worker and the current nodes latencies.
/// </summary>
/// <param name="worker">The worker to add.</param>
private void AddWorker(BasicWorker worker)
{
int iBestNodeIndex = 0;
lock (oServerNodesLocker)
{
TimeSpan lowestNodeLatency = TimeSpan.MaxValue;
for (int iScan = 0; iScan < serverNodes.Count; iScan++)
if (serverNodes[iScan].Latency < lowestNodeLatency)
{
iBestNodeIndex = iScan;
lowestNodeLatency = serverNodes[iBestNodeIndex].Latency;
}
if (lowestNodeLatency > worker.RequiredLatency)
{ //Create a new node.
ServerNode NewNode = new ServerNode();
NewNode.OnServerNodeNotifyEvent += //Hook to the node events.
new ServerNode.DelegateServerNodeNotification(
NewNode_OnServerNodeNotifyEvent);
NewNode.OnServerNodeWorkerLatencyChanged +=
new ServerNode.DelegateServerNodeWorkerLatencyChanged(
NewNode_OnServerNodeWorkerLatencyChanged);
serverNodes.Add(NewNode); //Add the new node to the list.
iBestNodeIndex = serverNodes.Count - 1;
if (bServerStarted && !bServerPaused) NewNode.Start();
}
serverNodes[iBestNodeIndex].AddWorker(worker);
}
}
/// <summary>
/// The listeners, accepters and connecters events are routed to this method.
/// </summary>
/// <param name="worker">The worker that raised an event.</param>
/// <param name="data">relvant event data</param>
void BasicServers_OnServerNotifyEvent(BasicWorker worker, object data)
{
NetworkServerClientWorker.NetworkClientNotification incommingEvent = null;
if (data.GetType() == typeof(NetworkServerClientWorker.NetworkClientNotification))
{
incommingEvent = (NetworkServerClientWorker.NetworkClientNotification)data;
switch (incommingEvent.EventType)
{
case NetworkClientBase.ClientEventTypeEnum.None:
break;
case NetworkClientBase.ClientEventTypeEnum.Connected:
break;
case NetworkClientBase.ClientEventTypeEnum.Accepted:
NetworkServerClientAccepter accepter =
(NetworkServerClientAccepter)incommingEvent.EventData;
accepter.RequiredLatency = newAcceptersLatency;
accepters.Workers.Add(accepter);
break;
case NetworkClientBase.ClientEventTypeEnum.MessageSent:
break;
case NetworkClientBase.ClientEventTypeEnum.RawDataRecieved:
break;
case NetworkClientBase.ClientEventTypeEnum.MessageRecieved:
break;
case NetworkClientBase.ClientEventTypeEnum.Disconnected:
switch (worker.GetType().Name)
{
case "NetworkServerClientListener": //Controlled by user of this class.
break;
case "NetworkServerClientAccepter": //This class add it so it should remove it.
accepters.Workers.Remove(worker);
break;
case "NetworkServerClientConnecter"://Controlled by user of this class.
break;
}
break;
case NetworkClientBase.ClientEventTypeEnum.Error:
break;
}
}
OnServerNotify((NetworkServerClientWorker)worker, incommingEvent);
}