public SubscriptionClient(IServiceBus bus, SubscriptionRouter router, Uri subscriptionServiceUri, TimeSpan startTimeout) { _bus = bus; _router = router; _subscriptionServiceUri = subscriptionServiceUri; _startTimeout = startTimeout; _network = router.Network; if (_log.IsDebugEnabled) _log.DebugFormat("Starting SubscriptionClient using {0}", subscriptionServiceUri); VerifyClientAndServiceNotOnSameEndpoint(bus); _ready.Reset(); var consumerInstance = new SubscriptionMessageConsumer(_router, _network); _unsubscribeAction = _bus.ControlBus.SubscribeInstance(consumerInstance); _unsubscribeAction += _bus.ControlBus.SubscribeContextHandler<SubscriptionRefresh>(Consume); _subscriptionEndpoint = _bus.GetEndpoint(subscriptionServiceUri); _producer = new SubscriptionServiceMessageProducer(router, _subscriptionEndpoint); WaitForSubscriptionServiceResponse(); }
public DistributorPipeline(IServiceBus bus) : base(bus) { RegisterStage("Distribute") .WithEvent<OnGetMessage>() .WithEvent<OnDeserializeTransportMessage>() .WithEvent<OnAfterDeserializeTransportMessage>() .WithEvent<OnHandleDistributeMessage>() .WithEvent<OnAfterHandleDistributeMessage>() .WithEvent<OnSerializeTransportMessage>() .WithEvent<OnAfterSerializeTransportMessage>() .WithEvent<OnDispatchTransportMessage>() .WithEvent<OnAfterDispatchTransportMessage>() .WithEvent<OnAcknowledgeMessage>() .WithEvent<OnAfterAcknowledgeMessage>(); RegisterObserver(new GetWorkMessageObserver()); RegisterObserver(new DeserializeTransportMessageObserver()); RegisterObserver(new DistributorMessageObserver()); RegisterObserver(new SerializeTransportMessageObserver()); RegisterObserver(new DispatchTransportMessageObserver()); RegisterObserver(new AcknowledgeMessageObserver()); RegisterObserver(new DistributorExceptionObserver()); // must be last }
public SimpleEventStore(IStoreSettings<IDbConnection> settings, IServiceBus serviceBus, ISerialize serializer, ISnapshotStore snapshotStore) { _settings = settings; _serviceBus = serviceBus; _serializer = serializer; _snapshotStore = snapshotStore; }
public ThreadPoolConsumerPool(IServiceBus bus, IObjectBuilder objectBuilder, Pipe eventAggregator, TimeSpan receiveTimeout) { _objectBuilder = objectBuilder; _receiveTimeout = receiveTimeout; _eventAggregator = eventAggregator; _bus = bus; }
public void Initialize(IServiceBus bus) { if (ServiceBusConfiguration.ServiceBusSection == null || ServiceBusConfiguration.ServiceBusSection.ForwardingRoutes == null) { return; } var factory = new MessageRouteSpecificationFactory(); foreach (MessageRouteElement mapElement in ServiceBusConfiguration.ServiceBusSection.ForwardingRoutes) { var map = messageRoutes.Find(mapElement.Uri); if (map == null) { map = new MessageRoute(bus.Configuration.QueueManager.GetQueue(mapElement.Uri)); messageRoutes.Add(map); } foreach (SpecificationElement specificationElement in mapElement) { map.AddSpecification(factory.Create(specificationElement.Name, specificationElement.Value)); } } }
public override IServiceBus GetDecoratedBus(IServiceBus bus) { if (_realBus == bus) return _bus; return base.GetDecoratedBus(bus); }
public SubscriptionRouterService(IServiceBus bus, string network) { _peerUri = bus.ControlBus.Endpoint.Address.Uri; _network = network; _peerId = CombGuid.Generate(); _observers = new List<SubscriptionObserver>(); _listeners = new List<BusSubscriptionEventListener>(); _unregister = () => true; _peerUri = bus.ControlBus.Endpoint.Address.Uri; var connector = new BusSubscriptionConnector(bus); _peerCache = ActorFactory.Create<PeerCache>(x => { x.ConstructedBy((fiber, scheduler, inbox) => new PeerCache(fiber, scheduler, connector, _peerId, _peerUri)); x.UseSharedScheduler(); x.HandleOnPoolFiber(); }) .GetActor(); }
public bool Start(HostControl hostControl) { _bus = ServiceBusFactory.New(x => { x.UseRabbitMq(); x.ReceiveFrom("rabbitmq://localhost/demo/member-service"); x.Subscribe(s => { s.Consumer(() => new SaveMemberAddressConsumer()); s.Consumer(() => new AddressValidationConsumer()); s.StateMachineSaga(_stateMachine, _stateMachineRepository, c => { c.Correlate(_stateMachine.AddressAdded, (state, message) => state.OriginatingCommandId == message.CommandId) .SelectCorrelationId(message => message.EventId); c.Correlate(_stateMachine.AddressApproved, (state, message) => state.MemberId == message.MemberId); }); }); }); return true; }
public MulticastSubscriptionClient(IServiceBus subscriptionBus, Uri uri, string networkKey) { _subscriptionBus = subscriptionBus; _uri = uri; _networkKey = networkKey; }
public void Promoted(IServiceBus bus) { if (_scheduler != null && !_scheduler.IsShutdown) _scheduler.Shutdown(); _scheduler = _schedulerFactory(); _scheduler.JobFactory = new ServiceBusJobFactory(bus); _scheduler.Start(); }
public bool Start(HostControl hostControl) { var container = new Container(cfg => cfg.Scan(scan => { scan.TheCallingAssembly(); scan.AssembliesFromApplicationBaseDirectory(); scan.AddAllTypesOf(typeof (IConsumer)); })); try { _Bus = ServiceBusFactory.New(sbc => { sbc.UseRabbitMq(); sbc.ReceiveFrom(ConfigurationManager.AppSettings["RabbitMQEndPoint"]); sbc.Subscribe(x => x.LoadFrom(container)); sbc.Validate(); }); container.Inject(_Bus); } catch (Exception e) { Console.WriteLine(e.Message); return false; } return true; }
public void Stop() { _unsubscribe(); _controlBus = null; _bus = null; }
public TaskMonitoringSource(HealthMonitoringSettings settings, ILogger logger, IServiceBus serviceBus, ISubscriptionRepository repository) { _settings = settings; _logger = logger; _serviceBus = serviceBus; _repository = repository; }
public DistributedHashTable( string database, Uri url, IEndpointRouter endpointRouter, IServiceBus bus, Node metadata) { Url = url; this.endpointRouter = endpointRouter; this.bus = bus; Metadata = metadata; if (Metadata != null) // sole node in the network, probably { Metadata.ExecuteSync(uri => { ServiceUtil.Execute<IDistributedHashTableMetaDataProvider>(uri, srv => { failOver = srv.GetNodeByUri(url); }); }); } try { hashTable = new PersistentHashTable(database); hashTable.Initialize(); } catch (Exception) { hashTable.Dispose(); throw; } }
public void SetUp() { // Need to do something about this. Little ridiculous FubuTransport.SetupForInMemoryTesting(); TestMessageRecorder.Clear(); MessageHistory.ClearAll(); InMemoryQueueManager.ClearAll(); runtime = FubuTransport.For<DelayedRegistry>().StructureMap(new Container()) .Bootstrap(); theServiceBus = runtime.Factory.Get<IServiceBus>(); theClock = runtime.Factory.Get<ISystemTime>().As<SettableClock>(); message1 = new OneMessage(); message2 = new OneMessage(); message3 = new OneMessage(); message4 = new OneMessage(); theServiceBus.DelaySend(message1, theClock.UtcNow().AddHours(1)); theServiceBus.DelaySend(message2, theClock.UtcNow().AddHours(1)); theServiceBus.DelaySend(message3, theClock.UtcNow().AddHours(2)); theServiceBus.DelaySend(message4, theClock.UtcNow().AddHours(2)); }
/// <summary> /// Initializes a new instance of the <see cref="BusSubscriptionConnector"/> class. /// </summary> /// <param name="bus">The bus.</param> public BusSubscriptionConnector(IServiceBus bus) { _dataBusSubscriptionCache = new EndpointSubscriptionConnectorCache(bus); _controlBusSubscriptionCache = new EndpointSubscriptionConnectorCache(bus.ControlBus); _connectionCache = new ConcurrentCache<Guid, UnsubscribeAction>(); }
public TodoModule(IAppSettings appSettings, ITodoService todoService, IServiceBus bus) { _todoService = todoService; _bus = bus; Post["/todo"] = _ => { var slashCommand = this.Bind<SlashCommand>(); if (slashCommand == null || slashCommand.command.Missing()) { Log.Info("Rejected an incoming slash command (unable to parse request body)."); return HttpStatusCode.BadRequest.WithReason("Unable to parse slash command."); } if (!appSettings.Get("todo:slackSlashCommandToken").Equals(slashCommand.token)) { Log.Info("Blocked an unauthorized slash command."); return HttpStatusCode.Unauthorized.WithReason("Missing or invalid token."); } if (!slashCommand.command.Equals("/todo", StringComparison.InvariantCultureIgnoreCase)) { Log.Info("Rejected an incoming slash command ({0} is not handled by this module).", slashCommand.command); return HttpStatusCode.BadRequest.WithReason("Unsupported slash command."); } var responseText = HandleTodo(slashCommand); if (responseText.Missing()) { return HttpStatusCode.OK; } return responseText; }; }
public void Initialize(IServiceBus serviceBus) { Guard.AgainstNull(serviceBus, "serviceBus"); AddAssertion("BeforeDequeueStream", Assertion); AddAssertion("AfterDequeueStream", Assertion); AddAssertion("AfterMessageDeserialization", Assertion); AddAssertion("BeforeEnqueueStream", Assertion); AddAssertion("AfterEnqueueStream", Assertion); AddAssertion("BeforeHandleMessage", Assertion); AddAssertion("AfterHandleMessage", Assertion); AddAssertion("BeforeRemoveMessage", Assertion); AddAssertion("AfterRemoveMessage", Assertion); serviceBus.Events.BeforeDequeueStream += (sender, e) => ThrowException("BeforeDequeueStream"); serviceBus.Events.AfterDequeueStream += (sender, e) => ThrowException("AfterDequeueStream"); serviceBus.Events.AfterMessageDeserialization += (sender, e) => ThrowException("AfterMessageDeserialization"); serviceBus.Events.BeforeEnqueueStream += (sender, e) => ThrowException("BeforeEnqueueStream"); serviceBus.Events.AfterEnqueueStream += (sender, e) => ThrowException("AfterEnqueueStream"); serviceBus.Events.BeforeHandleMessage += (sender, e) => ThrowException("BeforeHandleMessage"); serviceBus.Events.AfterHandleMessage += (sender, e) => ThrowException("AfterHandleMessage"); serviceBus.Events.BeforeRemoveMessage += (sender, e) => ThrowException("BeforeRemoveMessage"); serviceBus.Events.AfterRemoveMessage += (sender, e) => ThrowException("AfterRemoveMessage"); serviceBus.Events.PipelineReleased += PipelineReleased; }
/// <summary> /// /// </summary> /// <param name="serviceBus">The service bus on which commands are received</param> /// <param name="controlBus">The control bus for the synchronization messages between nodes</param> public void Start(IServiceBus serviceBus, IServiceBus controlBus) { _serviceBus = serviceBus; _controlBus = controlBus; _nodeState.ChangeTo<FollowerBehavior>(); }
public static void RegisterHandlers(IReadOnlyStore readOnlyStore, IServiceBus serviceBus) { _serviceBus = serviceBus; RegisterCommandHandler(new ProductListCommandHandlers()); RegisterEventHandler(new ProductListEventHandlers(readOnlyStore)); }
public override bool OnStart() { // Set the maximum number of concurrent connections ServicePointManager.DefaultConnectionLimit = 12; // For information on handling configuration changes // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357. bool result = base.OnStart(); if(result) { _bus = AzureBusInitializer.CreateBus("TestCloudSubscriber", sbc => { sbc.SetConcurrentConsumerLimit(64); sbc.Subscribe(subs => { subs.Consumer<SomethingHappenedConsumer>().Permanent(); }); }); } Trace.TraceInformation("TestCloudSubscriberWorker has been started"); return result; }
public GamingSummaryViewModel(GameController controller, IGameControlService controlService, IRegistrationService registrationService, IContestDao contestDao, IEventAggregator eventAggregator) { _controller = controller; _controlService = controlService; _registrationService = registrationService; _contestDao = contestDao; this.OpenGameSelectionCommand = _controller.OpenGameSelectionCommand; this.StartGameCommand = DelegateCommand<SequencingItem>.FromAsyncHandler(StartGame); this.MakeShotCommand = DelegateCommand<string>.FromAsyncHandler(MakeShot); this.EditShotCommand = new DelegateCommand<string>(EditShot); this.NewGameCommand = DelegateCommand.FromAsyncHandler(NewGame, CanNewGame); eventAggregator.GetEvent<GameSelected>().Subscribe((payload) => this.CurrentGame = payload); _liveBus = ServiceBusFactory.New(sbc => { sbc.UseMsmq(msmq => { msmq.UseMulticastSubscriptionClient(); msmq.VerifyMsmqConfiguration(); }); sbc.ReceiveFrom("msmq://localhost/ramp-festival_live_sender"); sbc.SetNetwork("WORKGROUP"); }); }
/// <summary> /// Call to initialize the service bus instance, including any configuration. /// </summary> /// <param name="configure">A lambda/action that does the bus configugration.</param> /// <exception cref="ConfigurationException"> /// If the bus has already been initialized by a call /// to this method.</exception> public static void Initialize(Action<ServiceBusConfigurator> configure) { if (_instance != null) throw new ConfigurationException("Bus.Instance has already been initialized. Call Shutdown first."); _instance = ServiceBusFactory.New(configure); }
public LoginController(IUserRepository userRepository, IServiceBus bus, ITranslationService translationService, IPasswordPolicy passwordPolicy) { _userRepository = userRepository; _bus = bus; _translationService = translationService; _passwordPolicy = passwordPolicy; }
public void Initialize() { XmlConfigurator.Configure(); bus = ServiceBusFactory.New(sbc => { sbc.UseMsmq(); sbc.VerifyMsmqConfiguration(); sbc.UseSubscriptionService(RuntimeServicesQueueName); sbc.UseControlBus(); sbc.UseJsonSerializer(); sbc.ReceiveFrom(QueueName); sbc.BeforeConsumingMessage(() => { }); sbc.AfterConsumingMessage(() => { }); sbc.SetConcurrentConsumerLimit(1); sbc.UseLog4Net(); sbc.Subscribe(subs => { subs.Consumer<Consumer>(); }); }); }
public SubscriptionRouterService(IServiceBus bus, SubscriptionRepository repository, string network) { _peerUri = bus.ControlBus.Endpoint.Address.Uri; _repository = repository; _network = network; _peerId = NewId.NextGuid(); _observers = new List<SubscriptionObserver>(); _listeners = new List<BusSubscriptionEventListener>(); _unregister = () => true; _peerUri = bus.ControlBus.Endpoint.Address.Uri; var connector = new BusSubscriptionConnector(bus); _peerCache = ActorFactory.Create<PeerCache>(x => { x.ConstructedBy((fiber, scheduler, inbox) => new PeerCache(connector, _peerId, _peerUri, repository)); x.UseSharedScheduler(); x.HandleOnPoolFiber(); }) .GetActor(); // at this point, existing subscriptions need to be loaded... _repository.Load(this); }
public CreateCustomerViewModel(IServiceBus bus, IEventAggregator eventAggregator) { _Bus = bus; _EventAggregator = eventAggregator; Command = new CreateNewCustomer(CombGuid.Generate(), "unknown", "unknown", "unknown", "unknown", "unknown", "305533333"); }
void Form1_Load(object sender, EventArgs e) { richTextBox1.Text += "Starting...\r\n"; _context = SynchronizationContext.Current; bus = ServiceBusFactory.New(sbc => { sbc.UseRabbitMqRouting(); sbc.ReceiveFrom("rabbitmq://localhost/mtreqresptest_server"); sbc.SetConcurrentConsumerLimit(1); sbc.Subscribe(sc => { sc.Consumer(() => { var consumer = new BasicConsumer(); consumer.Completed += ConsumerCompletedCallback; return consumer; }); }); }); richTextBox1.Text += "Started.\r\n"; }
public SendMessagePipeline(IServiceBus bus) : base(bus) { RegisterStage("Send") .WithEvent<OnPrepareMessage>() .WithEvent<OnAfterPrepareMessage>() .WithEvent<OnFindRouteForMessage>() .WithEvent<OnAfterFindRouteForMessage>() .WithEvent<OnSerializeMessage>() .WithEvent<OnAfterSerializeMessage>() .WithEvent<OnEncryptMessage>() .WithEvent<OnAfterEncryptMessage>() .WithEvent<OnCompressMessage>() .WithEvent<OnAfterCompressMessage>() .WithEvent<OnSerializeTransportMessage>() .WithEvent<OnAfterSerializeTransportMessage>() .WithEvent<OnSendMessage>() .WithEvent<OnAfterSendMessage>(); RegisterObserver(new PrepareMessageObserver()); RegisterObserver(new FindMessageRouteObserver()); RegisterObserver(new SerializeMessageObserver()); RegisterObserver(new SerializeTransportMessageObserver()); RegisterObserver(new CompressMessageObserver()); RegisterObserver(new EncryptMessageObserver()); RegisterObserver(new SendMessageObserver()); }
public WebSocketHandler(IServiceBus bus, WebSocket ws, IEventSerializator serializer, ILogger log) { _ws = ws; _queue = bus; _log = log; _serializer = serializer; }
public ControlInboxProcessorFactory(IServiceBus bus) { Guard.AgainstNull(bus, "bus"); _bus = bus; }
public void Start(IServiceBus bus) { _serviceBus = bus; _unsubscribeToken = _serviceBus.Subscribe(this); }
public EmailCommunicationCommand(IServiceBus serviceBus) : base(serviceBus) { }
public TimeoutTester(IServiceBus bus) { _bus = bus; _bus.Subscribe(this); _ticket = Guid.NewGuid(); }
/// <summary> /// Creates the peer with it's name in metadata. /// </summary> /// <param name="bus">The bus.</param> /// <param name="context">Context to put peer into</param> /// <param name="peerName">Name of the peer.</param> /// <returns>Created peer</returns> public static IPeer CreatePeer(this IServiceBus bus, string context, string peerName) { return(CreatePeer(bus, context, peerName, new Dictionary <string, string>())); }
/// <summary> /// Creates the peer with default configuration. /// </summary> /// <param name="bus">The bus.</param> /// <param name="context">Context to put peer into</param> /// <returns>Created peer</returns> public static IPeer CreatePeer(this IServiceBus bus, string context) { return(bus.CreatePeer(new PeerConfiguration(context))); }
/// <summary> /// Creates the peer with default configuration. /// </summary> /// <param name="bus">The bus.</param> /// <returns>Created peer</returns> public static IPeer CreatePeer(this IServiceBus bus) { return(bus.CreatePeer(new PeerConfiguration(string.Empty))); }
public static IEnumerable <IPipelineSink <TMessage> > ShouldHaveSubscriptionFor <TMessage>(this IServiceBus bus) where TMessage : class { return(bus.OutboundPipeline.ShouldHaveSubscriptionFor <TMessage>()); }
public SpotController(IServiceBus serviceBus) : base(serviceBus) { }
public static IEnumerable <IPipelineSink <TMessage> > ShouldHaveSagaSubscriptionFor <TSaga, TMessage>(this IServiceBus bus, Type policyType) where TMessage : class where TSaga : class, ISaga { return(bus.OutboundPipeline.ShouldHaveSubscriptionFor <TMessage>() .Where(sink => sink.GetType().Implements(typeof(SagaMessageSinkBase <TSaga, TMessage>))) .Where(sink => ((ISagaMessageSink <TSaga, TMessage>)sink).Policy.GetType().GetGenericTypeDefinition() == policyType)); }
public IBusService Create(IServiceBus bus) { return(new IntrospectionBusService()); }
public ControllerBase(IActionBus actionBus, IServiceBus serviceBus) { ActionBus = actionBus; ServiceBus = serviceBus; }
public void Stop(ITransport transport, IServiceBus serviceBus) { transport.MessageArrived -= TransportOnMessageArrived; transport.MessageProcessingCompleted -= TransportOnMessageProcessingCompleted; }
public NodeInstaller(IServiceBus bus, ISagaRepository <NodeSetupSaga> installerSagaRepo) { this.bus = bus; this.installerSagaRepo = installerSagaRepo ?? new InMemorySagaRepository <NodeSetupSaga>(); }
public CampaignController(IServiceBus serviceBus) : base(serviceBus) { }
public PingConsumer(IServiceBus bus) { this.bus = bus; }
public MemberApplicationService(IServiceBus bus) { _bus = bus; }
public MessageSender(IServiceBus bus) : this(bus, null) { }
public SessionController(IServiceBus bus, PrincipalFactory principalFactory) { this.bus = bus; this.principalFactory = principalFactory; }
public CashierService(IServiceBus bus, ISagaRepository <CashierSaga> sagaRepository) { _bus = bus; _sagaRepository = sagaRepository; }
public ProducerService(ISignalRNotifier notifier, ISignalRPublisher publisher, IServiceBus serviceBus) { _notifier = notifier; _publisher = publisher; _serviceBus = serviceBus; }
public void TestServiceBusWithRemoteKafka() { IServiceBus serviceBus = ServiceBus.Configure() .WithKafkaEndpoints <ITestMessage1>() .Named("Obvs.TestService") .AppendMessageProperties(message => new Dictionary <string, string> { { "TestProperty", "123" } }) .FilterReceivedMessages(properties => true) .ConnectToKafka(_seed2Addresses) .SerializedAsJson() .AsClientAndServer() .PublishLocally() .OnlyMessagesWithNoEndpoints() .UsingConsoleLogging() .Create(); ConcurrentBag <IMessage> messages = new ConcurrentBag <IMessage>(); // create some actions that will act as a fake services acting on incoming commands and requests Action <TestCommand> fakeService1 = command => serviceBus.PublishAsync(new TestEvent { Id = command.Id }); Action <TestRequest> fakeService2 = request => serviceBus.ReplyAsync(request, new TestResponse { Id = request.Id }); AnonymousObserver <IMessage> observer = new AnonymousObserver <IMessage>(x => { Console.WriteLine("********* " + x); messages.Add(x); }, Console.WriteLine, () => Console.WriteLine("OnCompleted")); // subscribe to all messages on the ServiceBus CompositeDisposable subscriptions = new CompositeDisposable { serviceBus.Events.Subscribe(observer), serviceBus.Commands.Subscribe(observer), serviceBus.Requests.Subscribe(observer), serviceBus.Commands.OfType <TestCommand>().Subscribe(fakeService1), serviceBus.Requests.OfType <TestRequest>().Subscribe(fakeService2) }; // send some messages serviceBus.SendAsync(new TestCommand { Id = 123 }); serviceBus.SendAsync(new TestCommand2 { Id = 123 }); serviceBus.SendAsync(new TestCommand3 { Id = 123 }); serviceBus.GetResponses(new TestRequest { Id = 456 }).Subscribe(observer); // wait some time until we think all messages have been sent and received over AMQ Thread.Sleep(TimeSpan.FromSeconds(10)); // test we got everything we expected Assert.That(messages.OfType <TestCommand>().Count() == 1, "TestCommand not received"); Assert.That(messages.OfType <TestCommand2>().Count() == 1, "TestCommand2 not received"); Assert.That(messages.OfType <TestCommand3>().Count() == 1, "TestCommand3 not received"); Assert.That(messages.OfType <TestEvent>().Count() == 1, "TestEvent not received"); Assert.That(messages.OfType <TestRequest>().Count() == 1, "TestRequest not received"); Assert.That(messages.OfType <TestResponse>().Count() == 1, "TestResponse not received"); subscriptions.Dispose(); ((IDisposable)serviceBus).Dispose(); // win! }
public void Start(IServiceBus bus) { _bus = bus; _unregisterAction = _bus.InboundPipeline.Configure(x => x.Register(this)); }
public NodeService(IServiceBus bus, ISagaRepository <TSaga> sagaRepository) { _bus = bus; _sagaRepository = sagaRepository; }
public Consumer(IServiceBus bus) { _bus = bus; }
public DefaultHostedService(IServiceBus bus) { Bus = bus.ThrowIfNull(nameof(bus)); }
public virtual IServiceBus GetDecoratedBus(IServiceBus bus) { return(new ServiceBusTestDecorator(bus, this)); }
public void Dispose() { _bus = null; _service = null; }
public InboxProcessorFactory(IServiceBus bus) { Guard.AgainstNull(bus, "bus"); this.bus = bus; }
public ServiceBus(IServiceBus <IMessage, ICommand, IEvent, IRequest, IResponse> serviceBus) { _serviceBus = serviceBus; }