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