public MessageBusBuilder initBus(MessageBusBuilder bus)
{
return(bus
.Produce <MessageRequest>(x => x.DefaultTopic("Send"))
.Handle <MessageRequest, MessageResponse>(x => x.Topic("Send").WithHandler <Handler>())
.ExpectRequestResponses(x => x.ReplyToTopic("Respond")));
}
public MessageBusBaseTest()
{
_timeZero = DateTimeOffset.Now;
_timeNow = _timeZero;
var messageBusBuilder = new MessageBusBuilder()
.Publish <RequestA>(x =>
{
x.DefaultTopic("a-requests");
x.DefaultTimeout(TimeSpan.FromSeconds(timeoutForA_10));
})
.Publish <RequestB>(x =>
{
x.DefaultTopic("b-requests");
})
.ExpectRequestResponses(x =>
{
x.ReplyToTopic("app01-responses");
x.DefaultTimeout(TimeSpan.FromSeconds(timeoutDefault_20));
})
.WithDependencyResolver(new LookupDependencyResolver(t => null))
.WithSerializer(new JsonMessageSerializer())
.WithProvider(s => new MessageBusTested(s));
_bus = (MessageBusTested)messageBusBuilder.Build();
// provide current time
_bus.CurrentTimeProvider = () => _timeNow;
}
public static void Main()
{
log4net.Config.XmlConfigurator.Configure();
var container = new Container(i => {
});
var messageBus = MessageBusBuilder.Initialize(builder => {
builder.ServiceLocator = new StructureMapServiceLocator(container);
builder.MessageTypeConventions.AddConvention(t => t.Namespace == "MyMessages");
builder.AddAssembliesToScan(Assembly.Load("MyMessages"));
builder.UseServiceBrokerTransport(t => {
t.ListenerQueue = "CWServiceBus_Samples_PubSub_Publisher";
t.ReturnAddress = "[//CWServiceBus/Samples/PubSub/Publisher]";
t.NumberOfWorkerThreads = 1;
t.ServiceBrokerConnectionString = "Data Source=localhost;Initial Catalog=ServiceBus;Trusted_Connection=true";
});
builder.SubscriptionStorage = new CWServiceBus.Unicast.Sql.SqlServerSubscriptionStorage()
{
ConnectionString = "Data Source=localhost;Initial Catalog=ServiceBus;Trusted_Connection=true",
};
});
messageBus.Start();
MessageBus = messageBus;
Run();
}
public static void WithJustCore()
{
// ... Initialization of SlimMessageBus
// Define the recipie how to create our IMessageBus
var busBuilder = new MessageBusBuilder()
.SimpleMessageBus();
// Create the IMessageBus instance from the builder
var bus = busBuilder
.Build();
// Set the provider to resolve our bus - this setup will work as a singleton.
MessageBus.SetProvider(() => bus);
// ... Somewhere in your domain layer
var greeter = new NewUserHelloGreeter();
// Register handler explicitly
bus.Subscribe(greeter);
// Handlers will be executed synchronous.
bus.Publish(new NewUserJoinedEvent("Bob"));
bus.Publish(new NewUserJoinedEvent("Jane"));
// .. OR
MessageBus.Current.Publish(new NewUserJoinedEvent("Jennifer"));
MessageBus.Current.Publish(new NewUserJoinedEvent("Tom"));
bus.UnSubscribe(greeter);
}
public async Task BasicReqRespOnTopic()
{
var topic = "test-echo";
MessageBusBuilder
.Produce <EchoRequest>(x =>
{
x.DefaultTopic(topic);
// this is optional
x.WithModifier((message, sbMessage) =>
{
// set the Azure SB message ID
sbMessage.MessageId = $"ID_{message.Index}";
// set the Azure SB message partition key
sbMessage.PartitionKey = message.Index.ToString(CultureInfo.InvariantCulture);
});
})
.Handle <EchoRequest, EchoResponse>(x => x.Topic(topic)
.SubscriptionName("handler")
.WithHandler <EchoRequestHandler>()
.Instances(2))
.ExpectRequestResponses(x =>
{
x.ReplyToTopic("test-echo-resp");
x.SubscriptionName("response-consumer");
x.DefaultTimeout(TimeSpan.FromSeconds(60));
});
await BasicReqResp().ConfigureAwait(false);
}
public static void Main()
{
log4net.Config.XmlConfigurator.Configure();
var container = new Container(i => {
i.ForSingletonOf <IManagesUnitOfWork>().Use <MyOwnUnitOfWork>();
});
var messageBus = MessageBusBuilder.Initialize(builder => {
builder.ServiceLocator = new StructureMapServiceLocator(container);
builder.MessageTypeConventions.AddConvention(t => t.Namespace == "MyMessages");
builder.AddAssembliesToScan(Assembly.Load("MyMessages"));
builder.AddAssembliesToScan(Assembly.Load("MyServer"));
builder.UseServiceBrokerTransport(t => {
t.ListenerQueue = "CWServiceBus_Samples_FullDuplex_Server";
t.ReturnAddress = "[//CWServiceBus/Samples/FullDuplex/Server]";
t.NumberOfWorkerThreads = 3;
t.ServiceBrokerConnectionString = "Data Source=localhost;Initial Catalog=ServiceBus;Trusted_Connection=true";
});
builder.DiagnosticsPerfCountersEnabled = true;
});
messageBus.Start();
while (true)
{
Thread.Sleep(5000);
}
}
public KafkaMessageBusIt()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var kafkaBrokers = configuration["Kafka:Brokers"];
KafkaSettings = new KafkaMessageBusSettings(kafkaBrokers)
{
ProducerConfigFactory = () => new Dictionary <string, object>
{
{ "socket.blocking.max.ms", 1 },
{ "queue.buffering.max.ms", 1 },
{ "socket.nagle.disable", true }
},
ConsumerConfigFactory = (group) => new Dictionary <string, object>
{
{ "socket.blocking.max.ms", 1 },
{ "fetch.error.backoff.ms", 1 },
{ "statistics.interval.ms", 500000 },
{ "socket.nagle.disable", true },
{ KafkaConfigKeys.Consumer.AutoOffsetReset, KafkaConfigValues.AutoOffsetReset.Earliest }
}
};
MessageBusBuilder = new MessageBusBuilder()
.WithSerializer(new JsonMessageSerializer())
.WithProviderKafka(KafkaSettings);
MessageBus = new Lazy <KafkaMessageBus>(() => (KafkaMessageBus)MessageBusBuilder.Build());
}
public async Task BasicPubSubOnTopic()
{
var concurrency = 2;
var subscribers = 2;
var topic = "test-ping";
MessageBusBuilder
.Produce <PingMessage>(x =>
{
x.DefaultTopic(topic);
// this is optional
x.WithModifier((message, sbMessage) =>
{
// set the Azure SB message ID
sbMessage.MessageId = $"ID_{message.Counter}";
// set the Azure SB message partition key
sbMessage.PartitionKey = message.Counter.ToString(CultureInfo.InvariantCulture);
});
})
.Do(builder => Enumerable.Range(0, subscribers).ToList().ForEach(i =>
{
builder.Consume <PingMessage>(x => x
.Topic(topic)
.SubscriptionName($"subscriber-{i}") // ensure subscription exists on the ServiceBus topic
.WithConsumer <PingConsumer>()
.Instances(concurrency));
}));
await BasicPubSub(concurrency, subscribers, subscribers).ConfigureAwait(false);
}
public KafkaMessageBusIt()
{
// address to the Kafka broker
var kafkaBrokers = "localhost:9092";
KafkaSettings = new KafkaMessageBusSettings(kafkaBrokers)
{
ProducerConfigFactory = () => new Dictionary <string, object>
{
{ "socket.blocking.max.ms", 1 },
{ "queue.buffering.max.ms", 1 },
{ "socket.nagle.disable", true }
},
ConsumerConfigFactory = (group) => new Dictionary <string, object>
{
{ "socket.blocking.max.ms", 1 },
{ "fetch.error.backoff.ms", 1 },
{ "statistics.interval.ms", 500000 },
{ "socket.nagle.disable", true },
{ "auto.offset.reset", "earliest" }
}
};
MessageBusBuilder = new MessageBusBuilder()
.WithSerializer(new JsonMessageSerializer())
.WithProviderKafka(KafkaSettings);
MessageBus = new Lazy <KafkaMessageBus>(() => (KafkaMessageBus)MessageBusBuilder.Build());
}
public static void Main()
{
log4net.Config.XmlConfigurator.Configure();
var container = new Container(i => {
});
messageBus = MessageBusBuilder.Initialize(builder => {
builder.ServiceLocator = new StructureMapServiceLocator(container);
builder.MessageTypeConventions.AddConvention(t => t.Namespace == "MyMessages");
builder.AddAssembliesToScan(Assembly.Load("MyMessages"));
builder.AddAssembliesToScan(Assembly.Load("MyClient"));
builder.MessageEndpointMappingCollection.Add(new CWServiceBus.Config.MessageEndpointMapping()
{
Messages = "MyMessages",
Endpoint = "[//CWServiceBus/Samples/FullDuplex/Server]",
});
builder.UseServiceBrokerTransport(t => {
t.ListenerQueue = "CWServiceBus_Samples_FullDuplex_Client";
t.ReturnAddress = "[//CWServiceBus/Samples/FullDuplex/Client]";
t.NumberOfWorkerThreads = 3;
t.ServiceBrokerConnectionString = "Data Source=localhost;Initial Catalog=ServiceBus;Trusted_Connection=true";
});
builder.DiagnosticsPerfCountersEnabled = true;
});
((IStartableMessageBus)messageBus).Start();
Run();
}
private static IMessageBus BuildMessageBus(IServiceProvider serviceProvider)
{
var domainAssembly = typeof(Startup).Assembly;
var mbb = MessageBusBuilder.Create()
.Produce <UserLeft>(x => x.DefaultTopic(x.Settings.MessageType.Name))
.Produce <UserJoined>(x => x.DefaultTopic(x.Settings.MessageType.Name))
.Produce <UserListRequested>(x => x.DefaultTopic(x.Settings.MessageType.Name))
.Produce <SendTextMessage>(x => x.DefaultTopic(x.Settings.MessageType.Name))
.Do(builder =>
{
var consumers = domainAssembly
.GetTypes()
.Where(t => t.IsClass && !t.IsAbstract)
.SelectMany(t => t.GetInterfaces(), (t, i) => new { Type = t, Interface = i })
.Where(x => x.Interface.IsGenericType && x.Interface.GetGenericTypeDefinition() == typeof(IConsumer <>))
.Select(x => new { HandlerType = x.Type, EventType = x.Interface.GetGenericArguments()[0] })
.ToList();
foreach (var consumerType in consumers)
{
builder.Consume(consumerType.EventType,
x => x.Topic(x.MessageType.Name).WithConsumer(consumerType.HandlerType));
}
})
.WithDependencyResolver(new AspNetCoreMessageBusDependencyResolver(serviceProvider))
.WithProviderMemory(new MemoryMessageBusSettings
{
EnableMessageSerialization = false
});
return(mbb.Build());
}
private IMessageBus BuildMessageBus(IServiceProvider serviceProvider)
{
// unique id across instances of this application (e.g. 1, 2, 3)
var instanceId = Configuration["InstanceId"];
var kafkaBrokers = Configuration["Kafka:Brokers"];
var instanceGroup = $"webapi-{instanceId}";
var instanceReplyTo = $"webapi-{instanceId}-response";
var messageBusBuilder = MessageBusBuilder.Create()
.Produce <GenerateThumbnailRequest>(x =>
{
// Default response timeout for this request type
//x.DefaultTimeout(TimeSpan.FromSeconds(10));
x.DefaultTopic("thumbnail-generation");
})
.ExpectRequestResponses(x =>
{
x.ReplyToTopic(instanceReplyTo);
x.Group(instanceGroup);
// Default global response timeout
x.DefaultTimeout(TimeSpan.FromSeconds(30));
})
//.WithDependencyResolverAsServiceLocator()
//.WithDependencyResolverAsAutofac()
.WithDependencyResolver(new AspNetCoreMessageBusDependencyResolver(serviceProvider))
.WithSerializer(new JsonMessageSerializer())
.WithProviderKafka(new KafkaMessageBusSettings(kafkaBrokers));
var messageBus = messageBusBuilder.Build();
return(messageBus);
}
public MessageBusBaseTest()
{
_timeZero = DateTimeOffset.Now;
_timeNow = _timeZero;
BusBuilder = MessageBusBuilder.Create()
.Produce <RequestA>(x =>
{
x.DefaultTopic("a-requests");
x.DefaultTimeout(TimeSpan.FromSeconds(TimeoutForA10));
})
.Produce <RequestB>(x =>
{
x.DefaultTopic("b-requests");
})
.ExpectRequestResponses(x =>
{
x.ReplyToTopic("app01-responses");
x.DefaultTimeout(TimeSpan.FromSeconds(TimeoutDefault20));
})
.WithDependencyResolver(new LookupDependencyResolver(t => null))
.WithSerializer(new JsonMessageSerializer())
.WithProvider(s =>
{
var bus = new MessageBusTested(s)
{
// provide current time
CurrentTimeProvider = () => _timeNow
};
return(bus);
});
_busLazy = new Lazy <MessageBusTested>(() => (MessageBusTested)BusBuilder.Build());
}
private static IMessageBus BuildMessageBus(IConfigurationRoot configuration, IComponentContext x)
{
// unique id across instances of this application (e.g. 1, 2, 3)
var instanceId = configuration["InstanceId"];
var kafkaBrokers = configuration["Kafka:Brokers"];
var instanceGroup = $"worker-{instanceId}";
var sharedGroup = "workers";
var messageBusBuilder = MessageBusBuilder
.Create()
.Handle <GenerateThumbnailRequest, GenerateThumbnailResponse>(s =>
{
s.Topic("thumbnail-generation", t =>
{
t.WithHandler <GenerateThumbnailRequestHandler>()
.Group(sharedGroup)
.Instances(3);
});
})
.WithDependencyResolver(new AutofacMessageBusDependencyResolver(x.Resolve <ILogger <AutofacMessageBusDependencyResolver> >()))
.WithSerializer(new JsonMessageSerializer())
.WithProviderKafka(new KafkaMessageBusSettings(kafkaBrokers)
{
ConsumerConfig = (config) =>
{
config.StatisticsIntervalMs = 60000;
config.AutoOffsetReset = Confluent.Kafka.AutoOffsetReset.Latest;
}
});
var messageBus = messageBusBuilder.Build();
return(messageBus);
}
public async Task BasicPubSubOnQueue()
{
var concurrency = 2;
var subscribers = 2;
var queue = "test-ping-queue";
MessageBusBuilder
.Produce <PingMessage>(x =>
{
x.DefaultQueue(queue);
// this is optional
x.WithModifier((message, sbMessage) =>
{
// set the Azure SB message ID
sbMessage.MessageId = $"ID_{message.Counter}";
// set the Azure SB message partition key
sbMessage.PartitionKey = message.Counter.ToString(CultureInfo.InvariantCulture);
});
})
.Do(builder => Enumerable.Range(0, subscribers).ToList().ForEach(i =>
{
builder.Consume <PingMessage>(x => x
.Queue(queue)
.WithConsumer <PingConsumer>()
.Instances(concurrency));
}));
await BasicPubSub(concurrency, subscribers, 1).ConfigureAwait(false);
}
public EventHubMessageBusIt()
{
_loggerFactory = NullLoggerFactory.Instance;
_logger = _loggerFactory.CreateLogger <EventHubMessageBusIt>();
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
Secrets.Load(@"..\..\..\..\..\secrets.txt");
// connection details to the Azure Event Hub
var connectionString = Secrets.Service.PopulateSecrets(configuration["Azure:EventHub"]);
var storageConnectionString = Secrets.Service.PopulateSecrets(configuration["Azure:Storage"]);
var storageContainerName = configuration["Azure:ContainerName"];
Settings = new EventHubMessageBusSettings(connectionString, storageConnectionString, storageContainerName);
MessageBusBuilder = MessageBusBuilder.Create()
.WithLoggerFacory(_loggerFactory)
.WithSerializer(new JsonMessageSerializer())
.WithProviderEventHub(Settings);
MessageBus = new Lazy <EventHubMessageBus>(() => (EventHubMessageBus)MessageBusBuilder.Build());
}
public static void Main()
{
log4net.Config.XmlConfigurator.Configure();
var container = new Container(i => {
});
var messageBus = MessageBusBuilder.Initialize(builder => {
builder.ServiceLocator = new StructureMapServiceLocator(container);
builder.MessageTypeConventions.AddConvention(t => t.Namespace == "MyMessages");
builder.AddAssembliesToScan(Assembly.Load("MyMessages"));
builder.AddAssembliesToScan(Assembly.Load("Subscriber2"));
builder.MessageEndpointMappingCollection.Add(new CWServiceBus.Config.MessageEndpointMapping()
{
Messages = "MyMessages",
Endpoint = "[//CWServiceBus/Samples/PubSub/Publisher]",
});
builder.UseServiceBrokerTransport(t => {
t.ListenerQueue = "CWServiceBus_Samples_PubSub_Subscriber2";
t.ReturnAddress = "[//CWServiceBus/Samples/PubSub/Subscriber2]";
t.NumberOfWorkerThreads = 1;
t.ServiceBrokerConnectionString = "Data Source=localhost;Initial Catalog=ServiceBus;Trusted_Connection=true";
});
});
messageBus.Start();
messageBus.Subscribe <IMyEvent>();
while (true)
{
Thread.Sleep(5000);
}
}
public void BasicReqResp()
{
// arrange
// ensure the topic has 2 partitions
var topic = "test-echo";
var echoRequestHandler = new EchoRequestHandler();
MessageBusBuilder
.Produce <EchoRequest>(x =>
{
x.DefaultTopic(topic);
})
.Handle <EchoRequest, EchoResponse>(x => x.Topic(topic)
.Group("handler") // ensure consumer group exists on the event hub
.WithHandler <EchoRequestHandler>()
.Instances(2))
.ExpectRequestResponses(x =>
{
x.ReplyToTopic("test-echo-resp");
x.Group("response-reader"); // ensure consumer group exists on the event hub
x.DefaultTimeout(TimeSpan.FromSeconds(30));
})
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(EchoRequestHandler))
{
return(echoRequestHandler);
}
throw new InvalidOperationException();
}));
var messageBus = MessageBus.Value;
// act
var requests = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new EchoRequest {
Index = i, Message = $"Echo {i}"
})
.ToList();
var responses = new List <Tuple <EchoRequest, EchoResponse> >();
requests.AsParallel().ForAll(req =>
{
var resp = messageBus.Send(req).Result;
lock (responses)
{
responses.Add(Tuple.Create(req, resp));
}
});
// assert
// all messages got back
responses.Count.Should().Be(NumberOfMessages);
responses.All(x => x.Item1.Message == x.Item2.Message).Should().BeTrue();
}
private IMessageBus BuildMessageBus(IServiceProvider serviceProvider)
{
var domainAssembly = typeof(OrderSubmittedEvent).Assembly;
var mbb = MessageBusBuilder.Create()
// declare that OrderSubmittedEvent will be produced
.Produce <OrderSubmittedEvent>(x => x.DefaultTopic(x.Settings.MessageType.Name))
// declare that OrderSubmittedEvent will be consumed by OrderSubmittedHandler
//.SubscribeTo<OrderSubmittedEvent>(x => x.Topic(x.MessageType.Name).WithSubscriber<OrderSubmittedHandler>())
// Note: we could discover messages and handlers using reflection and register them automatically
.Do(builder => domainAssembly
.GetTypes()
.Where(t => t.IsClass && !t.IsAbstract)
.SelectMany(t => t.GetInterfaces(), (t, i) => new { Type = t, Interface = i })
.Where(x => x.Interface.IsGenericType && x.Interface.GetGenericTypeDefinition() == typeof(IConsumer <>))
.Select(x => new { HandlerType = x.Type, EventType = x.Interface.GetGenericArguments()[0] })
.ToList()
.ForEach(find =>
{
builder.Consume(find.EventType, x => x.Topic(x.MessageType.Name).WithConsumer(find.HandlerType));
})
)
//.WithSerializer(new JsonMessageSerializer()) // No need to use the serializer because of `MemoryMessageBusSettings.EnableMessageSerialization = false`
.WithDependencyResolver(new AspNetCoreMessageBusDependencyResolver(serviceProvider))
.WithProviderMemory(new MemoryMessageBusSettings
{
// Do not serialize the domain events and rather pass the same instance across handlers
EnableMessageSerialization = false
});
return(mbb.Build());
}
public void Init()
{
var messageBusBuilder = new MessageBusBuilder()
.Publish <RequestA>(x =>
{
x.DefaultTopic("a-requests");
x.DefaultTimeout(TimeSpan.FromSeconds(10));
})
.Publish <RequestB>(x =>
{
x.DefaultTopic("b-requests");
})
.ExpectRequestResponses(x =>
{
x.ReplyToTopic("app01-responses");
x.DefaultTimeout(TimeSpan.FromSeconds(20));
})
.WithSerializer(new JsonMessageSerializer())
.WithProvider(s => new MessageBusTested(s));
_bus = (MessageBusTested)messageBusBuilder.Build();
// provide current time
_bus.CurrentTimeProvider = () => DateTimeOffset.UtcNow;
}
public static MessageBusBuilder AddAmqp(this MessageBusBuilder builder, Action <AmqpOptions> configureOption)
{
builder.Services.Configure(configureOption);
builder.AddPubsubProvider <AmqpPubsubProvider>()
.AddQueueProvider <AmqpQueueProvider>();
return(builder);
}
/// <summary>
/// Registers the specified assemblies.
/// </summary>
/// <param name="assemblies">The assemblies.</param>
public static void Register(IEnumerable <Assembly> assemblies)
{
var registeredTypes = new HashSet <Type>();
var builder = MessageBusBuilder.Create()
.WithDependencyResolver(new MessageBusDependencyResolver())
.WithProviderMemory(new MemoryMessageBusSettings()
{
EnableMessageSerialization = false
})
.Do(builder =>
{
assemblies.ToList().ForEach(assembly =>
{
assembly.GetTypes().Where(t => t.IsClass && !t.IsAbstract)
.SelectMany(t => t.GetInterfaces(), (t, i) => new { Type = t, Interface = i })
.Where(x => x.Interface.IsGenericType && x.Interface.GetGenericTypeDefinition() == typeof(IMessageBusConsumer <>))
.Select(x => new { HandlerType = x.Type, EventType = x.Interface.GetGenericArguments()[0] })
.ToList()
.ForEach(find =>
{
// Yeah, samples are really generic. I could not be more sarcastic about this.
if (!registeredTypes.Contains(find.EventType))
{
registeredTypes.Add(find.EventType);
builder.Produce(find.EventType, x => x.DefaultTopic(x.Settings.MessageType.Name));
}
builder.Consume(find.EventType, x => x.Topic(x.MessageType.Name).WithConsumer(find.HandlerType));
});
});
});
var mbus = new MessageBus(builder.Build(), registeredTypes);
DIContainer.Container.RegisterInstance <IMessageBus>(mbus);
}
private async Task BasicPubSub(int concurrency, int subscribers, int expectedMessageCopies)
{
// arrange
var consumersCreated = new ConcurrentBag <PingConsumer>();
var consumedMessages = new List <(PingMessage Message, string MessageId)>();
MessageBusBuilder
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f != typeof(PingConsumer))
{
throw new InvalidOperationException();
}
var pingConsumer = new PingConsumer(_loggerFactory.CreateLogger <PingConsumer>(), consumedMessages);
consumersCreated.Add(pingConsumer);
return(pingConsumer);
}));
var messageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var producedMessages = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new PingMessage {
Counter = i, Value = Guid.NewGuid()
})
.ToList();
var messageTasks = producedMessages.Select(m => messageBus.Publish(m));
// wait until all messages are sent
await Task.WhenAll(messageTasks).ConfigureAwait(false);
stopwatch.Stop();
_logger.LogInformation("Published {0} messages in {1}", producedMessages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
await WaitUntilArriving(consumedMessages);
stopwatch.Stop();
// assert
// ensure number of instances of consumers created matches
consumersCreated.Count.Should().Be(producedMessages.Count * expectedMessageCopies);
consumedMessages.Count.Should().Be(producedMessages.Count * expectedMessageCopies);
// ... the content should match
foreach (var producedMessage in producedMessages)
{
var messageCopies = consumedMessages.Count(x => x.Message.Counter == producedMessage.Counter && x.Message.Value == producedMessage.Value && x.MessageId == GetMessageId(x.Message));
messageCopies.Should().Be(expectedMessageCopies);
}
}
public void BasicPubSub()
{
// arrange
var topic = $"test-ping";
var pingConsumer = new PingConsumer();
MessageBusBuilder
.Publish <PingMessage>(x =>
{
x.DefaultTopic(topic);
})
.SubscribeTo <PingMessage>(x => x.Topic(topic)
.Group("subscriber") // ensure consumer group exists on the event hub
.WithSubscriber <PingConsumer>()
.Instances(2))
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(PingConsumer))
{
return(pingConsumer);
}
throw new InvalidOperationException();
}));
var kafkaMessageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var messages = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new PingMessage {
Counter = i, Timestamp = DateTime.UtcNow
})
.ToList();
messages
.AsParallel()
.ForAll(m => kafkaMessageBus.Publish(m).Wait());
stopwatch.Stop();
Log.InfoFormat("Published {0} messages in {1}", messages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
var messagesReceived = ConsumeFromTopic(pingConsumer);
stopwatch.Stop();
Log.InfoFormat("Consumed {0} messages in {1}", messagesReceived.Count, stopwatch.Elapsed);
// assert
// all messages got back
messagesReceived.Count.Should().Be(messages.Count);
}
private async Task BasicPubSub(int concurrency, int subscribers)
{
// arrange
var pingConsumer = new PingConsumer();
MessageBusBuilder
.WithDependencyResolver(new LookupDependencyResolver(f =>
{
if (f == typeof(PingConsumer))
{
return(pingConsumer);
}
throw new InvalidOperationException();
}));
var messageBus = MessageBus.Value;
// act
// publish
var stopwatch = Stopwatch.StartNew();
var producedMessages = Enumerable
.Range(0, NumberOfMessages)
.Select(i => new PingMessage {
Counter = i, Value = Guid.NewGuid()
})
.ToList();
var messageTasks = producedMessages.Select(m => messageBus.Publish(m));
// wait until all messages are sent
await Task.WhenAll(messageTasks).ConfigureAwait(false);
stopwatch.Stop();
Log.InfoFormat(CultureInfo.InvariantCulture, "Published {0} messages in {1}", producedMessages.Count, stopwatch.Elapsed);
// consume
stopwatch.Restart();
var consumersReceivedMessages = await ConsumeAll(pingConsumer, subscribers *producedMessages.Count);
stopwatch.Stop();
Log.InfoFormat(CultureInfo.InvariantCulture, "Consumed {0} messages in {1}", consumersReceivedMessages.Count, stopwatch.Elapsed);
// assert
// ensure number of instances of consumers created matches
consumersReceivedMessages.Count.Should().Be(subscribers * producedMessages.Count);
// ensure all messages arrived
// ... the count should match
consumersReceivedMessages.Count.Should().Be(subscribers * producedMessages.Count);
// ... the content should match
foreach (var producedMessage in producedMessages)
{
var messageCopies = consumersReceivedMessages.Count(x => x.Counter == producedMessage.Counter && x.Value == producedMessage.Value);
messageCopies.Should().Be(subscribers);
}
}
private SqlConnection GetSqlConnection()
{
IMessageBusBuilder messageBuilder = new MessageBusBuilder(this.logController, this.connectionStrings, this.serviceBusConfiguration);
IConfigurationFactory configFactory = messageBuilder.BuildConfigurationFactory();
SqlConnection sqlConnection = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["PasdcContext"].ToString());
return(sqlConnection);
}
public static MessageBusBuilder WithProviderMemory(this MessageBusBuilder mbb, MemoryMessageBusSettings providerSettings)
{
if (mbb is null)
{
throw new ArgumentNullException(nameof(mbb));
}
return(mbb.WithProvider(settings => new MemoryMessageBus(settings, providerSettings)));
}
public static MessageBusBuilder WithProviderRedis(this MessageBusBuilder mbb, RedisMessageBusSettings redisSettings)
{
if (mbb == null)
{
throw new ArgumentNullException(nameof(mbb));
}
return(mbb.WithProvider(settings => new RedisMessageBus(settings, redisSettings)));
}
public static MessageBusBuilder UseSqlServerTransport(this MessageBusBuilder builder, Action <SqlServerTransportBuilder> configure)
{
builder.TransportBuilder = new SqlServerTransportBuilder(builder);
if (configure != null)
{
configure(builder.TransportBuilder as SqlServerTransportBuilder);
}
return(builder);
}
public static MessageBusBuilder UseServiceBrokerTransport(this MessageBusBuilder builder, Action <Config.ServiceBrokerTransportBuilder> configure)
{
builder.TransportBuilder = new Config.ServiceBrokerTransportBuilder(builder);
if (configure != null)
{
configure(builder.TransportBuilder as Config.ServiceBrokerTransportBuilder);
}
return(builder);
}
public ServiceBrokerTransportBuilder(MessageBusBuilder messageBusBuilder) {
this.MessageBusBuilder = messageBusBuilder;
}
public SqlServerTransportBuilder(MessageBusBuilder messageBusBuilder)
{
this.MessageBusBuilder = messageBusBuilder;
this.MessageBusBuilder.MessageTypeConventions.AddConvention(t => t == typeof(HeaderInfo));
}
