public void MeasureThroughput()
{
const int sendMessageCount = 2000000;
var senderTransport = CreateAndStartZmqTransport("Abc.Testing.Sender");
var receivedMessageCount = 0;
var receiverTransport = CreateAndStartZmqTransport("Abc.Testing.Receiver", _ => ++receivedMessageCount);
var receivers = new[] { new Peer(receiverTransport.PeerId, receiverTransport.InboundEndPoint) };
var transportMessage = new FakeCommand(42).ToTransportMessage();
senderTransport.Send(transportMessage, receivers);
var spinWait = new SpinWait();
while (receivedMessageCount != 1)
spinWait.SpinOnce();
using (Measure.Throughput(sendMessageCount))
{
for (var i = 0; i < sendMessageCount; ++i)
{
senderTransport.Send(transportMessage, receivers);
}
while (receivedMessageCount != sendMessageCount + 1)
spinWait.SpinOnce();
}
senderTransport.Stop();
receiverTransport.Stop();
}
public void should_send_MessageProcessingFailed_if_unable_to_deserialize_message()
{
SetupPeersHandlingMessage<MessageProcessingFailed>(_peerUp);
_bus.Start();
var command = new FakeCommand(123);
_messageSerializer.AddSerializationExceptionFor(command.TypeId(), "Serialization error");
using (SystemDateTime.PauseTime())
using (MessageId.PauseIdGeneration())
{
var transportMessage = command.ToTransportMessage();
var messageProcessingFailedBytes = new MessageProcessingFailed(null, null, null, DateTime.UtcNow, null).ToTransportMessage().MessageBytes;
_messageSerializer.AddSerializationFuncFor<MessageProcessingFailed>(x =>
{
x.FailingMessage.ShouldEqual(transportMessage);
x.ExceptionUtcTime.ShouldEqual(SystemDateTime.UtcNow);
x.ExceptionMessage.ShouldContain("Unable to deserialize message");
return messageProcessingFailedBytes;
});
_transport.RaiseMessageReceived(transportMessage);
var processingFailedTransportMessage = new TransportMessage(MessageUtil.TypeId<MessageProcessingFailed>(), messageProcessingFailedBytes, _self);
_transport.ExpectExactly(new TransportMessageSent(processingFailedTransportMessage, _peerUp));
}
}
public void should_not_block_when_hitting_high_water_mark()
{
var senderTransport = CreateAndStartZmqTransport();
senderTransport.SocketOptions.SendHighWaterMark = 3;
senderTransport.SocketOptions.SendTimeout = 50.Milliseconds();
senderTransport.SocketOptions.SendRetriesBeforeSwitchingToClosedState = 2;
var receviedMessages = new List<TransportMessage>();
var upReceiverTransport = CreateAndStartZmqTransport(onMessageReceived: receviedMessages.Add);
var upReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Up"), upReceiverTransport.InboundEndPoint);
var downReceiverTransport = CreateAndStartZmqTransport();
var downReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Down"), downReceiverTransport.InboundEndPoint);
downReceiverTransport.Stop();
for (var i = 1; i <= 10; ++i)
{
var message = new FakeCommand(i).ToTransportMessage();
senderTransport.Send(message, new[] { upReceiver, downReceiver });
var expectedMessageCount = i;
Wait.Until(() => receviedMessages.Count == expectedMessageCount, 500.Milliseconds(), "Failed to send message after " + i + " successful sent");
}
}
public void should_resolve_peer_using_basic_round_robin_for_different_commands()
{
// Arrange
var resolver = new RoundRobinPeerSelector();
var command1 = new FakeCommand(42);
var command1Peer1 = new Peer(new PeerId("command1peer1"), "endpoint1");
var command1Peer2 = new Peer(new PeerId("command1peer2"), "endpoint2");
var command1HandlingPeer = new[] { command1Peer1, command1Peer2 };
var command2 = new FakeInfrastructureCommand();
var command2Peer1 = new Peer(new PeerId("command2peer1"), "endpoint1");
var command2Peer2 = new Peer(new PeerId("command2peer2"), "endpoint2");
var command2HandlingPeer = new[] { command2Peer1, command2Peer2 };
// Act - Assert
var resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer1);
resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer2);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer1);
resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer1);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer2);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer1);
}
public void should_receive_messages_immediately_after_start()
{
Transport.Start();
var message = new FakeCommand(123).ToTransportMessage();
InnerTransport.RaiseMessageReceived(message);
Wait.Until(() => MessagesForwardedToBus.Count == 1, 500.Milliseconds());
}
public void should_ack_transport_when_handling_undeserializable_message()
{
var command = new FakeCommand(123);
_messageSerializer.AddSerializationExceptionFor(command.TypeId());
var transportMessage = command.ToTransportMessage();
_transport.RaiseMessageReceived(transportMessage);
_transport.AckedMessages.ShouldContain(transportMessage);
}
public void should_throw_exception_if_no_peer_is_setup_to_handle_a_command()
{
var command = new FakeCommand(456);
SetupPeersHandlingMessage<FakeCommand>(new Peer[0]);
_bus.Start();
Assert.Throws<InvalidOperationException>(() => _bus.Send(command));
}
public void should_not_publish_a_MessageHandled_event_after_a_persistent_message_is_processed_by_a_non_persistent_host()
{
Transport.Start();
var command = new FakeCommand(123).ToTransportMessage();
InnerTransport.RaiseMessageReceived(command);
Thread.Sleep(10);
InnerTransport.ExpectNothing();
}
public void should_dispatch_received_message()
{
var command = new FakeCommand(123);
var invokerCalled = false;
SetupDispatch(command, _ => invokerCalled = true);
var transportMessageReceived = command.ToTransportMessage(_peerUp);
_transport.RaiseMessageReceived(transportMessageReceived);
invokerCalled.ShouldBeTrue();
}
public void should_not_throw_when_handling_a_persistent_command_even_if_peer_is_not_responding()
{
var command = new FakeCommand(456);
var peer = new Peer(new PeerId("Abc.Testing.Peer1"), "Peer1Endpoint", true, isResponding: false);
SetupPeersHandlingMessage<FakeCommand>(new[] { peer });
_bus.Start();
_bus.Send(command);
var sentMessage = _transport.MessagesSent.ExpectedSingle();
sentMessage.ShouldHaveSamePropertiesAs(command);
}
public void should_send_command_with_message_context()
{
MessageContext.Current.ShouldBeNull();
var message = new FakeCommand(1);
MessageContext context = null;
_busMock.Setup(x => x.Send(message)).Callback(() => context = MessageContext.Current);
_bus.Send(message);
MessageContext.Current.ShouldBeNull();
context.ShouldEqual(_context);
}
public void should_only_forward_replayed_messages_during_replay_phase()
{
Transport.Start();
var transportMessageToForward = new FakeCommand(123).ToTransportMessage();
var normalTransportMessage = new FakeEvent(123).ToTransportMessage();
var replayedTransportMessage = transportMessageToForward.ToReplayedTransportMessage(ReplayId);
InnerTransport.RaiseMessageReceived(replayedTransportMessage);
InnerTransport.RaiseMessageReceived(normalTransportMessage);
MessagesForwardedToBus.Count.ShouldEqual(1);
MessagesForwardedToBus.Single().Id.ShouldEqual(transportMessageToForward.Id);
}
public void should_throw_exception_if_several_peers_can_handle_a_command()
{
var command = new FakeCommand(456);
var peer1 = new Peer(new PeerId("Abc.Testing.Peer1"), "Peer1Endpoint");
var peer2 = new Peer(new PeerId("Abc.Testing.Peer2"), "Peer2Endpoint");
SetupPeersHandlingMessage<FakeCommand>(peer1, peer2);
_bus.Start();
Assert.Throws<InvalidOperationException>(() => _bus.Send(command));
}
public void should_not_consider_if_peer_is_up_to_send_commands([Values(true, false)]bool isTargetPeerUp)
{
using (MessageId.PauseIdGeneration())
{
var command = new FakeCommand(456);
SetupPeersHandlingMessage<FakeCommand>(isTargetPeerUp ? _peerUp : _peerDown);
_bus.Start();
_bus.Send(command);
_transport.ExpectExactly(new TransportMessageSent(command.ToTransportMessage(_self), new[] { isTargetPeerUp ? _peerUp : _peerDown }));
}
}
public void should_return_null_when_no_peer_can_handle_the_command()
{
// Arrange
var resolver = new RoundRobinPeerSelector();
var command = new FakeCommand(42);
var handlingPeers = new Peer[0];
// Act
var resolvedPeer = resolver.GetTargetPeer(command, handlingPeers);
// Assert
resolvedPeer.ShouldBeNull();
}
public void should_send_command_to_peer_with_message_context()
{
MessageContext.Current.ShouldBeNull();
var message = new FakeCommand(1);
var peer = new Peer(new PeerId("Abc.Foo.0"), "tcp://dtc:1234");
MessageContext context = null;
_busMock.Setup(x => x.Send(message, peer)).Callback(() => context = MessageContext.Current);
_bus.Send(message, peer);
MessageContext.Current.ShouldBeNull();
context.ShouldEqual(_context);
}
public void shoud_send_a_completion_message_with_error_code_on_exception()
{
using (MessageId.PauseIdGeneration())
{
var command = new FakeCommand(123);
SetupDispatch(command, error: new Exception());
var transportMessageReceived = command.ToTransportMessage(_peerUp);
_transport.RaiseMessageReceived(transportMessageReceived);
var expectedTransportMessage = new MessageExecutionCompleted(transportMessageReceived.Id, 1, null).ToTransportMessage(_self);
_transport.Expect(new TransportMessageSent(expectedTransportMessage, _peerUp));
}
}
public void should_forward_a_normal_message_after_a_back_to_live_event()
{
Transport.Start();
var transportMessageToForward = new FakeCommand(123).ToTransportMessage();
InnerTransport.RaiseMessageReceived(transportMessageToForward);
MessagesForwardedToBus.ShouldBeEmpty();
InnerTransport.RaiseMessageReceived(new ReplayPhaseEnded(StartMessageReplayCommand.ReplayId).ToTransportMessage());
Thread.Sleep(50);
MessagesForwardedToBus.Count.ShouldEqual(1);
MessagesForwardedToBus.Single().ShouldEqualDeeply(transportMessageToForward);
}
public void should_return_the_only_handling_peer_when_there_is_only_one_handling_peer()
{
// Arrange
var resolver = new RoundRobinPeerSelector();
var command = new FakeCommand(42);
var peer1 = new Peer(new PeerId("peer1"), "endpoint1");
var handlingPeers = new []{ peer1 };
// Act
var resolvedPeer = resolver.GetTargetPeer(command, handlingPeers);
// Assert
resolvedPeer.ShouldEqual(peer1);
}
public void shoud_send_a_completion_message_without_error_code()
{
using (MessageId.PauseIdGeneration())
{
var command = new FakeCommand(123);
SetupDispatch(command);
var transportMessageReceived = command.ToTransportMessage(_peerUp);
_transport.RaiseMessageReceived(transportMessageReceived);
var messageExecutionCompleted = new MessageExecutionCompleted(transportMessageReceived.Id, 0, null).ToTransportMessage(_self);
_transport.ExpectExactly(new TransportMessageSent(messageExecutionCompleted, _peerUp));
}
}
public void should_not_filter_received_messages_when_environment_is_not_specified()
{
var transport1 = CreateAndStartZmqTransport(environment: null);
var transport2ReceivedMessages = new ConcurrentBag<TransportMessage>();
var transport2 = CreateAndStartZmqTransport(onMessageReceived: transport2ReceivedMessages.Add, environment: "NotTest");
var transport2Peer = new Peer(new PeerId("Abc.Testing.2"), transport2.InboundEndPoint);
var message = new FakeCommand(1).ToTransportMessage();
transport1.Send(message, new[] { transport2Peer });
Wait.Until(() => transport2ReceivedMessages.Count >= 1, 500.Milliseconds());
transport2ReceivedMessages.Single().Id.ShouldEqual(message.Id);
}
public void should_forward_error_when_handling_command_locally()
{
var command = new FakeCommand(1);
SetupDispatch(command, error: new Exception("Test error"));
SetupPeersHandlingMessage<FakeCommand>(_self);
_bus.Start();
var task = _bus.Send(command);
var completed = task.Wait(500);
completed.ShouldBeTrue();
task.Result.IsSuccess.ShouldBeFalse();
}
public void shoud_send_a_completion_message_with_domain_exception_error_code()
{
using (MessageId.PauseIdGeneration())
{
const int domainExceptionValue = 5000;
var command = new FakeCommand(123);
SetupDispatch(command, error: new DomainException(domainExceptionValue, "Domain Exception"));
var transportMessageReceived = command.ToTransportMessage(_peerUp);
_transport.RaiseMessageReceived(transportMessageReceived);
var expectedTransportMessage = new MessageExecutionCompleted(transportMessageReceived.Id, domainExceptionValue).ToTransportMessage(_self);
_transport.ExpectExactly(new TransportMessageSent(expectedTransportMessage, _peerUp));
}
}
public void should_handle_command_locally()
{
var command = new FakeCommand(1);
var handled = false;
SetupDispatch(command, _ => handled = true);
SetupPeersHandlingMessage<FakeCommand>(_self);
_bus.Start();
var completed = _bus.Send(command).Wait(500);
handled.ShouldBeTrue();
completed.ShouldBeTrue();
_transport.Messages.ShouldBeEmpty();
}
public void should_not_let_the_outbound_thread_die_if_a_peer_cannot_be_resolved()
{
var senderTransport = CreateAndStartZmqTransport(environment: null);
var receivedMessages = new ConcurrentBag<TransportMessage>();
var destinationTransport = CreateAndStartZmqTransport(onMessageReceived: receivedMessages.Add, environment: "NotTest");
var destinationPeer = new Peer(new PeerId("Abc.Testing.2"), destinationTransport.InboundEndPoint);
var nonExistingPeer = new Peer(new PeerId("Abc.NonExistingPeer.2"), "tcp://non_existing_peer:1234");
var message = new FakeCommand(1).ToTransportMessage();
senderTransport.Send(message, new[] { nonExistingPeer });
senderTransport.Send(message, new[] { destinationPeer });
Wait.Until(() => receivedMessages.Count >= 1, 1000.Milliseconds(), "The outbound thread was killed and couldn't connect to the next peer");
}
public void should_not_lose_messages_when_switching_to_safety_phase()
{
Transport.Start();
var liveMessageToStack = new FakeCommand(123).ToTransportMessage();
var replayedMessageToPlayAfterStack = new FakeCommand(456).ToTransportMessage();
InnerTransport.RaiseMessageReceived(liveMessageToStack);
InnerTransport.RaiseMessageReceived(new ReplayPhaseEnded(StartMessageReplayCommand.ReplayId).ToTransportMessage());
InnerTransport.RaiseMessageReceived(replayedMessageToPlayAfterStack.ToReplayedTransportMessage(StartMessageReplayCommand.ReplayId));
Wait.Until(() => MessagesForwardedToBus.Count >= 2, 150.Milliseconds());
MessagesForwardedToBus.Count.ShouldEqual(2);
MessagesForwardedToBus.First().Id.ShouldEqual(liveMessageToStack.Id);
MessagesForwardedToBus.Last().Id.ShouldEqual(replayedMessageToPlayAfterStack.Id);
}
public void should_not_send_a_MessageProcessingFailed_on_domain_exception_with_local_processing()
{
SetupPeersHandlingMessage<MessageProcessingFailed>(_peerUp);
using (SystemDateTime.PauseTime())
using (MessageId.PauseIdGeneration())
{
var command = new FakeCommand(123);
SetupDispatch(command, error: new DomainException(123, "Exception message"));
SetupPeersHandlingMessage<FakeCommand>(_self);
_bus.Start();
_bus.Send(command);
_transport.ExpectNothing();
}
}
public void should_send_message()
{
using (MessageId.PauseIdGeneration())
{
var command = new FakeCommand(456);
SetupPeersHandlingMessage<FakeCommand>(_peerUp);
_bus.Start();
_bus.Send(command);
var sentMessage = _transport.Messages.Single();
var expectedTransportMessage = command.ToTransportMessage(_self);
sentMessage.TransportMessage.ShouldHaveSamePropertiesAs(expectedTransportMessage);
var destination = sentMessage.Targets.Single();
destination.ShouldHaveSamePropertiesAs(_peerUp);
}
}
public void should_release_task_when_completion_message_is_sent()
{
using (MessageId.PauseIdGeneration())
{
var command = new FakeCommand(123);
SetupPeersHandlingMessage<FakeCommand>(_peerUp);
_bus.Start();
var task = _bus.Send(command);
var commandCompleted = new MessageExecutionCompleted(MessageId.NextId(), 1);
_transport.RaiseMessageReceived(commandCompleted.ToTransportMessage());
var receivedAck = task.Wait(10);
receivedAck.ShouldBeTrue();
task.Result.ErrorCode.ShouldEqual(1);
}
}
public void handlers_reply_with_an_int()
{
using (MessageId.PauseIdGeneration())
{
const int commandReply = 456;
var command = new FakeCommand(123);
SetupDispatch(command, _ => _bus.Reply(commandReply));
var transportMessageReceived = command.ToTransportMessage(_peerUp);
var expectedTransportMessage = new MessageExecutionCompleted(transportMessageReceived.Id, commandReply, null).ToTransportMessage(_self);
_transport.RaiseMessageReceived(transportMessageReceived);
var sentMessage = _transport.Messages.Single();
expectedTransportMessage.ShouldHaveSamePropertiesAs(sentMessage.TransportMessage);
var destination = sentMessage.Targets.Single();
destination.ShouldHaveSamePropertiesAs(_peerUp);
}
}