public void EachDestinationIsSubscribedOnDedicatedThreadTest()
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory())){
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
var queue1MessagesThreadIds = new List <int>();
var queue2MessagesThreadIds = new List <int>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), s => queue1MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId)))
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"), s => queue2MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId)))
{
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"));
Thread.Sleep(1000);
}
Assert.That(queue1MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue2MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue1MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue2MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue1MessagesThreadIds.First() != queue2MessagesThreadIds.First(), Is.True, "Messages from different subscriptions were processed one thread");
}
}
public void SendTest(string dest)
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, dest), s => { }))
{
engine.Send(Guid.NewGuid().ToString(), new Endpoint(TransportConstants.TRANSPORT_ID1, dest));
Thread.Sleep(1000);
}
int i = 0;
Stopwatch sw = Stopwatch.StartNew();
var done = new ManualResetEvent(false);
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, dest), s =>
{
if (Interlocked.Increment(ref i) == 2961)
{
done.Set();
}
}))
{
var message = string.Join(",", Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()));
while (!done.WaitOne(0))
{
engine.Send(message, new Endpoint(TransportConstants.TRANSPORT_ID1, dest));
}
}
Console.WriteLine(sw.ElapsedMilliseconds);
}
}
public void SharedDestinationSendSubscribeTest()
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
engine.SerializationManager.RegisterSerializer("fake", typeof(int), new FakeIntSerializer());
var recievedNonSharedMessages = new List <string>();
var recievedStrMessages = new List <string>();
var recievedIntMessages = new List <int>();
using (
engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, false, serializationFormat: "fake"), s =>
{
recievedNonSharedMessages.Add(s);
Console.WriteLine("Non-Shared dest subscription #1:" + s);
}))
using (
engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, true, serializationFormat: "fake"), s =>
{
recievedStrMessages.Add(s);
Console.WriteLine("Subscription #1:" + s);
}))
using (engine.Subscribe <int>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, true, serializationFormat: "fake"), i =>
{
recievedIntMessages.Add(i);
Console.WriteLine("Subscription #2:" + i);
}))
{
engine.Send("11", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("12", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("13", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("14", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("15", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(21, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("16", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(22, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("23", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(24, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(25, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(26, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(27, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(28, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
Thread.Sleep(2000);
}
Assert.That(recievedNonSharedMessages.Count, Is.EqualTo(14), "Not all messages from both sequences were received by non-shared subscription ");
Assert.That(recievedStrMessages.Count, Is.EqualTo(7), "Not all messages from first sequence were received by corresponding subscription ");
Assert.That(recievedIntMessages.Count, Is.EqualTo(7), "Not all messages from second sequence were received by corresponding subscription");
}
}
public void EndToEndRabbitResubscriptionTest()
{
var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo> {
{ "test", new TransportInfo(HOST, "guest", "guest", null, "RabbitMq") }
}),
new RabbitMqTransportFactory(_logFactory));
using (messagingEngine)
{
for (int i = 0; i < 100; i++)
{
messagingEngine.Send(i, new Endpoint("test", TEST_EXCHANGE, serializationFormat: SerializationFormat.Json));
}
messagingEngine.Subscribe <int>(new Endpoint("test", TEST_QUEUE, serializationFormat: SerializationFormat.Json), message =>
{
Console.WriteLine(message + "\n");
Thread.Sleep(1000);
});
Thread.Sleep(30 * 60 * 1000);
}
Console.WriteLine("Done");
}
public void ByDefaultEachDestinationIsSubscribedOnDedicatedThreadTest()
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(new LogToConsole(), resolver, new InMemoryTransportFactory()))
{
engine.SerializationManager.RegisterSerializer(SerializationFormat.Json, typeof(string), new FakeStringSerializer());
var queue1MessagesThreadIds = new List <int>();
var queue2MessagesThreadIds = new List <int>();
var messagesCounter = 0;
var allMessagesAreRecieved = new ManualResetEvent(false);
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json), s =>
{
queue1MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
if (Interlocked.Increment(ref messagesCounter) == 6)
{
allMessagesAreRecieved.Set();
}
}))
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json), s =>
{
queue2MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
if (Interlocked.Increment(ref messagesCounter) == 6)
{
allMessagesAreRecieved.Set();
}
}))
{
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json));
allMessagesAreRecieved.WaitOne(1000);
}
Assert.That(queue1MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue2MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue1MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue2MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue1MessagesThreadIds.First() != queue2MessagesThreadIds.First(), Is.True, "Messages from different subscriptions were processed one thread");
}
}
public void UnknownMessageTest()
{
ITransportResolver transportResolver = new TransportResolver(new Dictionary <string, TransportInfo>()
{
{ "main", new TransportInfo(HOST, "guest", "guest", "None", "RabbitMq") }
});
var eq = new Endpoint("main", TEST_QUEUE, true, "json");
var ee = new Endpoint("main", TEST_EXCHANGE, true, "json");
using (var me = new MessagingEngine(transportResolver, new RabbitMqTransportFactory()))
{
me.Send("string value", ee);
}
using (var me = new MessagingEngine(transportResolver, new RabbitMqTransportFactory()))
{
me.Subscribe <int>(eq, Console.WriteLine);
me.Subscribe <double>(eq, Console.WriteLine);
// me.Subscribe<string>(eq, Console.WriteLine);
}
Thread.Sleep(1200);
}
public void ContextUsesDefaultRouteForCommandPublishingIfItDoesNotHaveItsOwnTest()
{
var bcCommands = new Endpoint("InMemory", "bcCommands", serializationFormat: SerializationFormat.Json);
var defaultCommands = new Endpoint("InMemory", "defaultCommands", serializationFormat: SerializationFormat.Json);
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.BoundedContext("bc2")
.PublishingCommands(typeof(int)).To("bc1").With("bcCommands"),
Register.DefaultRouting
.PublishingCommands(typeof(string)).To("bc1").With("defaultCommands")
.PublishingCommands(typeof(int)).To("bc1").With("defaultCommands")))
{
engine.Start();
var received = new AutoResetEvent(false);
using (messagingEngine.Subscribe(defaultCommands, o => received.Set(), s => { }, typeof(string)))
{
engine.SendCommand("test", "bc2", "bc1");
Assert.That(received.WaitOne(2000), Is.True, "not defined for context command was not routed with default route map");
}
using (messagingEngine.Subscribe(bcCommands, o => received.Set(), s => { }, typeof(int)))
{
engine.SendCommand(1, "bc2", "bc1");
Assert.That(received.WaitOne(2000), Is.True, "defined for context command was not routed with context route map");
}
}
}
}
public void Subscribe()
{
ITransportResolver resolver = ObjectMother.MockTransportResolver("Weblogic");
using (IMessagingEngine engine = new MessagingEngine(resolver, new WeblogicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
var receivedMessages = new List <object>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), receivedMessages.Add))
{
Thread.Sleep(1000);
}
foreach (var receivedMessage in receivedMessages)
{
Console.WriteLine(receivedMessage);
}
}
}
public void SubscriptionToClusterTest()
{
ITransportResolver transportResolver = new TransportResolver(new Dictionary <string, TransportInfo>()
{
{ "main", new TransportInfo("localhost1,localhost", "guest", "guest", "None", "RabbitMq") },
{ "sendTransport", new TransportInfo("localhost", "guest", "guest", "None", "RabbitMq") }
});
var endpoint = new Endpoint("main", TEST_EXCHANGE, TEST_QUEUE, true, SerializationFormat.Json);
var sendEndpoint = new Endpoint("sendTransport", TEST_EXCHANGE, TEST_QUEUE, true, SerializationFormat.Json);
using (var me = new MessagingEngine(_logFactory, transportResolver, new RabbitMqTransportFactory(_logFactory, false)))
{
me.Send(1, sendEndpoint);
me.ResubscriptionTimeout = 100;
var received = new ManualResetEvent(false);
me.Subscribe <int>(endpoint, i => received.Set());
Assert.That(received.WaitOne(1000), Is.True, "Subscription when first broker in list is not resolvable while next one is ok");
}
}
public void SendSubscribeWithTimeToLive()
{
ITransportResolver resolver = ObjectMother.MockTransportResolver("Weblogic");
using (IMessagingEngine engine = new MessagingEngine(resolver, new WeblogicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
engine.Send("ping1", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), 200);
engine.Send("ping2", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), 1000);
Thread.Sleep(300);
var receivedMessages = new List <object>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), receivedMessages.Add))
{
Thread.Sleep(1000);
}
Assert.AreEqual(1, receivedMessages.Count);
Assert.AreEqual("ping2", receivedMessages[0]);
}
}
protected override IDisposable InitializeFeed(Subject <TData> dataFeed, TInitResponse response, TContext context)
{
var hbEndpoint = GetHbEndpoint(context);
var heartBeatInterval = GetHeartbeatIntervalFromResponse(response, context);
Logger.DebugFormat("Subscribing for heartbeats. Context: {0}; Endpoint: {1}; Hb interval {2}ms", GetContextLogRepresentationString(context), hbEndpoint, heartBeatInterval);
var scheduledHbLoss = new SerialDisposable();
var hbSubscription = Disposable.Empty;
var tmp = MessagingEngine.Subscribe <THeartbeatMessage>(hbEndpoint, message => processHeartBeat(context, message, dataFeed, heartBeatInterval, scheduledHbLoss));
hbSubscription = Disposable.Create(() =>
{
tmp.Dispose();
Logger.DebugFormat("Unsubscribed from heartbeats: {0}; Endpoint: {1}", GetContextLogRepresentationString(context), hbEndpoint);
});
scheduledHbLoss.Disposable = scheduleHbLoss(heartBeatInterval, dataFeed, context);
return(new CompositeDisposable(hbSubscription, scheduledHbLoss));
}
public void SendSubscribeTest(string dest)
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
var recievedMessages = new List <object>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"), recievedMessages.Add))
{
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
Thread.Sleep(1000);
}
Assert.That(recievedMessages.Count, Is.EqualTo(3), "Some messages were not received");
Assert.That(recievedMessages, Is.EqualTo(new[] { "test", "test", "test" }), "Some messages were corrupted");
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
Thread.Sleep(100);
Assert.That(recievedMessages.Count, Is.EqualTo(3),
"Subscription callback was called after subscription is disposed");
}
}
public void Start()
{
foreach (var registration in _registrations)
{
registration.Create(this);
}
foreach (var registration in _registrations)
{
registration.Process(this);
}
EnsureEndpoints();
foreach (var boundedContext in Contexts)
{
foreach (var route in boundedContext.Routes)
{
Context context = boundedContext;
var subscriptions = route.MessageRoutes
.Where(r => r.Key.CommunicationType == CommunicationType.Subscribe)
.Select(r => new
{
type = r.Key.MessageType,
priority = r.Key.Priority,
remoteBoundedContext = r.Key.RemoteBoundedContext,
endpoint = new Endpoint(
r.Value.TransportId,
"",
r.Value.Destination.Subscribe,
r.Value.SharedDestination,
r.Value.SerializationFormat)
})
.GroupBy(x => Tuple.Create(x.endpoint, x.priority, x.remoteBoundedContext))
.Select(g => new
{
endpoint = g.Key.Item1,
priority = g.Key.Item2,
remoteBoundedContext = g.Key.Item3,
types = g.Select(x => x.type).ToArray()
});
foreach (var subscription in subscriptions)
{
var processingGroup = route.ProcessingGroupName;
var routeName = route.Name;
var endpoint = subscription.endpoint;
var remoteBoundedContext = subscription.remoteBoundedContext;
CallbackDelegate <object> callback = null;
string messageTypeName = null;
switch (route.Type)
{
case RouteType.Events:
callback = (@event, acknowledge, headers) => context.EventDispatcher.Dispatch(remoteBoundedContext, new[] { Tuple.Create(@event, acknowledge) });
messageTypeName = "event";
break;
case RouteType.Commands:
callback = (command, acknowledge, headers) => context.CommandDispatcher.Dispatch(command, acknowledge, endpoint, routeName);
messageTypeName = "command";
break;
}
_subscription.Add(MessagingEngine.Subscribe(
endpoint,
callback,
(type, acknowledge) => throw new InvalidOperationException($"Unknown {messageTypeName} received: {type}"),
processingGroup,
(int)subscription.priority,
subscription.types));
}
}
}
foreach (var boundedContext in Contexts)
{
boundedContext.Processes.ForEach(p => p.Start(boundedContext, boundedContext.EventsPublisher));
}
}
