public void when_message_fails_to_deserialize_then_dead_letters_message() { var waiter = new ManualResetEventSlim(); var sender = new TopicSender(this.Settings, this.Topic); var processor = new FakeProcessor( waiter, new SubscriptionReceiver(this.Settings, this.Topic, this.Subscription), new JsonTextSerializer()); processor.Start(); var data = new JsonTextSerializer().Serialize(new Data()); data = data.Replace(typeof(Data).FullName, "Some.TypeName.Cannot.Resolve"); var stream = new MemoryStream(Encoding.UTF8.GetBytes(data)); stream.Position = 0; sender.SendAsync(() => new BrokeredMessage(stream, true)); waiter.Wait(5000); var deadReceiver = this.Settings.CreateMessageReceiver(this.Topic, this.Subscription); var deadMessage = deadReceiver.Receive(TimeSpan.FromSeconds(5)); processor.Dispose(); Assert.NotNull(deadMessage); var payload = new StreamReader(deadMessage.GetBody <Stream>()).ReadToEnd(); Assert.Contains("Some.TypeName.Cannot.Resolve", payload); }
partial void OnCreateContainer(UnityContainer container) { var metadata = container.Resolve <IMetadataProvider>(); var serializer = container.Resolve <ITextSerializer>(); // blob var blobStorageAccount = CloudStorageAccount.Parse(azureSettings.BlobStorage.ConnectionString); container.RegisterInstance <IBlobStorage>(new SqlBlobStorage("BlobStorage")); var commandBus = new CommandBus(new TopicSender(azureSettings.ServiceBus, Topics.Commands.Path), metadata, serializer); var topicSender = new TopicSender(azureSettings.ServiceBus, Topics.Events.Path); container.RegisterInstance <IMessageSender>(topicSender); var eventBus = new EventBus(topicSender, metadata, serializer); var commandProcessor = new CommandProcessor(new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, "all", false, new SubscriptionReceiverInstrumentation("all", this.instrumentationEnabled)), serializer); container.RegisterInstance <ICommandBus>(commandBus); container.RegisterInstance <IEventBus>(eventBus); container.RegisterInstance <IProcessor>("CommandProcessor", commandProcessor); RegisterRepository(container); RegisterEventProcessors(container); RegisterCommandHandlers(container, commandProcessor); }
public void when_sending_message_then_can_receive_it() { var sender = new TopicSender(this.settings, this.topic); BrokeredMessage message = null; var data = new Data { Id = Guid.NewGuid(), Title = "Foo" }; using (var receiver = new SubscriptionReceiver(this.settings, this.topic, this.subscription)) { var signal = new ManualResetEventSlim(); receiver.MessageReceived += (o, e) => { message = e.Message; signal.Set(); }; receiver.Start(); sender.Send(new BrokeredMessage(data)); signal.Wait(); } Assert.NotNull(message); var received = message.GetBody <Data>(); Assert.Equal(data.Id, received.Id); Assert.Equal(data.Title, received.Title); }
public void when_sending_message_then_can_receive_it() { var sender = new TopicSender(this.Settings, this.Topic); Data data = new Data { Id = Guid.NewGuid(), Title = "Foo" }; Data received = null; using (var receiver = new SubscriptionReceiver(this.Settings, this.Topic, this.Subscription)) { var signal = new ManualResetEventSlim(); receiver.Start( m => { received = m.GetBody <Data>(); signal.Set(); return(MessageReleaseAction.CompleteMessage); }); sender.SendAsync(() => new BrokeredMessage(data)); signal.Wait(); } Assert.NotNull(received); Assert.Equal(data.Id, received.Id); Assert.Equal(data.Title, received.Title); }
public void when_creating_processor_then_receives_from_specified_subscription() { this.sut.Initialize(); var waiter = new ManualResetEventSlim(); var handler = new Mock <IEventHandler <AnEvent> >(); var serializer = new JsonTextSerializer(); var ev = new AnEvent(); handler.Setup(x => x.Handle(It.IsAny <AnEvent>())) .Callback(() => waiter.Set()); var processor = this.sut.CreateEventProcessor("log", handler.Object, serializer); processor.Start(); var sender = new TopicSender(this.settings, this.settings.Topics.First(t => t.Path.StartsWith("conference/events")).Path); var bus = new EventBus(sender, new StandardMetadataProvider(), serializer); bus.Publish(ev); waiter.Wait(5000); handler.Verify(x => x.Handle(It.Is <AnEvent>(e => e.SourceId == ev.SourceId))); }
public void when_message_received_then_calls_process_message() { var waiter = new ManualResetEventSlim(); var sender = new TopicSender(this.Settings, this.Topic); var processor = new FakeProcessor( waiter, new SubscriptionReceiver(this.Settings, this.Topic, this.Subscription), new JsonTextSerializer()); processor.Start(); var messageId = Guid.NewGuid().ToString(); var correlationId = Guid.NewGuid().ToString(); var stream = new MemoryStream(); new JsonTextSerializer().Serialize(new StreamWriter(stream), "Foo"); stream.Position = 0; sender.SendAsync(() => new BrokeredMessage(stream, true) { MessageId = messageId, CorrelationId = correlationId }); waiter.Wait(5000); Assert.NotNull(processor.Payload); Assert.Equal(messageId, processor.MessageId); Assert.Equal(correlationId, processor.CorrelationId); }
partial void OnCreateContainer(UnityContainer container) { var metadata = container.Resolve <IMetadataProvider>(); var serializer = container.Resolve <ITextSerializer>(); // blob var blobStorageAccount = CloudStorageAccount.Parse(azureSettings.BlobStorage.ConnectionString); container.RegisterInstance <IBlobStorage>(new CloudBlobStorage(blobStorageAccount, azureSettings.BlobStorage.RootContainerName)); var commandBus = new CommandBus(new TopicSender(azureSettings.ServiceBus, Topics.Commands.Path), metadata, serializer); var eventsTopicSender = new TopicSender(azureSettings.ServiceBus, Topics.Events.Path); container.RegisterInstance <IMessageSender>("events", eventsTopicSender); container.RegisterInstance <IMessageSender>("orders", new TopicSender(azureSettings.ServiceBus, Topics.EventsOrders.Path)); container.RegisterInstance <IMessageSender>("seatsavailability", new TopicSender(azureSettings.ServiceBus, Topics.EventsAvailability.Path)); var eventBus = new EventBus(eventsTopicSender, metadata, serializer); var sessionlessCommandProcessor = new CommandProcessor(new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, Topics.Commands.Subscriptions.Sessionless, false, new SubscriptionReceiverInstrumentation(Topics.Commands.Subscriptions.Sessionless, this.instrumentationEnabled)), serializer); var seatsAvailabilityCommandProcessor = new CommandProcessor(new SessionSubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, Topics.Commands.Subscriptions.Seatsavailability, false, new SessionSubscriptionReceiverInstrumentation(Topics.Commands.Subscriptions.Seatsavailability, this.instrumentationEnabled)), serializer); var synchronousCommandBus = new SynchronousCommandBusDecorator(commandBus); container.RegisterInstance <ICommandBus>(synchronousCommandBus); container.RegisterInstance <IEventBus>(eventBus); container.RegisterInstance <IProcessor>("SessionlessCommandProcessor", sessionlessCommandProcessor); container.RegisterInstance <IProcessor>("SeatsAvailabilityCommandProcessor", seatsAvailabilityCommandProcessor); RegisterRepositories(container); RegisterEventProcessors(container); RegisterCommandHandlers(container, sessionlessCommandProcessor, seatsAvailabilityCommandProcessor); // handle order commands inline, as they do not have competition. synchronousCommandBus.Register(container.Resolve <ICommandHandler>("OrderCommandHandler")); // message log var messageLogAccount = CloudStorageAccount.Parse(azureSettings.MessageLog.ConnectionString); container.RegisterInstance <IProcessor>("EventLogger", new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Events.Path, Topics.Events.Subscriptions.Log))); container.RegisterInstance <IProcessor>("OrderEventLogger", new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.EventsOrders.Path, Topics.EventsOrders.Subscriptions.LogOrders))); container.RegisterInstance <IProcessor>("SeatsAvailabilityEventLogger", new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.EventsAvailability.Path, Topics.EventsAvailability.Subscriptions.LogAvail))); container.RegisterInstance <IProcessor>("CommandLogger", new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, Topics.Commands.Subscriptions.Log))); }
public async Task Send() { var msg = new BrokeredMessage(); var m = NamespaceManager.CreateFromConnectionString(connection); var client = Substitute.For<IBusTopicClient>(); client.Send(msg); var q = new TopicSender(Guid.NewGuid().ToString(), m, client); await q.Send(msg); client.Received().Send(msg); }
public CommandHandlerService() { serializer = new JsonSerializer(); var eventSender = new TopicSender(settings, "proto/events"); var eventBus = new EventBus(eventSender, new DummyMetadataProvider(), serializer); eventStore = new EventStore("tenant", EventStoreConnectionString, serializer, eventBus); InitializeConsumer(); InitializeCommandHandlers(); }
static void TestSendCommand() { TopicClient commandClient = TopicClient.CreateFromConnectionString(serviceBusConnectionString, commandTopicPath); TopicSender sender = new TopicSender(commandClient); //sender.Send( () => { return new BrokeredMessage( "Hello CQRS" ); } ); ITextSerializer serializer = new JsonTextSerializer(); CommandBus bus = new CommandBus(sender, serializer); bus.Send(new Envelope <ICommand>(new PlaceOrder() { ProductId = 1, Quantity = 10 })); }
public SyntheticMessageCreator(string serviceBusConnectionString, string monitoringTopicName, ILogger log) { _servicebusConnectionString = serviceBusConnectionString; _monitoringTopicName = monitoringTopicName; if (ts is null) { ts = new TopicSender(_servicebusConnectionString, _monitoringTopicName, log); } if (_logger is null) { _logger = log; } }
static void TestSendEvent() { TopicClient eventClient = TopicClient.CreateFromConnectionString(serviceBusConnectionString, orderEventTopicPath); TopicSender sender = new TopicSender(eventClient); ITextSerializer serializer = new JsonTextSerializer(); EventBus eventBus = new EventBus(sender, serializer); eventBus.Publish(new Envelope <IEvent>(new OrderPlaced() { ProductId = 1, Quantity = 2, SourceId = Guid.NewGuid() })); }
public void when_processing_throws_then_sends_message_to_dead_letter() { var failCount = 0; var waiter = new ManualResetEventSlim(); var sender = new TopicSender(this.Settings, this.Topic); var processor = new Mock <MessageProcessor>( new SubscriptionReceiver(this.Settings, this.Topic, this.Subscription), new JsonTextSerializer()) { CallBase = true }; processor.Protected() .Setup("ProcessMessage", ItExpr.IsAny <string>(), ItExpr.IsAny <object>(), ItExpr.IsAny <string>(), ItExpr.IsAny <string>()) .Callback(() => { failCount++; if (failCount == 5) { waiter.Set(); } throw new ArgumentException(); }); processor.Object.Start(); var stream = new MemoryStream(); new JsonTextSerializer().Serialize(new StreamWriter(stream), "Foo"); stream.Position = 0; sender.SendAsync(() => new BrokeredMessage(stream, true)); waiter.Wait(5000); var deadReceiver = this.Settings.CreateMessageReceiver(this.Topic, this.Subscription); var deadMessage = deadReceiver.Receive(TimeSpan.FromSeconds(5)); processor.Object.Dispose(); Assert.NotNull(deadMessage); var data = new JsonTextSerializer().Deserialize(new StreamReader(deadMessage.GetBody <Stream>())); Assert.Equal("Foo", (string)data); }
public void when_message_receivedthen_calls_process_message() { var waiter = new ManualResetEventSlim(); var sender = new TopicSender(this.Settings, this.Topic); var processor = new FakeProcessor( waiter, new SubscriptionReceiver(this.Settings, this.Topic, this.Subscription), new BinarySerializer()); processor.Start(); var stream = new MemoryStream(); new BinarySerializer().Serialize(stream, "Foo"); stream.Position = 0; sender.Send(new BrokeredMessage(stream, true)); waiter.Wait(5000); Assert.NotNull(processor.Payload); }
public void TestTopic() { var exchangeName = "test.topic"; byte queueCount = 4; ITopicSender publisher = new TopicSender(_conn, exchangeName, queueCount, confirmEnabled: true, debugEnabled: true); var sentMessageDict = new ConcurrentDictionary <string, Tuple <bool, IMessageTransportationContext> >(); publisher.OnMessageSent += (sender, e) => { sentMessageDict.TryAdd(e.Context.GetMessageId(), new Tuple <bool, IMessageTransportationContext>(false, e.Context)); }; publisher.OnMessageSendingSucceeded += (sender, e) => { sentMessageDict.AddOrUpdate(e.Context.GetMessageId(), new Tuple <bool, IMessageTransportationContext>(true, e.Context), (key, originVal) => new Tuple <bool, IMessageTransportationContext>(true, originVal.Item2)); }; int sendSequence = 0; while (true) { try { sendSequence++; if (sendSequence % 3 == 0) { var message = new Message01(new Guid("58437EDC-87B7-4995-A5C0-BB5FD0FE49E0")) { Sequence = random.Next(1, 20) }; Envelope envelopedMessage = Envelope.Create(message, $"{message.HostingFilialeId}_{Guid.NewGuid()}"); Task.Run(() => publisher.SendMessage(envelopedMessage)); } else if (sendSequence % 3 == 1) { var message = new Message02(new Guid("7AE62AF0-EB1F-49C6-8FD1-128D77C84698")); Task.Run(() => publisher.SendMessage(Envelope.Create(message, $"{message.SaleFilialeId}"))); } else { var message = new Message03(new Guid("4AE62AF0-EB1F-49C6-8FD1-128D77C84698")); Task.Run(() => publisher.SendMessage(Envelope.Create(message, $"{message.SaleFilialeId}"))); } } catch (Exception ex) { Console.WriteLine($"{ex.GetType().FullName}"); } if (sendSequence == 10000000) { Thread.Sleep(3000); Task.Run(() => { publisher.Dispose(); }); break; } } var timeout = sendSequence / 10; var executeSeconds = 0; while (sentMessageDict.Count != sendSequence || sentMessageDict.Values.Any(w => !w.Item1 && w.Item2.LastException == null)) { if (executeSeconds > timeout) { break; } Thread.Sleep(1000); executeSeconds++; } var failList = sentMessageDict.Values.Where(w => !w.Item1).ToList(); }
static partial void OnCreateContainer(UnityContainer container) { var serializer = new JsonTextSerializer(); container.RegisterInstance <ITextSerializer>(serializer); var metadata = new StandardMetadataProvider(); container.RegisterInstance <IMetadataProvider>(metadata); var instrumentationEnabled = CloudConfigurationManager.GetSetting("InstrumentationEnabled") == "true"; // command bus var settings = InfrastructureSettings.Read(HttpContext.Current.Server.MapPath(@"~\bin\Settings.xml")); if (!Conference.Common.MaintenanceMode.IsInMaintainanceMode) { new ServiceBusConfig(settings.ServiceBus).Initialize(); } var commandBus = new CommandBus(new TopicSender(settings.ServiceBus, "conference/commands"), metadata, serializer); var synchronousCommandBus = new SynchronousCommandBusDecorator(commandBus); container.RegisterInstance <ICommandBus>(synchronousCommandBus); container.RegisterInstance <ICommandHandlerRegistry>(synchronousCommandBus); // blob var blobStorageAccount = CloudStorageAccount.Parse(settings.BlobStorage.ConnectionString); container.RegisterInstance <IBlobStorage>(new CloudBlobStorage(blobStorageAccount, settings.BlobStorage.RootContainerName)); // support for inline command processing container.RegisterType <ICommandHandler, OrderCommandHandler>("OrderCommandHandler"); container.RegisterType <ICommandHandler, ThirdPartyProcessorPaymentCommandHandler>("ThirdPartyProcessorPaymentCommandHandler"); container.RegisterType <ICommandHandler, SeatAssignmentsHandler>("SeatAssignmentsHandler"); container.RegisterType <DbContext, PaymentsDbContext>("payments", new TransientLifetimeManager(), new InjectionConstructor("Payments")); container.RegisterType <IDataContext <ThirdPartyProcessorPayment>, SqlDataContext <ThirdPartyProcessorPayment> >( new TransientLifetimeManager(), new InjectionConstructor(new ResolvedParameter <Func <DbContext> >("payments"), typeof(IEventBus))); container.RegisterType <IPricingService, PricingService>(new ContainerControlledLifetimeManager()); var topicSender = new TopicSender(settings.ServiceBus, "conference/events"); container.RegisterInstance <IMessageSender>(topicSender); var eventBus = new EventBus(topicSender, metadata, serializer); container.RegisterInstance <IEventBus>(eventBus); var eventSourcingAccount = CloudStorageAccount.Parse(settings.EventSourcing.ConnectionString); var eventStore = new EventStore(eventSourcingAccount, settings.EventSourcing.OrdersTableName); container.RegisterInstance <IEventStore>(eventStore); container.RegisterInstance <IPendingEventsQueue>(eventStore); container.RegisterType <IEventStoreBusPublisher, EventStoreBusPublisher>( new ContainerControlledLifetimeManager(), new InjectionConstructor( new TopicSender(settings.ServiceBus, "conference/eventsOrders"), typeof(IPendingEventsQueue), new EventStoreBusPublisherInstrumentation("web.public - orders", instrumentationEnabled))); container.RegisterType( typeof(IEventSourcedRepository <>), typeof(AzureEventSourcedRepository <>), new ContainerControlledLifetimeManager(), new InjectionConstructor(typeof(IEventStore), typeof(IEventStoreBusPublisher), typeof(ITextSerializer), typeof(IMetadataProvider), new InjectionParameter <ObjectCache>(null))); // to satisfy the IProcessor requirements. container.RegisterType <IProcessor, PublisherProcessorAdapter>("EventStoreBusPublisher", new ContainerControlledLifetimeManager()); }
public void TestPubsub2() { var exchangeName = "test.pubsub"; var subscriberNames = new string[] { "wms", "erp" }; byte queueCount = 2; IPubsubSender publisher = new PubsubSender(_conn, exchangeName, subscriberNames, publishToExchange: true, publishToExchangeQueueCount: queueCount, debugEnabled: true); var sentMessageDict = new ConcurrentDictionary <string, Tuple <bool, IMessageTransportationContext> >(); publisher.OnMessageSent += (sender, e) => { sentMessageDict.TryAdd(e.Context.GetMessageId(), new Tuple <bool, IMessageTransportationContext>(false, e.Context)); }; publisher.OnMessageSendingSucceeded += (sender, e) => { sentMessageDict.AddOrUpdate(e.Context.GetMessageId(), new Tuple <bool, IMessageTransportationContext>(true, e.Context), (key, originVal) => new Tuple <bool, IMessageTransportationContext>(true, originVal.Item2)); }; foreach (var subscriberName in publisher.SubscriberNameQueueOrExchangeNameMapping.Keys) { var topicPublisher = new TopicSender(_conn, publisher.SubscriberNameQueueOrExchangeNameMapping[subscriberName], queueCount, sourceExchangeName: publisher.ExchangeName); } int sendSequence = 0; while (true) { try { sendSequence++; if (sendSequence % 4 != 0) { var message = new Message01(new Guid("58437EDC-87B7-4995-A5C0-BB5FD0FE49E0")) { Sequence = random.Next(1, 20) }; Envelope envelopedMessage = Envelope.Create(message, $"{message.HostingFilialeId}_{Guid.NewGuid()}"); Task.Run(() => publisher.SendMessage(envelopedMessage)); Console.WriteLine($"{sendSequence}. send Message01 sequence={message.Sequence} "); } else { var message = new Message02(new Guid("7AE62AF0-EB1F-49C6-8FD1-128D77C84698")); Task.Run(() => publisher.SendMessage(Envelope.Create(message, $"{message.SaleFilialeId}"))); Console.WriteLine($"{sendSequence}. send Message02 no sequence"); } } catch (Exception ex) { Console.WriteLine($"{ex.Message}"); } if (sendSequence == 1000) { Thread.Sleep(3000); Task.Run(() => { publisher.Dispose(); }); break; } } var timeout = sendSequence / 10; var executeSeconds = 0; while (sentMessageDict.Count != sendSequence || sentMessageDict.Values.Any(w => !w.Item1 && w.Item2.LastException == null)) { if (executeSeconds > timeout) { break; } Thread.Sleep(1000); executeSeconds++; } var failList = sentMessageDict.Values.Where(w => !w.Item1).ToList(); }
public async Task SaveBrokeredMessageNull() { var queue = new TopicSender(Guid.NewGuid().ToString(), connection); await queue.Send((BrokeredMessage)null); }
public void when_sending_message_batch_then_succeeds() { var sender = new TopicSender(this.settings, this.topic); sender.Send(new[] { new BrokeredMessage(Guid.NewGuid()), new BrokeredMessage(Guid.NewGuid()) }); }
public async Task SendThrowsMessagingException() { var msg = new BrokeredMessage(); var m = NamespaceManager.CreateFromConnectionString(connection); var first = true; var client = Substitute.For<IBusTopicClient>(); client.When(c => c.Send(msg)).Do(x => { var tmp = first; first = false; throw new MessagingException(Guid.NewGuid().ToString(), tmp, new Exception()); }); var q = new TopicSender(Guid.NewGuid().ToString(), m, client); await q.Send(msg); }
public async Task SaveObjectNull() { var queue = new TopicSender(Guid.NewGuid().ToString(), connection); await queue.Send((object)null); }
public void HandleTransientErrorNull() { this.exception = null; var ex = new MessagingException("hahaha"); var bq = new TopicSender(Guid.NewGuid().ToString(), connection); bq.TransientErrorOccured += this.Error; bq.HandleTransientError(null); Assert.IsNull(this.exception); }
partial void OnCreateContainer(IServiceCollection services, ITextSerializer serializer, IMetadataProvider metadata, ILoggerFactory loggerFactory) { var azureSettings = InfrastructureSettings.Read("Application\\Settings.xml"); var busConfig = new ServiceBusConfig(azureSettings.ServiceBus, loggerFactory); busConfig.Initialize(); // blob var blobStorageAccount = CloudStorageAccount.Parse(azureSettings.BlobStorage.ConnectionString); services.AddSingleton <IBlobStorage>(new CloudBlobStorage(blobStorageAccount, azureSettings.BlobStorage.RootContainerName, loggerFactory.CreateLogger <CloudBlobStorage>())); var topicLogger = loggerFactory.CreateLogger <TopicSender>(); var commandBus = new CommandBus(new TopicSender(azureSettings.ServiceBus, Topics.Commands.Path, topicLogger), metadata, serializer); var eventsTopicSender = new TopicSender(azureSettings.ServiceBus, Topics.Events.Path, topicLogger); services.AddSingleton <IMessageSender>(eventsTopicSender); services.AddSingleton <IMessageSender>(/*"orders", */ new TopicSender(azureSettings.ServiceBus, Topics.EventsOrders.Path, topicLogger)); services.AddSingleton <IMessageSender>(/*"seatsavailability",*/ new TopicSender(azureSettings.ServiceBus, Topics.EventsAvailability.Path, topicLogger)); var eventBus = new EventBus(eventsTopicSender, metadata, serializer); var subscriptionLogger = loggerFactory.CreateLogger <SubscriptionReceiver>(); var sessionSubscriptionLogger = loggerFactory.CreateLogger <SessionSubscriptionReceiver>(); var sessionlessCommandProcessor = new CommandProcessor(new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, Topics.Commands.Subscriptions.Sessionless, false, subscriptionLogger), serializer, loggerFactory.CreateLogger <CommandProcessor>()); var anchorsAvailabilityCommandProcessor = new CommandProcessor(new SessionSubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, Topics.Commands.Subscriptions.Anchorsavailability, false, sessionSubscriptionLogger), serializer, loggerFactory.CreateLogger <CommandProcessor>()); var synchronousCommandBus = new SynchronousCommandBusDecorator(commandBus, loggerFactory.CreateLogger <SynchronousCommandBusDecorator>()); services.AddSingleton <ICommandBus>(synchronousCommandBus); services.AddSingleton <IEventBus>(eventBus); services.AddSingleton <IProcessor>(/*"SessionlessCommandProcessor", */ sessionlessCommandProcessor); services.AddSingleton <IProcessor>(/*"AnchorsAvailabilityCommandProcessor", */ anchorsAvailabilityCommandProcessor); RegisterRepositories(services, azureSettings, loggerFactory); var serviceProvider = services.BuildServiceProvider(); RegisterEventProcessors(services, serviceProvider, busConfig, serializer, loggerFactory); var commandHandlers = serviceProvider.GetServices <ICommandHandler>().ToList(); RegisterCommandHandlers(services, commandHandlers, sessionlessCommandProcessor, anchorsAvailabilityCommandProcessor); // handle order commands inline, as they do not have competition. // TODO: Get exactly OrderCommandHandler synchronousCommandBus.Register(commandHandlers.First(s => s.GetType() == typeof(OrderCommandHandler))); // message log var messageLogAccount = CloudStorageAccount.Parse(azureSettings.MessageLog.ConnectionString); services.AddSingleton <IProcessor>(/*"EventLogger", */ new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Events.Path, Topics.Events.Subscriptions.Log, true, subscriptionLogger))); services.AddSingleton <IProcessor>(/*"OrderEventLogger", */ new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.EventsOrders.Path, Topics.EventsOrders.Subscriptions.LogOrders, true, subscriptionLogger))); services.AddSingleton <IProcessor>(/*"SeatsAvailabilityEventLogger", */ new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.EventsAvailability.Path, Topics.EventsAvailability.Subscriptions.LogAvail, true, subscriptionLogger))); services.AddSingleton <IProcessor>(/*"CommandLogger", */ new AzureMessageLogListener( new AzureMessageLogWriter(messageLogAccount, azureSettings.MessageLog.TableName), new SubscriptionReceiver(azureSettings.ServiceBus, Topics.Commands.Path, Topics.Commands.Subscriptions.Log, true, subscriptionLogger))); }
static void TestSendEvent() { TopicClient eventClient = TopicClient.CreateFromConnectionString( serviceBusConnectionString, orderEventTopicPath ); TopicSender sender = new TopicSender( eventClient ); ITextSerializer serializer = new JsonTextSerializer(); EventBus eventBus = new EventBus( sender, serializer ); eventBus.Publish( new Envelope<IEvent>( new OrderPlaced() { ProductId = 1, Quantity = 2, SourceId = Guid.NewGuid() } ) ); }
static void TestSendCommand() { TopicClient commandClient = TopicClient.CreateFromConnectionString( serviceBusConnectionString, commandTopicPath ); TopicSender sender = new TopicSender( commandClient ); //sender.Send( () => { return new BrokeredMessage( "Hello CQRS" ); } ); ITextSerializer serializer = new JsonTextSerializer(); CommandBus bus = new CommandBus( sender, serializer ); bus.Send( new Envelope<ICommand>( new PlaceOrder() { ProductId = 1, Quantity = 10 } ) ); }
public TopicController(TopicSender TopicSender) { _TopicSender = TopicSender; }