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 UnsubscribeAction Connect <TConsumer>(IInboundPipelineConfigurator configurator,
IConsumerFactory <TConsumer> consumerFactory)
where TConsumer : class
{
return(_connectors.Select(x => x.Connect(configurator, consumerFactory))
.Aggregate <UnsubscribeAction, UnsubscribeAction>(() => true, (seed, x) => () => seed() && x()));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, object instance)
{
var worker = instance as ISagaWorker <TSaga>;
ISagaMessageSink <TSaga, TMessage> sink = _connector.CreateSink();
var workerSink = new SagaWorkerMessageSink <TSaga, TMessage>(worker, sink);
return(configurator.Pipeline.ConnectToRouter(workerSink, () => configurator.SubscribedTo <Distributed <TMessage> >()));
}
UnsubscribeAction IResponseHandler.Connect(IInboundPipelineConfigurator configurator)
{
var connector = new RequestHandlerSubscriptionConnector <TResponse>();
HandlerSelector <TResponse> handler = HandlerSelector.ForContextHandler <TResponse>(HandleResponse);
return(connector.Connect(configurator, _requestId, handler));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, IWorker worker)
{
IWorkerLoad <TMessage> workerLoad = worker.GetWorkerLoad <TMessage>();
var consumerSink = new SelectedConsumerMessageSink <TConsumer, TMessage>(_consumerFactory);
var sink = new WorkerMessageSink <TMessage>(workerLoad, consumerSink);
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <Distributed <TMessage> >()));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, IDistributor distributor)
{
IWorkerAvailability <TMessage> workerAvailability = distributor.GetWorkerAvailability <TMessage>();
// TODO we need to make a saga worker availability so that we can split saga load by correlation id
IWorkerSelector <TMessage> workerSelector = _workerSelectorFactory.GetSelector <TMessage>();
var sink = new DistributorMessageSink <TMessage>(workerAvailability, workerSelector);
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <TMessage>()));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, IWorker worker)
{
IWorkerLoad <TMessage> workerLoad = worker.GetWorkerLoad <TMessage>();
ISagaPolicy <TSaga, TMessage> policy = GetPolicy();
ISagaMessageSink <TSaga, TMessage> messageSink = GetSagaMessageSink(_sagaRepository, policy);
var sink = new WorkerMessageSink <TMessage>(workerLoad, messageSink);
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <Distributed <TMessage> >()));
}
public ISubscriptionReference Connect(IInboundPipelineConfigurator configurator, IWorker worker)
{
IWorkerLoad <TMessage> workerLoad = worker.GetWorkerLoad <TMessage>();
var handlerSink = new InstanceMessageSink <TMessage>(MultipleHandlerSelector.ForHandler(_handler));
var sink = new WorkerMessageSink <TMessage>(workerLoad, handlerSink);
UnsubscribeAction unsubscribeAction = configurator.Pipeline.ConnectToRouter(sink,
() => configurator.SubscribedTo <Distributed <TMessage> >());
return(_referenceFactory(unsubscribeAction));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator)
{
var routerConfigurator = new InboundMessageRouterConfigurator(configurator.Pipeline);
MessageRouter <IConsumeContext <TMessage> > router = routerConfigurator.FindOrCreate <TMessage>();
ISagaMessageSink <TSaga, TMessage> sink = CreateSink();
UnsubscribeAction result = router.Connect(sink);
UnsubscribeAction remove = configurator.SubscribedTo <TMessage>();
return(() => result() && (router.SinkCount == 0) && remove());
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, object instance)
{
var worker = instance as IWorker <TMessage>;
if (worker == null)
{
throw new ConfigurationException("The instance is not a distributor worker");
}
var sink = new WorkerMessageSink <Distributed <TMessage> >(MultipleHandlerSelector.ForHandler(
HandlerSelector.ForSelectiveHandler <Distributed <TMessage> >(worker.Accept, worker.Consume)));
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <Distributed <TMessage> >()));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, HandlerSelector <TMessage> handler)
{
var routerConfigurator = new InboundMessageRouterConfigurator(configurator.Pipeline);
MessageRouter <IConsumeContext <TMessage> > router = routerConfigurator.FindOrCreate <TMessage>();
var sink = new InstanceMessageSink <TMessage>(MultipleHandlerSelector.ForHandler(handler));
UnsubscribeAction result = router.Connect(sink);
UnsubscribeAction remove = configurator.SubscribedTo <TMessage>();
return(() => result() && (router.SinkCount == 0) && remove());
}
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 sink = new InstanceMessageSink <TMessage>(MultipleHandlerSelector.ForHandler(
HandlerSelector.ForSelectiveHandler <TMessage>(consumer.Accept, consumer.Consume)));
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <TMessage>()));
}
public UnsubscribeAction Connect <T>(IInboundPipelineConfigurator configurator, IConsumerFactory <T> factory)
where T : class
{
var consumerFactory = factory as IConsumerFactory <TConsumer>;
if (consumerFactory == null)
{
throw new ArgumentException("The consumer factory is of an invalid type: " +
typeof(T).ToShortTypeName());
}
var sink = new ContextConsumerMessageSink <TConsumer, TMessage>(consumerFactory);
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <TMessage>()));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, string requestId,
HandlerSelector <TMessage> handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler", "The handler cannot be null.");
}
var correlatedConfigurator = new InboundRequestMessageRouterConfigurator(configurator.Pipeline);
RequestMessageRouter <IConsumeContext <TMessage>, TMessage> router =
correlatedConfigurator.FindOrCreate <TMessage>();
var sink = new InstanceMessageSink <TMessage>(MultipleHandlerSelector.ForHandler(handler));
UnsubscribeAction result = router.Connect(requestId, sink);
return(() => result() && (router.SinkCount(requestId) == 0)); // && remove();
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator, string requestId, HandlerSelector <TMessage> handler)
{
if (handler == null)
{
throw new NullReferenceException("The handler cannot be null.");
}
var correlatedConfigurator = new InboundRequestMessageRouterConfigurator(configurator.Pipeline);
RequestMessageRouter <IConsumeContext <TMessage>, TMessage> router =
correlatedConfigurator.FindOrCreate <TMessage>();
var sink = new InstanceMessageSink <TMessage>(MultipleHandlerSelector.ForHandler(handler));
UnsubscribeAction result = router.Connect(requestId, sink);
// TODO this should NOT publish a correlated subscription, in fact, do we even need to subscribe?
//UnsubscribeAction remove = configurator.SubscribedTo<TMessage>();
return(() => result() && (router.SinkCount(requestId) == 0));// && remove();
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator)
{
ISagaMessageSink <TSaga, TMessage> sink = CreateSink();
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <TMessage>()));
}
public ISubscriptionReference Subscribe(IInboundPipelineConfigurator configurator)
{
UnsubscribeAction unsubscribe = _connector.Connect(configurator);
return(_referenceFactory(unsubscribe));
}
public ISubscriptionReference Connect(IInboundPipelineConfigurator configurator, IDistributor distributor)
{
return(_referenceFactory(_messageConnector.Connect(configurator, distributor)));
}
public UnsubscribeAction Connect(IInboundPipelineConfigurator configurator)
{
return(_connectors.Select(x => x.Connect(configurator))
.Aggregate <UnsubscribeAction, UnsubscribeAction>(() => true, (seed, x) => () => seed() && x()));
}
public ISubscriptionReference Subscribe(IInboundPipelineConfigurator configurator)
{
UnsubscribeAction unsubscribe = _connector.Connect(configurator, _instance);
return _referenceFactory(unsubscribe);
}
public InboundMessagePipeline(IPipelineSink <IConsumeContext> output, IInboundPipelineConfigurator configurator)
{
_output = Atomic.Create(output);
_configurator = configurator;
}
public ISubscriptionReference Connect(IInboundPipelineConfigurator configurator, IDistributor distributor)
{
return(_referenceFactory(_connectors.Select(x => x.Connect(configurator, distributor))
.Aggregate <UnsubscribeAction, UnsubscribeAction>(() => true, (seed, x) => () => seed() && x())));
}
