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 TaskRequest(string requestId, TRequest message, TimeSpan timeout, TimeoutHandler <TRequest> timeoutHandler, CancellationToken cancellationToken, IServiceBus bus, IEnumerable <IResponseHandler> handlers) { _requestId = requestId; _message = message; _timeoutHandler = timeoutHandler; _responseHandlers = new DictionaryCache <Type, ITaskResponseHandler>(x => x.ResponseType, handlers.Cast <ITaskResponseHandler>()); // this is our task, which we complete/fail/cancel as appropriate _source = new TaskCompletionSource <TRequest>(TaskCreationOptions.None); _source.Task.ContinueWith(HandleCompletion); // this is what gets called to cancel the request, cancels the task as well _cancelRequest = new CancellationTokenSource(); _cancelRequestRegistration = cancellationToken.Register(HandleCancel); // this is what we call to cancel the timeout if the request is cancelled or a handler completes _cancelTimeout = new CancellationTokenSource(); if (timeout >= TimeSpan.Zero) { Task timeoutTask = TaskHelper.Timeout(timeout, _cancelTimeout.Token); timeoutTask.ContinueWith(HandleTimeout, TaskContinuationOptions.NotOnCanceled); } _unsubscribe = SubscribeHandlers(bus); }
public void Prepare(TScenario scenario) { var decoratedSagaRepository = new SagaRepositoryTestDecorator <TSaga>(_sagaRepository, _received, _created, _sagas); _unsubscribe = scenario.InputBus.SubscribeStateMachineSaga(_stateMachine, decoratedSagaRepository); }
public void Adding_many_dynamic_and_removing_should_retain_dynamics() { var dynamicA = new FutureMessage <A>(); var dynamicB = new FutureMessage <B>(); var dynamicC = new FutureMessage <C>(); var dynamicD = new FutureMessage <D>(); UnsubscribeAction subscriptionA = RemoteBus.SubscribeHandler <A>(dynamicA.Set); UnsubscribeAction subscriptionB = RemoteBus.SubscribeHandler <B>(dynamicB.Set); UnsubscribeAction subscriptionC = RemoteBus.SubscribeHandler <C>(dynamicC.Set); UnsubscribeAction subscriptionD = RemoteBus.SubscribeHandler <D>(dynamicD.Set); LocalBus.HasSubscription <D>(8.Seconds()).Any().ShouldBeTrue("No D subscription"); try { subscriptionA().ShouldBeFalse("A static not remaining"); subscriptionB().ShouldBeFalse("B static not remaining"); subscriptionC().ShouldBeFalse("C static not remaining"); LocalBus.Publish(new A()); LocalBus.Publish(new B()); LocalBus.Publish(new C()); LocalBus.Publish(new D()); _receivedA.IsAvailable(8.Seconds()).ShouldBeTrue("A not received"); _receivedB.IsAvailable(8.Seconds()).ShouldBeTrue("B not received"); _receivedC.IsAvailable(8.Seconds()).ShouldBeTrue("C not received"); dynamicD.IsAvailable(8.Seconds()).ShouldBeTrue("D should have been received"); } finally { subscriptionD(); } }
public void Consume(OrderInsertedMessage message) { Console.WriteLine(string.Format("Hey, your order {0} is inserted.", message.OrderId)); _unsubscribeToken(); _unsubscribeToken = null; }
public void The_pipeline_should_have_insertable_items() { // two consumers, one for each type of message IndiscriminantConsumer <PingMessage> pingConsumer = new IndiscriminantConsumer <PingMessage>(); IndiscriminantConsumer <PongMessage> pongConsumer = new IndiscriminantConsumer <PongMessage>(); UnsubscribeAction pingToken = _pipeline.Subscribe(pingConsumer); UnsubscribeAction pongToken = _pipeline.Subscribe(pongConsumer); PipelineViewer.Trace(_pipeline); PingMessage pingMessage = new PingMessage(); PongMessage pongMessage = new PongMessage(); _pipeline.Dispatch(pingMessage, accept => true); _pipeline.Dispatch(pongMessage, accept => true); Assert.AreEqual(pingMessage, pingConsumer.Consumed); Assert.AreEqual(pongMessage, pongConsumer.Consumed); pingToken(); pongToken(); PipelineViewer.Trace(_pipeline); }
public void Test() { Guid ticket = Guid.NewGuid(); _subscriptionEndpoint.Send(new AddSubscriptionClient(ticket, _bus.Endpoint.Uri, _bus.Endpoint.Uri)); _counter.IncrementMessagesSent(); if (_rand.Next(0, 10) == 0) { _unsubscribeToken(); _unsubscribeToken = _bus.Subscribe(_handler); _counter.Subscribed = true; } else if (_rand.Next(0, 10) == 0) { _unsubscribeToken(); _unsubscribeToken = () => false; _counter.Subscribed = false; } if (_rand.Next(0, 10) < 4) { _bus.Publish(new SimpleMessage()); _counter.IncrementPublishCount(); } _subscriptionEndpoint.Send(new RemoveSubscriptionClient(ticket, _bus.Endpoint.Uri, _bus.Endpoint.Uri)); }
protected override void EstablishContext() { base.EstablishContext(); _ping = new PingMessage(); _future = new FutureMessage <PingMessage, Guid>(_ping.CorrelationId); _unsubscribe = RemoteBus.SubscribeHandler <PingMessage>(message => { _future.Set(message); }); RemoteBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); LocalBus.ShouldHaveRemoteSubscriptionFor <PingMessage>(); Trace.WriteLine("LocalBus"); LocalBus.OutboundPipeline.Trace(); Trace.WriteLine("RemoteBus"); RemoteBus.OutboundPipeline.Trace(); LocalBus.Publish(_ping); }
public static UnsubscribeAction ConnectToRouter <T>(this IPipelineSink <T> pipeline, IPipelineSink <T> sink, Func <bool> unsubscribe) where T : class { UnsubscribeAction result = pipeline.ConnectToRouter(sink); return(() => result() && unsubscribe()); }
public IAsyncResult BeginSend(AsyncCallback callback, object state) { _state = state; UnsubscribeAction unsubscribeToken = () => true; unsubscribeToken = SubscribeToResponseMessages(unsubscribeToken); WaitOrTimerCallback timerCallback = (s, timedOut) => { unsubscribeToken(); if (timedOut) { if (_timeoutAction != null) { _timeoutAction(); } } callback(this); }; _waitHandle = ThreadPool.RegisterWaitForSingleObject(_responseReceived, timerCallback, state, _responseTimeout, true); InvokeRequestAction(); return(this); }
public void Test() { Guid ticket = Guid.NewGuid(); _subscriptionEndpoint.Send(new AddSubscriptionClient(ticket, _bus.Endpoint.Address.Uri, _bus.Endpoint.Address.Uri)); _counter.IncrementMessagesSent(); if (_rand.Next(0, 10) == 0) { _unsubscribeToken(); _unsubscribeToken = _bus.SubscribeInstance(_handler); _counter.Subscribed = true; } else if (_rand.Next(0, 10) == 0) { _unsubscribeToken(); _unsubscribeToken = () => false; _counter.Subscribed = false; } if (_rand.Next(0, 10) < 4) { _bus.Publish(new SimpleMessage()); _counter.IncrementPublishCount(); } _subscriptionEndpoint.Send(new RemoveSubscriptionClient(ticket, _bus.Endpoint.Address.Uri, _bus.Endpoint.Address.Uri)); }
public void Should_process_the_messages_in_order_and_not_at_the_same_time() { UnsubscribeAction unsubscribeAction = LocalBus.SubscribeSaga(_sagaRepository); Guid transactionId = NewId.NextGuid(); Trace.WriteLine("Creating transaction for " + transactionId); int startValue = 1; var startConcurrentSaga = new StartConcurrentSaga { CorrelationId = transactionId, Name = "Chris", Value = startValue }; LocalBus.Publish(startConcurrentSaga); var saga = _sagaRepository.ShouldContainSaga(transactionId, 8.Seconds()); Assert.IsNotNull(saga); int nextValue = 2; var continueConcurrentSaga = new ContinueConcurrentSaga { CorrelationId = transactionId, Value = nextValue }; LocalBus.Publish(continueConcurrentSaga); saga = _sagaRepository.ShouldContainSaga(x => x.CorrelationId == transactionId && x.Value == nextValue, 8.Seconds()); Assert.IsNotNull(saga); unsubscribeAction(); Assert.AreEqual(nextValue, saga.Value); }
public void Consume(DrinkReadyMessage message) { MessageBox.Show(string.Format("Hey, {0}, your {1} is ready.", message.Name, message.Drink)); _unsubscribeToken(); _unsubscribeToken = null; }
protected virtual UnsubscribeAction Connect <TComponent, TMessage>(ISubscriberContext context) where TMessage : class where TComponent : class, Observes <TMessage, TComponent>, ISaga { MessageRouterConfigurator routerConfigurator = MessageRouterConfigurator.For(context.Pipeline); var router = routerConfigurator.FindOrCreate <TMessage>(); var instance = (Observes <TMessage, TComponent>) FastActivator <TComponent> .Create(Guid.Empty); Expression <Func <TComponent, TMessage, bool> > selector = instance.GetBindExpression(); var repository = context.Builder.GetInstance <ISagaRepository <TComponent> >(); var policy = new ExistingSagaPolicy <TComponent, TMessage>(x => false); var sink = new PropertySagaMessageSink <TComponent, TMessage>(context, context.Data as IServiceBus, repository, policy, selector); if (sink == null) { throw new ConfigurationException("Could not build the message sink for " + typeof(TComponent).FullName); } var result = router.Connect(sink); UnsubscribeAction remove = context.SubscribedTo <TMessage>(); return(() => result() && (router.SinkCount == 0) && remove()); }
public SubscriptionRouterService(IServiceBus bus, string network) { _peerUri = bus.ControlBus.Endpoint.Address.Uri; _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(fiber, scheduler, connector, _peerId, _peerUri)); x.UseSharedScheduler(); x.HandleOnPoolFiber(); }) .GetActor(); }
public void Consume(IConsumeContext <BusStatus> context) { if (!_requestId.Equals(context.RequestId)) { return; } if (_unsubscribe != null) { _unsubscribe(); } _unsubscribe = null; ITextBlock text = new TextBlock() .BeginBlock("Status URI:", _uriString) .EndBlock(); foreach (BusStatusEntry entry in context.Message.Entries) { text.BodyFormat("{0}:{1}", entry.Key, entry.Value); } text.EndBlock(); _log.Info(text.ToString()); _complete.Set(); }
protected override void EstablishContext() { base.EstablishContext(); _ping = new PingMessage(); _future = new FutureMessage<PingMessage, Guid>(_ping.CorrelationId); _unsubscribe = RemoteBus.SubscribeHandler<PingMessage>(message => { _future.Set(message); }); RemoteBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); //LocalBus.ShouldHaveRemoteSubscriptionFor<PingMessage>(); Trace.WriteLine("LocalBus"); LocalBus.OutboundPipeline.Trace(); Trace.WriteLine("RemoteBus"); RemoteBus.OutboundPipeline.Trace(); LocalBus.Publish(_ping); }
void Cleanup() { _cancelRequestRegistration.Dispose(); _unsubscribe(); _unsubscribe = () => false; }
void SubscriptionManager() { _bus = ServiceBusConfigurator.New(servicesBus => { servicesBus.ReceiveFrom("msmq://localhost/mt_subscription_ui"); servicesBus.SetObjectBuilder(_builder); servicesBus.ConfigureService <SubscriptionClientConfigurator>(client => { // need to add the ability to read from configuratino settings somehow client.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions"); }); }); _unsubscribe = _bus.Subscribe(this); _subscriptionServiceEndpoint = _builder.GetInstance <IEndpointFactory>().GetEndpoint("msmq://localhost/mt_subscriptions"); _subscriptionServiceEndpoint.Send(new CacheUpdateRequest(_bus.Endpoint.Uri)); // _timeoutRepository.TimeoutAdded += TimeoutRefreshNeeded; // _timeoutRepository.TimeoutUpdated += TimeoutRefreshNeeded; // _timeoutRepository.TimeoutRemoved += TimeoutRefreshNeeded; }
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 void Consume(OrderCanceledMessage message) { MessageBox.Show(string.Format("Hey, your order {0} is inserted has been canceled on date {1}.", message.CorrelationId, message.DataCancellazione), "Order Inserted", MessageBoxButtons.OK); _unsubscribeToken(); _unsubscribeToken = null; }
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, object instance) { var consumer = instance as TConsumer; if (consumer == null) { throw new NullReferenceException("The consumer instance cannot be null."); } var correlatedConfigurator = new InboundCorrelatedMessageRouterConfigurator(configurator.Pipeline); CorrelatedMessageRouter <IConsumeContext <TMessage>, TMessage, TKey> router = correlatedConfigurator.FindOrCreate <TMessage, TKey>(); var sink = new InstanceMessageSink <TMessage>(MultipleHandlerSelector.ForHandler( HandlerSelector.ForHandler <TMessage>(consumer.Consume))); TKey correlationId = consumer.CorrelationId; UnsubscribeAction result = router.Connect(correlationId, sink); UnsubscribeAction remove = configurator.SubscribedTo <TMessage, TKey>(correlationId); return(() => result() && (router.SinkCount(correlationId) == 0) && remove()); }
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(); }
/// <summary> /// Initializes a new instance of the <see cref="SubscriptionClient"/> class. /// </summary> /// <param name="bus">The bus.</param> /// <param name="router">The router.</param> /// <param name="subscriptionServiceUri">The subscription service URI.</param> /// <param name="startTimeout">The start timeout.</param> public SubscriptionClient(IServiceBus bus, ISubscriptionRouter 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 MulticastSubscriptionClient(IServiceBus subscriptionBus, SubscriptionRouter router) { _subscriptionBus = subscriptionBus; _router = router; _network = router.Network; _peerId = router.PeerId; _peerUri = router.PeerUri; if (_log.IsDebugEnabled) { _log.DebugFormat("Starting MulticastSubscriptionService using {0}", subscriptionBus.Endpoint.Address); } var consumerInstance = new SubscriptionMessageConsumer(_router, _network); var msmqAddress = subscriptionBus.Endpoint.Address as IMsmqEndpointAddress; if (msmqAddress == null || msmqAddress.Uri.Scheme != MulticastMsmqTransportFactory.MulticastScheme) { throw new EndpointException(subscriptionBus.Endpoint.Address.Uri, "The multicast subscription client must be used on a multicast MSMQ endpoint"); } _producer = new BusSubscriptionMessageProducer(router, subscriptionBus.Endpoint, msmqAddress.InboundUri); _unsubscribeAction = _subscriptionBus.SubscribeInstance(consumerInstance); _unsubscribeAction += _subscriptionBus.SubscribeInstance(this); }
public void Stop() { if (_scheduled != null) { _scheduled.Cancel(); _scheduled = null; } if (_scheduler != null) { _scheduler.Stop(60.Seconds()); _scheduler = null; } if (_fiber != null) { _fiber.Shutdown(60.Seconds()); } if (_unsubscribeAction != null) { _unsubscribeAction(); _unsubscribeAction = null; } }
public UnsubscribeAction SubscribedTo <T>() where T : class { UnsubscribeAction result = () => true; _subscriptionEventHandlers.Each(x => { result += x.SubscribedTo <T>(); }); return(result); }
public void Start() { _bus = ServiceLocator.Current.GetInstance <IServiceBus>("server"); _unsubscribe = _bus.Subscribe <SendEmailConsumer>(); Console.WriteLine("Service running..."); }
public ServiceBusSubscription(IServiceBus bus, IObserver <T> observer, Predicate <T> condition) { _unsubscribeAction = condition == null? bus.Subscribe <T>(observer.OnNext) : bus.Subscribe(observer.OnNext, condition); // TODO: Hook for observer.OnError? }
public void Start() { _unsubscribeToken = _bus.Subscribe(this); _distributedTask.WhenCompleted(CompleteDistributedTask); _bus.Publish(new EnlistSubTaskWorkers <TInput>()); }
private UnsubscribeAction SubscribeToResponseMessages(UnsubscribeAction unsubscribeToken) { for (int i = 0; i < _responseActions.Count; i++) { unsubscribeToken += _responseActions[i].SubscribeTo(_bus); } return(unsubscribeToken); }
public void Dispose() { if (_unsubscribe != null) { _unsubscribe(); } _unsubscribe = null; }
public UnsubscribeAction SubscribedTo <T, K>(K correlationId) where T : class, CorrelatedBy <K> { UnsubscribeAction result = () => true; _subscriptionEventHandlers.Each(x => { result += x.SubscribedTo <T, K>(correlationId); }); return(result); }
public void Subscribe() { if (unsubscribeSaga != null) { unsubscribeSaga(); } unsubscribeSaga = bus.SubscribeSaga(installerSagaRepo); }
public void Start(IServiceBus bus) { _bus = bus; _controlBus = bus.ControlBus; _unsubscribe += _controlBus.Subscribe<Acceptor<AvailableGridServiceNode>>(); _unsubscribe += _controlBus.Subscribe<Learner<AvailableGridServiceNode>>(); }
public void Start(IServiceBus bus) { _unsubscribe = () => true; foreach (var route in _routes) { _unsubscribe += route(bus); } }
public void Start(IServiceBus bus) { _unsubscribe = () => true; foreach (Func<IServiceBus, IEndpointFactory, UnsubscribeAction> route in _routes) { _unsubscribe += route(bus, _factory); } }
public UnsubscribeAction SubscribedTo <TMessage, TKey>(TKey correlationId) where TMessage : class, CorrelatedBy <TKey> { UnsubscribeAction result = () => true; _subscriptionEventHandlers.Each(x => { result += x.SubscribedTo <TMessage, TKey>(correlationId); }); return(result); }
public void OnComplete() { if (_unsubscribeAction != null) { _unsubscribeAction(); _unsubscribeAction = null; } _producer.OnComplete(); }
public void Start() { if (_log.IsInfoEnabled) _log.Info("MessageDeferralService Starting"); _unsubscribeToken = _bus.Subscribe<DeferMessageConsumer>(); _unsubscribeToken += _bus.Subscribe<TimeoutExpiredConsumer>(); if (_log.IsInfoEnabled) _log.Info("MessageDeferralService Started"); }
private void MainForm_Load(object sender, EventArgs e) { _bus = ObjectFactory.GetInstance<IServiceBus>(); _unsubscribe = _bus.Subscribe<SubTaskWorker<GenerateMandelbrotWorker, GenerateRow, RowGenerated>>(); _worker = new BackgroundWorker(); _worker.DoWork += worker_DoWork; _worker.RunWorkerCompleted += worker_RunWorkerCompleted; var task = new GenerateMandelbrotTask(_viewer.Width, _viewer.Height, 1000); _worker.RunWorkerAsync(task); }
public void A_message_is_published() { _received = new Future<A>(); _receivedB = new Future<B>(); var unsub = LocalBus.SubscribeHandler<A>(message => _received.Complete(message)); _unsubscribe = unsub += LocalBus.SubscribeHandler<B>(message => _receivedB.Complete(message)); LocalBus.Publish(new A { StringA = "ValueA", StringB = "ValueB", }); }
public void Run(StopWatch stopWatch) { stopWatch.Start(); SimpleRequestService service = new SimpleRequestService(_bus); _unsubscribeToken = _bus.Subscribe(service); CheckPoint point = stopWatch.Mark("Correlated Requests"); CheckPoint responsePoint = stopWatch.Mark("Correlated Responses"); ManagedThreadPool<CorrelatedController> pool = new ManagedThreadPool<CorrelatedController>(DoWorker, 10, 10); try { for (int index = 0; index < _attempts; index++) { CorrelatedController controller = new CorrelatedController(_bus, OnSuccess, OnTimeout); pool.Enqueue(controller); } point.Complete(_attempts); _finishedEvent.WaitOne(TimeSpan.FromSeconds(60), true); responsePoint.Complete(_timeouts + _successes); } finally { pool.Dispose(); } _unsubscribeToken(); Console.WriteLine("Attempts: {0}, Succeeded: {1}, Timeouts: {2}", _attempts, _successes, _timeouts); stopWatch.Stop(); }
public void Start() { //IServiceBus bus = ServiceLocator.Current.GetInstance<IServiceBus>(); _unsubscribeAction = _bus.Subscribe<Subscriber<CreateOrderMessage>>(); Logger.Info("Subscribing with CreateOrderSubscriber"); }
public void Start() { _unsubscribeAction = _bus.Subscribe<CashierSaga>(); }
public void Start() { _unsubscribeAction = _bus.Subscribe<DrinkPreparationSaga>(); }
public void Start() { _bus = ServiceLocator.Current.GetInstance<IServiceBus>(); _unsubscribeAction = _bus.Subscribe<DrinkPreparationSaga>(); }
void ListenToBus(IServiceBus bus) { var subscriptionEventListener = new BusSubscriptionEventListener(bus, this); _unregister += bus.Configure(x => { UnregisterAction unregisterAction = x.Register(subscriptionEventListener); return () => unregisterAction(); }); _listeners.Add(subscriptionEventListener); IServiceBus controlBus = bus.ControlBus; if (controlBus != bus) { ListenToBus(controlBus); } }
public static ISubscriptionReference Create(UnsubscribeAction unsubscribe) { return new TransientSubscriptionReference(unsubscribe); }
public void Start() { _unsubscribeToken = _bus.Subscribe<InventoryLevelService>(); }
public TransientSubscriptionReference(UnsubscribeAction unsubscribe) { _unsubscribe = unsubscribe; }
public void Start() { _unsubscribeAction = _bus.SubscribeConsumer<TicketRequestLogger>(); }
public void Start() { _unsubscribeAction = _bus.SubscribeSaga(_sagaRepository); }
public void Start() { // ninject doesn't have the brains for this one _unsubscribeAction = _bus.SubscribeSaga(_sagaRepository); }
public void Subscribe() { if (unsubscribeSaga != null) unsubscribeSaga(); unsubscribeSaga = bus.SubscribeSaga(installerSagaRepo); }
public DisposableUnsubscribeAction(UnsubscribeAction action) { _action = action; }
public PermanentSubscriptionReference(UnsubscribeAction unsubscribe) { _unsubscribe = unsubscribe; }
public void OnStop() { _unsubscribe(); _unsubscribe = () => true; }
public void Start() { _bus = ServiceLocator.Current.GetInstance<IServiceBus>("server"); _unsubscribeToken = _bus.Subscribe<InventoryLevelService>(); }
public void Add(UnsubscribeAction action) { _action += action; }