public void Setup()
{
_busMock = new Mock <IBus>();
_context = MessageContext.CreateTest("u.name");
_bus = new MessageContextAwareBus(_busMock.Object, _context);
}
private static void RunLocalDispatch()
{
var bus = new BusFactory()
.WithHandlers(typeof(BusPerformanceTests.PerfHandler))
.CreateAndStartInMemoryBus();
Console.WriteLine("Press any key to start");
Console.ReadKey();
var running = true;
var runTask = Task.Run(() =>
{
using (DispatchQueue.SetCurrentDispatchQueueName(DispatchQueueNameScanner.DefaultQueueName))
using (MessageContext.SetCurrent(MessageContext.CreateTest()))
{
while (running)
{
bus.Send(new BusPerformanceTests.PerfCommand(42));
}
}
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
running = false;
runTask.Wait();
bus.Stop();
}
public void Setup()
{
_invoker = new TestMessageHandlerInvoker <FakeCommand>();
_message = new FakeCommand(123);
_messageContext = MessageContext.CreateTest("u.name");
_pipes = new List <IPipe>();
_invocation = new PipeInvocation(_invoker, _message, _messageContext, _pipes);
_handlerInvocation = _invocation;
}
private Task <DispatchResult> Dispatch(IMessage message)
{
var taskCompletionSource = new TaskCompletionSource <DispatchResult>();
var dispatch = new MessageDispatch(MessageContext.CreateTest("u.name"), message, (x, r) => taskCompletionSource.SetResult(r));
_messageDispatcher.Dispatch(dispatch);
return(taskCompletionSource.Task);
}
public void Setup()
{
_invoker = new TestAsyncMessageHandlerInvoker <ExecutableEvent>();
_message = new ExecutableEvent();
_messageContext = MessageContext.CreateTest();
_pipes = new List <IPipe>();
_invocation = new PipeInvocation(_invoker, new List <IMessage> {
_message
}, _messageContext, _pipes);
}
public void should_throw_if_a_blacklisted_peer_tries_to_register()
{
var blacklistedPeer = TestDataBuilder.CreatePersistentPeerDescriptor("tcp://blacklistedpeer:123", typeof(FakeCommand));
var registerCommand = new RegisterPeerCommand(blacklistedPeer);
_handler.Context = MessageContext.CreateTest(new OriginatorInfo(blacklistedPeer.Peer.Id, blacklistedPeer.Peer.EndPoint, "BLACKLISTEDMACHINE", "initiator"));
var exception = typeof(InvalidOperationException).ShouldBeThrownBy(() => _handler.Handle(registerCommand));
exception.Message.ShouldEqual("Peer Abc.Testing.0 on host BLACKLISTEDMACHINE is not allowed to register on this directory");
}
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_get_reply_code()
{
_messageDispatcher.LoadMessageHandlerInvokers();
int?replyCode = null;
var context = MessageContext.CreateTest();
var dispatch = new MessageDispatch(context, new ReplyCommand(), (x, r) => replyCode = context.ReplyCode);
_messageDispatcher.Dispatch(dispatch);
Wait.Until(() => replyCode == ReplyCommand.ReplyCode, 500.Milliseconds());
}
public void should_get_reply_code()
{
LoadAndStartDispatcher();
int?replyCode = null;
var context = MessageContext.CreateTest();
var dispatch = new MessageDispatch(context, new ReplyCommand(), new TestMessageSerializer(), (x, r) => replyCode = context.ReplyCode);
_messageDispatcher.Dispatch(dispatch);
Wait.Until(() => replyCode == ReplyCommand.ReplyCode, 2.Seconds());
}
private Task <DispatchResult> Dispatch(IMessage message, bool isLocal = false)
{
var taskCompletionSource = new TaskCompletionSource <DispatchResult>();
var dispatch = new MessageDispatch(MessageContext.CreateTest("u.name"), message, new TestMessageSerializer(), (x, r) => taskCompletionSource.SetResult(r))
{
IsLocal = isLocal
};
_messageDispatcher.Dispatch(dispatch);
return(taskCompletionSource.Task);
}
private Task <DispatchResult> EnqueueBatchedInvocation(ExecutableEvent message)
{
var tcs = new TaskCompletionSource <DispatchResult>();
var dispatch = new MessageDispatch(MessageContext.CreateTest(), message, (d, r) => tcs.SetResult(r));
dispatch.SetHandlerCount(1);
var invoker = new TestBatchedMessageHandlerInvoker <FakeEvent>();
_dispatchQueue.Enqueue(dispatch, invoker);
return(tcs.Task);
}
public void should_override_username()
{
var context = MessageContext.CreateTest("original");
using (MessageContext.SetCurrent(context))
{
MessageContext.Current.InitiatorUserName.ShouldEqual("original");
using (MessageContext.OverrideInitiatorUsername("override"))
MessageContext.Current.InitiatorUserName.ShouldEqual("override");
MessageContext.Current.InitiatorUserName.ShouldEqual("original");
}
}
public void Setup()
{
_contextScope = MessageContext.SetCurrent(MessageContext.CreateTest());
_configurationMock = new Mock <IDirectoryConfiguration>();
_configurationMock.SetupGet(conf => conf.BlacklistedMachines).Returns(new[] { "ANOTHER_BLACKLISTEDMACHINE", "BLACKlistedMACHINE" });
_repositoryMock = new Mock <IPeerRepository>();
_bus = new TestBus();
_speedReporter = new Mock <IDirectorySpeedReporter>();
_handler = new DirectoryCommandsHandler(_bus, _repositoryMock.Object, _configurationMock.Object, _speedReporter.Object)
{
Context = MessageContext.CreateOverride(_sender.Id, _sender.EndPoint)
};
}
public void should_build_invocation_with_pipe()
{
var pipe = new FakePipe {
IsAutoEnabled = true
};
_pipeSource.Pipes.Add(pipe);
var message = new FakeCommand(123);
var messageContext = MessageContext.CreateTest("u.name");
var invoker = new TestMessageHandlerInvoker(typeof(FakeCommandHandler), typeof(FakeCommand));
var invocation = _pipeManager.BuildPipeInvocation(invoker, message, messageContext);
invocation.Pipes.Single().ShouldEqual(pipe);
}
public void MeasureLocalDispatch()
{
// 25/11/2013 - PC CAO: 190k/s
var bus = new BusFactory()
.WithHandlers(typeof(PerfCommandHandler), typeof(PerfEventHandler))
.CreateAndStartInMemoryBus();
using (MessageContext.SetCurrent(MessageContext.CreateTest().WithDispatchQueueName(DispatchQueueNameScanner.DefaultQueueName)))
{
Measure.Execution(500000, () => bus.Send(new PerfCommand(42)));
}
bus.Stop();
}
public void should_continue_processing_messages_after_continuation_error()
{
_dispatchQueue.Start();
var message1 = new ExecutableEvent {
Callback = x => throw new Exception("Processing error")
};
var dispatch = new MessageDispatch(MessageContext.CreateTest(), message1, new TestMessageSerializer(), (d, r) => throw new Exception("Continuation error"));
dispatch.SetHandlerCount(1);
_dispatchQueue.Enqueue(dispatch, new TestMessageHandlerInvoker <ExecutableEvent>());
var message2 = new ExecutableEvent();
var task = EnqueueInvocation(message2);
task.Wait(5.Seconds()).ShouldBeTrue();
}
public void should_forward_initiator_id()
{
using (MessageId.PauseIdGeneration())
{
var receivedCommand = new FakeCommand(123);
var eventToPublish = new FakeEvent(456);
SetupDispatch(receivedCommand, _ => _bus.Publish(eventToPublish));
SetupPeersHandlingMessage <FakeEvent>(_peerDown);
using (MessageContext.SetCurrent(MessageContext.CreateTest(new OriginatorInfo(_peerUp.Id, _peerUp.EndPoint, null, "x.initiator"))))
{
var transportMessageReceived = receivedCommand.ToTransportMessage(_peerUp);
transportMessageReceived.Originator.InitiatorUserName.ShouldEqual("x.initiator");
_transport.RaiseMessageReceived(transportMessageReceived);
}
var sentMessage = _transport.Messages.Single(x => x.TransportMessage.MessageTypeId == eventToPublish.TypeId());
sentMessage.TransportMessage.Originator.InitiatorUserName.ShouldEqual("x.initiator");
}
}
public void should_invoke_handler()
{
var handler = new Handler();
var container = new Container(x => x.ForSingletonOf <Handler>().Use(handler));
var messages = new List <IMessage>
{
new Message {
Id = 1
},
new Message {
Id = 2
},
};
var invoker = new BatchedMessageHandlerInvoker(container, typeof(Handler), typeof(Message));
var invocation = new PipeInvocation(invoker, messages, MessageContext.CreateTest(), new IPipe[0]);
invocation.Run();
handler.Messages.ShouldEqual(messages.Cast <Message>().ToList());
}
public void should_hide_task_scheduler()
{
_messageDispatcher.LoadMessageHandlerInvokers();
var syncHandler = new CapturingTaskSchedulerSyncCommandHandler();
_containerMock.Setup(x => x.GetInstance(typeof(CapturingTaskSchedulerSyncCommandHandler))).Returns(syncHandler);
var asyncHandler = new CapturingTaskSchedulerAsyncCommandHandler();
_containerMock.Setup(x => x.GetInstance(typeof(CapturingTaskSchedulerAsyncCommandHandler))).Returns(asyncHandler);
var command = new DispatchCommand();
Dispatch(command, MessageContext.CreateTest("u.name").WithDispatchQueueName("some queue")); // make sure we go through a dispatch queue!
syncHandler.Signal.WaitOne(1.Second()).ShouldBeTrue();
asyncHandler.Signal.WaitOne(1.Second()).ShouldBeTrue();
syncHandler.TaskScheduler.ShouldEqual(TaskScheduler.Default);
asyncHandler.TaskScheduler.ShouldEqual(TaskScheduler.Default);
}
public void should_run_invoker_synchronously_if_dispatch_queue_name_equals_current_queue_name()
{
_messageDispatcher.LoadMessageHandlerInvokers();
var handler = new SyncCommandHandlerWithQueueName1()
{
WaitForSignal = true
};
_containerMock.Setup(x => x.GetInstance(typeof(SyncCommandHandlerWithQueueName1))).Returns(handler);
var task = Task.Run(() =>
{
var context = MessageContext.CreateTest("u.name").WithDispatchQueueName("DispatchQueue1");
Dispatch(new DispatchCommand(), context);
});
Thread.Sleep(150);
task.IsCompleted.ShouldBeFalse("Dispatch should run synchronously");
handler.CalledSignal.Set();
Wait.Until(() => task.IsCompleted, 150.Milliseconds());
}
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 static IMessageHandlerInvocation ToInvocation(this IMessage message)
{
return(ToInvocation(message, MessageContext.CreateTest("u.name")));
}
protected virtual MessageContext CreateMessageContext()
{
return(MessageContext.CreateTest());
}
private void Dispatch(IMessage message, MessageDispatcher dispatcher = null)
{
var messageContext = MessageContext.CreateTest("u.name");
Dispatch(message, messageContext.WithDispatchQueueName(DispatchQueueNameScanner.DefaultQueueName), dispatcher);
}
public static TestPipeInvocation Create <TMessage>(TMessage message) where TMessage : class, IMessage
{
return(new TestPipeInvocation(message, MessageContext.CreateTest("u.name"), new TestMessageHandlerInvoker <TMessage>()));
}
public TestPipeInvocation(IMessage message, Type handlerType, Exception exception = null) : base(new TestMessageHandlerInvoker(handlerType, message.GetType()), message, MessageContext.CreateTest("u.name"), new List <IPipe>())
{
AddExceptionCallback(exception);
}