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)); }