private void Dispatch(MessageDispatch dispatch, List <IMessageHandlerInvoker> invokers)
{
switch (_status)
{
case Status.Stopped:
throw new InvalidOperationException("MessageDispatcher is stopped");
case Status.Stopping:
if (dispatch.IsLocal)
{
break;
}
throw new InvalidOperationException("MessageDispatcher is stopping");
}
if (invokers.Count == 0)
{
dispatch.SetIgnored();
return;
}
dispatch.SetHandlerCount(invokers.Count);
foreach (var invoker in invokers)
{
if (invoker.ShouldHandle(dispatch.Message))
{
Dispatch(dispatch, invoker);
}
}
}
public void RunOrEnqueue(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
if (dispatch.ShouldRunSynchronously || IsCurrentDispatchQueue)
{
RunSingle(dispatch, invoker);
}
else
{
Enqueue(dispatch, invoker);
}
}
private void RunSingle(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
if (!_isRunning)
{
return;
}
var batch = new Batch(1);
batch.Add(new Entry(dispatch, invoker));
RunBatch(batch);
}
private static void DispatchSync(PipeInvocation invocation, MessageDispatch dispatch)
{
Exception exception = null;
try
{
invocation.Run();
}
catch (Exception ex)
{
exception = ex;
}
dispatch.SetHandled(invocation.Invoker, exception);
}
private void Dispatch(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
var context = dispatch.Context.WithDispatchQueueName(invoker.DispatchQueueName);
var invocation = _pipeManager.BuildPipeInvocation(invoker, dispatch.Message, context);
var isInSameDispatchQueue = ShouldRunInCurrentDispatchQueue(invoker.DispatchQueueName, dispatch.Context.DispatchQueueName);
if (invoker.CanInvokeSynchronously && (dispatch.ShouldRunSynchronously || isInSameDispatchQueue))
{
DispatchSync(invocation, dispatch);
}
else
{
DispatchAsync(invocation, dispatch);
}
}
private void Dispatch(MessageDispatch dispatch, List <IMessageHandlerInvoker> invokers)
{
if (!_isRunning)
{
throw new InvalidOperationException("MessageDispatcher is stopped");
}
if (invokers.Count == 0)
{
dispatch.SetIgnored();
return;
}
dispatch.SetHandlerCount(invokers.Count);
foreach (var invoker in invokers)
{
Dispatch(dispatch, invoker);
}
}
private void DispatchAsync(PipeInvocation invocation, MessageDispatch dispatch)
{
var invocationTask = invocation.RunAsync();
invocationTask.ContinueWith(task => dispatch.SetHandled(invocation.Invoker, GetException(task)), TaskContinuationOptions.ExecuteSynchronously);
if (invocationTask.Status != TaskStatus.Created)
{
return;
}
if (invocation.Invoker.ShouldCreateStartedTasks)
{
var exception = new InvalidProgramException($"{invocation.Invoker.MessageHandlerType.Name}.Handle({invocation.Invoker.MessageType.Name}) did not start the returned task");
dispatch.SetHandled(invocation.Invoker, exception);
return;
}
var taskScheduler = GetTaskScheduler(invocation.Invoker.DispatchQueueName);
invocationTask.Start(taskScheduler);
}
public void Dispatch(MessageDispatch dispatch)
{
if (!_isRunning)
{
throw new InvalidOperationException("MessageDispatcher is stopped");
}
var invokers = _invokers.GetValueOrDefault(dispatch.Message.TypeId(), _emptyInvokers)
.Where(dispatch.ShouldInvoke)
.ToList();
if (invokers.Count == 0)
{
dispatch.SetIgnored();
return;
}
dispatch.SetHandlerCount(invokers.Count);
foreach (var invoker in invokers)
{
Dispatch(dispatch, invoker);
}
}
private void Dispatch(MessageDispatch dispatch, List<IMessageHandlerInvoker> invokers)
{
if (!_isRunning)
throw new InvalidOperationException("MessageDispatcher is stopped");
if (invokers.Count == 0)
{
dispatch.SetIgnored();
return;
}
dispatch.SetHandlerCount(invokers.Count);
foreach (var invoker in invokers)
{
Dispatch(dispatch, invoker);
}
}
public void Dispatch(MessageDispatch dispatch, Func<Type, bool> handlerFilter)
{
var invokers = _invokers.GetValueOrDefault(dispatch.Message.TypeId(), _emptyInvokers).Where(x => handlerFilter(x.MessageHandlerType)).ToList();
Dispatch(dispatch, invokers);
}
public void Dispatch(MessageDispatch dispatch)
{
var invokers = _invokers.GetValueOrDefault(dispatch.Message.TypeId(), _emptyInvokers);
Dispatch(dispatch, invokers);
}
private void Dispatch(IMessage message, MessageContext context, MessageDispatcher dispatcher = null)
{
_dispatchResultRef = null;
var dispatch = new MessageDispatch(context, message, (x, r) => _dispatchResultRef = new DispatchResultRef(r));
(dispatcher ?? _messageDispatcher).Dispatch(dispatch);
}
public void should_get_reply_code()
{
_messageDispatcher.LoadMessageHandlerInvokers();
var context = MessageContext.CreateTest("u.name");
var dispatch = new MessageDispatch(context.WithDispatchQueueName(DispatchQueueNameScanner.DefaultQueueName), new ReplyCommand(), (x, r) => { });
_messageDispatcher.Dispatch(dispatch);
context.ReplyCode.ShouldEqual(ReplyCommand.ReplyCode);
}
public void should_filter_invoker()
{
_messageDispatcher.LoadMessageHandlerInvokers();
var asyncHandler = new AsyncCommandHandler();
_containerMock.Setup(x => x.GetInstance(typeof(AsyncCommandHandler))).Returns(asyncHandler);
var syncHandler = new SyncCommandHandler();
_containerMock.Setup(x => x.GetInstance(typeof(SyncCommandHandler))).Returns(syncHandler);
var context = MessageContext.CreateTest("u.name");
var command = new DispatchCommand();
var dispatched = new ManualResetEvent(false);
var dispatch = new MessageDispatch(context, command, (x, r) => dispatched.Set());
_messageDispatcher.Dispatch(dispatch, x => x == typeof(AsyncCommandHandler));
dispatched.WaitOne(500.Milliseconds()).ShouldBeTrue();
syncHandler.Called.ShouldBeFalse();
asyncHandler.CalledSignal.IsSet.ShouldBeTrue();
}
public void Dispatch(MessageDispatch dispatch)
{
var invokers = _invokers.GetValueOrDefault(dispatch.Message.TypeId(), _emptyInvokers);
Dispatch(dispatch, invokers);
}
public void Dispatch(MessageDispatch dispatch, Func <Type, bool> handlerFilter)
{
var invokers = _invokers.GetValueOrDefault(dispatch.Message.TypeId(), _emptyInvokers).Where(x => handlerFilter(x.MessageHandlerType)).ToList();
Dispatch(dispatch, invokers);
}
private void Dispatch(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
var dispatchQueue = _dispatchQueues.GetOrAdd(invoker.DispatchQueueName, CreateAndStartDispatchQueue);
dispatchQueue.RunOrEnqueue(dispatch, invoker);
}
private void Dispatch(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
var dispatchQueue = _dispatchQueues[invoker.DispatchQueueName];
dispatchQueue.RunOrEnqueue(dispatch, invoker);
}
private void Dispatch(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
var context = dispatch.Context.WithDispatchQueueName(invoker.DispatchQueueName);
var invocation = _pipeManager.BuildPipeInvocation(invoker, dispatch.Message, context);
var isInSameDispatchQueue = ShouldRunInCurrentDispatchQueue(invoker.DispatchQueueName, dispatch.Context.DispatchQueueName);
if (invoker.CanInvokeSynchronously && (dispatch.ShouldRunSynchronously || isInSameDispatchQueue))
DispatchSync(invocation, dispatch);
else
DispatchAsync(invocation, dispatch);
}
public Entry(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
Dispatch = dispatch;
Invoker = invoker;
Action = null;
}
private void DispatchAsync(PipeInvocation invocation, MessageDispatch dispatch)
{
var invocationTask = invocation.RunAsync();
invocationTask.ContinueWith(task => dispatch.SetHandled(invocation.Invoker, GetException(task)), TaskContinuationOptions.ExecuteSynchronously);
if (invocationTask.Status != TaskStatus.Created)
return;
if (invocation.Invoker.ShouldCreateStartedTasks)
{
var exception = new InvalidProgramException(string.Format("{0}.Handle({1}) did not start the returned task", invocation.Invoker.MessageHandlerType.Name, invocation.Invoker.MessageType.Name));
dispatch.SetHandled(invocation.Invoker, exception);
return;
}
var taskScheduler = GetTaskScheduler(invocation.Invoker.DispatchQueueName);
invocationTask.Start(taskScheduler);
}
public void Enqueue(MessageDispatch dispatch, IMessageHandlerInvoker invoker)
{
_queue.Add(new Entry(dispatch, invoker));
}
private static void DispatchSync(PipeInvocation invocation, MessageDispatch dispatch)
{
Exception exception = null;
try
{
invocation.Run();
}
catch (Exception ex)
{
exception = ex;
}
dispatch.SetHandled(invocation.Invoker, exception);
}