public void RegistrationMessageIsAcceptedAndItsCallbackInvoked()
{
var waitHandle = new AutoResetEvent(false);
var callbackCalled = false;
var msg = new RegisterMessage
{
ComponentType = ComponentType.TaskManager,
ParallelThreads = 5,
SolvableProblems = new List <string> {
"dvrp"
}
};
var rawMsg = _marshaller.Marshall(new Message[] { msg });
ProcessedDataCallback c = response =>
{
callbackCalled = true;
waitHandle.Set();
};
_processor.StartProcessing();
_processor.EnqueueDataToProcess(rawMsg, null, c);
waitHandle.WaitOne(5000);
_processor.StopProcessing();
Assert.IsTrue(callbackCalled);
}
public void RegistrationMessageIsAcceptedAndRegisterResponseMessageIsPassedBack()
{
var waitHandle = new AutoResetEvent(false);
var msg = new RegisterMessage
{
ParallelThreads = 5,
SolvableProblems = new List <string> {
"dvrp"
},
ComponentType = ComponentType.ComputationalNode
};
var rawMsg = _marshaller.Marshall(new Message[] { msg });
Message outputMessage = null;
ProcessedDataCallback c = response =>
{
outputMessage = _marshaller.Unmarshall(response)[0];
waitHandle.Set();
};
_processor.StartProcessing();
_processor.EnqueueDataToProcess(rawMsg, null, c);
waitHandle.WaitOne(10000);
_processor.StopProcessing();
Assert.IsInstanceOfType(outputMessage, typeof(RegisterResponseMessage));
}
public void StatusMessageFromARegisteredComponentReturnsNoOperationIfThereAreNoTasksPending()
{
var waitHandle = new AutoResetEvent(false);
var msg = new StatusMessage
{
ComponentId = 5,
Threads = new List <ThreadStatus> {
new ThreadStatus {
ProblemType = "dvrp"
}
}
};
var rawMsg = _marshaller.Marshall(new Message[] { msg });
Message outputMessage = null;
ProcessedDataCallback c = response =>
{
outputMessage = _marshaller.Unmarshall(response)[0];
waitHandle.Set();
};
_processor.StartProcessing();
_processor.EnqueueDataToProcess(rawMsg, null, c);
waitHandle.WaitOne(5000);
_processor.StopProcessing();
Assert.IsInstanceOfType(outputMessage, typeof(ErrorMessage));
}
public void SolveRequestMessageIsAcceptedAndSolveRequestResponseMessageIsPassedBack()
{
var waitHandle = new AutoResetEvent(false);
var msg = new SolveRequestMessage
{
ProblemData = new byte[0],
ProblemType = "dvrp"
};
var rawMsg = _marshaller.Marshall(new Message[] { msg });
Message outputMessage = null;
ProcessedDataCallback c = response =>
{
outputMessage = _marshaller.Unmarshall(response)[0];
waitHandle.Set();
};
_processor.StartProcessing();
_processor.EnqueueDataToProcess(rawMsg, null, c);
waitHandle.WaitOne(5000);
_processor.StopProcessing();
Assert.IsInstanceOfType(outputMessage, typeof(SolveRequestResponseMessage));
}
/// <summary>
/// Enqueue data into the queue.
/// </summary>
/// <param name="data">Byte data sent by the client.</param>
/// <param name="metadata">Information about the data and connection.</param>
/// <param name="callback">Callback that finalizes the connection.</param>
public void Enqueue(byte[] data, Metadata metadata, ProcessedDataCallback callback)
{
var item = new RawDataQueueItem
{
Data = data,
Metadata = metadata,
Callback = callback
};
Enqueue(item);
}
/// <summary>
/// Dequeue item from the queue if possible.
/// </summary>
/// <param name="data">Byte data sent by the client.</param>
/// <param name="metadata">Information about the data and connection.</param>
/// <param name="callback">Callback that finalizes the connection.</param>
/// <returns>True if managed to dequeue.</returns>
public bool TryDequeue(out byte[] data, out Metadata metadata, out ProcessedDataCallback callback)
{
RawDataQueueItem item;
if (TryDequeue(out item))
{
data = item.Data;
metadata = item.Metadata;
callback = item.Callback;
return(true);
}
data = null;
metadata = null;
callback = null;
return(false);
}
/// <summary>
/// Enqueues new raw message to process.
/// </summary>
/// <param name="data">Raw message data.</param>
/// <param name="metadata">Information about received data.</param>
/// <param name="callback">Callback invoked after processing containing marshalled response messages.</param>
public void EnqueueDataToProcess(byte[] data, Metadata metadata, ProcessedDataCallback callback)
{
_inputDataQueue.Enqueue(data, metadata, callback);
_processingLock.Set();
}
public void EnqueueDataToProcess(byte[] data, Metadata metadata, ProcessedDataCallback callback)
{
Array.Reverse(data);
new Task(() => { callback(data); }).Start();
}
public void EnqueueDataToProcess(byte[] data, Metadata metadata, ProcessedDataCallback callback)
{
Array.Reverse(data);
new Task(() => { callback(data); }).Start();
}
/// <summary>
/// Enqueues new raw message to process.
/// </summary>
/// <param name="data">Raw message data.</param>
/// <param name="metadata">Information about received data.</param>
/// <param name="callback">Callback invoked after processing containing marshalled response messages.</param>
public void EnqueueDataToProcess(byte[] data, Metadata metadata, ProcessedDataCallback callback)
{
_inputDataQueue.Enqueue(data, metadata, callback);
_processingLock.Set();
}
