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