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());
}
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 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.ForHandler <TMessage>(consumer.Consume)));
return(configurator.Pipeline.ConnectToRouter(sink, () => configurator.SubscribedTo <TMessage>()));
}
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);
}
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 void Handle <TResponse>(Action <TResponse> handler)
where TResponse : class
{
var connector = new RequestHandlerSubscriptionConnector <TResponse>();
Action <TResponse> responseHandler = message =>
{
try
{
handler(message);
_request.Complete(message);
}
catch (Exception ex)
{
var exception = new RequestException("The response handler threw an exception", ex, message);
_request.Fail(exception);
}
};
_handlers.Add(
x => { return(connector.Connect(x, _requestId, HandlerSelector.ForHandler(responseHandler))); });
}
/// <summary>
/// Adds a message handler to the service bus for handling a specific type of message
/// </summary>
/// <typeparam name="T">The message type to handle, often inferred from the callback specified</typeparam>
/// <param name="bus"></param>
/// <param name="handler">The callback to invoke when messages of the specified type arrive on the service bus</param>
public static UnsubscribeAction SubscribeHandler <T>(this IServiceBus bus, Action <T> handler)
where T : class
{
return(SubscribeHandlerSelector(bus, HandlerSelector.ForHandler(handler)));
}
public HandlerSubscriptionConfiguratorImpl(Action <TMessage> handler)
{
_handler = HandlerSelector.ForHandler(handler);
}
protected ResponseHandlerBase(string requestId, SynchronizationContext synchronizationContext,
Action <TResponse> handler)
: this(requestId, synchronizationContext)
{
_handler = HandlerSelector.ForHandler(handler);
}
protected ResponseHandlerBase(string requestId, Action <TResponse> handler)
: this(requestId)
{
_handler = HandlerSelector.ForHandler(handler);
}
public HandlerWorkerConfiguratorImpl(Action <TMessage> handler)
{
_handler = HandlerSelector.ForHandler(handler);
}