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());
}
protected virtual UnsubscribeAction Connect <TMessage>(ISubscriberContext context, Consumes <TMessage> .All consumer)
where TMessage : class
{
var sink = new InstanceMessageSink <TMessage>(message => consumer.Consume);
return(context.Pipeline.ConnectToRouter(sink, () => context.SubscribedTo <TMessage>()));
}
public bool Inspect <TMessage>(InstanceMessageSink <TMessage> sink)
where TMessage : class
{
Append(string.Format("Consumed by Instance ({0})", GetMessageName <TMessage>()));
return(true);
}
protected virtual UnsubscribeAction Connect <TMessage>(ISubscriberContext context, Consumes <TMessage> .Selected consumer)
where TMessage : class
{
var sink = new InstanceMessageSink <TMessage>(message =>
{
// rock it
return(consumer.Accept(message) ? (Action <TMessage>)consumer.Consume : null);
});
return(context.Pipeline.ConnectToRouter(sink, () => context.SubscribedTo <TMessage>()));
}
private static IPipelineSink <PingMessage> SetupRouterOnly()
{
_consumer = new PerformantConsumer <PingMessage>(1500000);
var messageSink = new InstanceMessageSink <PingMessage>(message => _consumer.Consume);
var router = new MessageRouter <PingMessage>();
router.Connect(messageSink);
return(router);
}
private static MessageRouter <IConsumeContext <PingMessage> > SetupRouterOnly()
{
_consumer = new PerformantConsumer <PingMessage>(1500000);
var messageSink = new InstanceMessageSink <PingMessage>(MultipleHandlerSelector.ForHandler(
HandlerSelector.ForHandler <PingMessage>(_consumer.Consume)));
var router = new MessageRouter <IConsumeContext <PingMessage> >();
router.Connect(messageSink);
return(router);
}
public bool Inspect <TMessage>(InstanceMessageSink <TMessage> sink)
where TMessage : class
{
if (typeof(TMessage) == typeof(T))
{
Result = Result.Concat(new[] { sink as IPipelineSink <T> });
return(false);
}
return(true);
}
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, 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(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 void How_many_messages_can_the_pipe_send_per_second()
{
long count = 0;
long count2 = 0;
long limit = 2500000;
var messageSink = new InstanceMessageSink <ClaimModified>(MultipleHandlerSelector.ForHandler(
HandlerSelector.ForHandler <ClaimModified>(m => { count++; })));
var messageSink2 = new InstanceMessageSink <ClaimModified>(MultipleHandlerSelector.ForHandler(
HandlerSelector.ForHandler <ClaimModified>(m => { count2++; })));
var router = new MessageRouter <IConsumeContext <ClaimModified> >();
router.Connect(messageSink);
router.Connect(messageSink2);
var translater = new InboundConvertMessageSink <ClaimModified>(router);
var objectRouter = new MessageRouter <IConsumeContext>();
objectRouter.Connect(translater);
var pipeline = new InboundMessagePipeline(objectRouter, MockRepository.GenerateMock <IInboundPipelineConfigurator>());
var message = new ClaimModified();
var context = new ConsumeContext <ClaimModified>(ReceiveContext.Empty(), message);
for (int i = 0; i < 100; i++)
{
pipeline.Dispatch(context);
}
count = 0;
count2 = 0;
Stopwatch timer = Stopwatch.StartNew();
for (int i = 0; i < limit; i++)
{
pipeline.Dispatch(context);
}
timer.Stop();
Trace.WriteLine("Received: " + (count + count2) + ", expected " + limit * 2);
Trace.WriteLine("Elapsed Time: " + timer.ElapsedMilliseconds + "ms");
Trace.WriteLine("Messages Per Second: " + limit * 1000 / timer.ElapsedMilliseconds);
}
public UnsubscribeAction Subscribe <TMessage>(Func <TMessage, Action <TMessage> > getHandler) where TMessage : class
{
var routerConfigurator = MessageRouterConfigurator.For(_pipeline);
var router = routerConfigurator.FindOrCreate <TMessage>();
Func <TMessage, Action <TMessage> > consumer = getHandler;
var sink = new InstanceMessageSink <TMessage>(consumer);
var result = router.Connect(sink);
UnsubscribeAction remove = SubscribedTo <TMessage>();
return(() => result() && (router.SinkCount == 0) && remove());
}
private static IPipelineSink <object> SetupTwoRoutersOnly()
{
_consumer = new PerformantConsumer <PingMessage>(1500000);
var messageSink = new InstanceMessageSink <PingMessage>(message => _consumer.Consume);
var router = new MessageRouter <PingMessage>();
router.Connect(messageSink);
var translater = new MessageTranslator <object, PingMessage>(router);
var nextRouter = new MessageRouter <object>();
nextRouter.Connect(translater);
return(nextRouter);
}
private static MessageRouter <IConsumeContext> SetupTwoRoutersOnly()
{
_consumer = new PerformantConsumer <PingMessage>(1500000);
var messageSink = new InstanceMessageSink <PingMessage>(MultipleHandlerSelector.ForHandler(
HandlerSelector.ForHandler <PingMessage>(_consumer.Consume)));
var router = new MessageRouter <IConsumeContext <PingMessage> >();
router.Connect(messageSink);
var translater = new InboundConvertMessageSink <PingMessage>(router);
var nextRouter = new MessageRouter <IConsumeContext>();
nextRouter.Connect(translater);
return(nextRouter);
}
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();
}
