/// <summary> /// Dispatch a message through the pipeline. If the message will be consumed, the accept function /// is called to allow the endpoint to acknowledge the message reception if applicable /// </summary> /// <param name="pipeline">The pipeline instance</param> /// <param name="message">The message to dispatch</param> /// <param name="acknowledge">The function to call if the message will be consumed by the pipeline</param> /// <returns>whether the message was consumed</returns> public static bool Dispatch <T>(this IInboundMessagePipeline pipeline, T message, Func <T, bool> acknowledge) where T : class { bool consumed = false; using (var bodyStream = new MemoryStream()) { ReceiveContext receiveContext = ReceiveContext.FromBodyStream(bodyStream); pipeline.Configure(x => receiveContext.SetBus(x.Bus)); var context = new ConsumeContext <T>(receiveContext, message); using (context.CreateScope()) { foreach (var consumer in pipeline.Enumerate(context)) { if (!acknowledge(message)) { return(false); } acknowledge = x => true; consumed = true; consumer(context); } } } return(consumed); }
public static UnsubscribeAction Connect <TOutput>(this IInboundMessagePipeline pipeline, IPipelineSink <IConsumeContext <TOutput> > sink) where TOutput : class { var routerConfigurator = new InboundMessageRouterConfigurator(pipeline); return(routerConfigurator.FindOrCreate <TOutput>().Connect(sink)); }
InboundPipelineConfigurator(IServiceBus bus) { _subscriptionEventHandlers = new RegistrationList <ISubscriptionEvent>(); _bus = bus; var router = new MessageRouter <IConsumeContext>(); _pipeline = new InboundMessagePipeline(router, this); }
/// <summary> /// Subscribe a component to the pipeline that handles every message /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="pipeline">The pipeline to configure</param> /// <param name="instance">The instance that will handle the messages</param> /// <returns></returns> public static UnsubscribeAction ConnectInstance <TComponent>(this IInboundMessagePipeline pipeline, TComponent instance) where TComponent : class { return(pipeline.Configure(x => { IInstanceConnector connector = InstanceConnectorCache.GetInstanceConnector <TComponent>(); return connector.Connect(x, instance); })); }
/// <summary> /// Subscribe a component type to the pipeline that is resolved from the container for each message /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="pipeline">The pipeline to configure</param> /// <returns></returns> public static UnsubscribeAction ConnectConsumer <TComponent>(this IInboundMessagePipeline pipeline) where TComponent : class, new() { return(pipeline.Configure(x => { var consumerFactory = new DelegateConsumerFactory <TComponent>(() => new TComponent()); IConsumerConnector connector = ConsumerConnectorCache.GetConsumerConnector <TComponent>(); return connector.Connect(x, consumerFactory); })); }
public static UnsubscribeAction ConnectHandler <TMessage>(this IInboundMessagePipeline pipeline, Action <TMessage> handler, Predicate <TMessage> condition) where TMessage : class { return(pipeline.Configure(x => { var connector = new HandlerSubscriptionConnector <TMessage>(); return connector.Connect(x, HandlerSelector.ForSelectiveHandler(condition, handler)); })); }
/// <summary> /// Subscribe a component type to the pipeline that is resolved from the container for each message /// </summary> /// <typeparam name="TConsumer"></typeparam> /// <param name="pipeline">The pipeline to configure</param> /// <param name="consumerFactory"></param> /// <returns></returns> public static UnsubscribeAction ConnectConsumer <TConsumer>(this IInboundMessagePipeline pipeline, Func <TConsumer> consumerFactory) where TConsumer : class { return(pipeline.Configure(x => { var factory = new DelegateConsumerFactory <TConsumer>(consumerFactory); IConsumerConnector connector = ConsumerConnectorCache.GetConsumerConnector <TConsumer>(); return connector.Connect(x, factory); })); }
public static UnsubscribeAction ConnectToRouter <TOutput>(this IInboundMessagePipeline pipeline, IPipelineSink <IConsumeContext <TOutput> > sink, Func <UnsubscribeAction> subscribedTo) where TOutput : class { var routerConfigurator = new InboundMessageRouterConfigurator(pipeline); MessageRouter <IConsumeContext <TOutput> > router = routerConfigurator.FindOrCreate <TOutput>(); UnsubscribeAction result = router.Connect(sink); UnsubscribeAction remove = subscribedTo(); return(() => result() && (router.SinkCount == 0) && remove()); }
public InboundMessageInterceptorConfigurator(IInboundMessagePipeline sink) { _sink = sink; }
public static IEnumerable <IPipelineSink <TMessage> > ShouldHaveSubscriptionFor <TMessage>(this IInboundMessagePipeline pipeline) where TMessage : class { DateTime giveUpAt = DateTime.Now + Timeout; while (DateTime.Now < giveUpAt) { var inspector = new PipelineSinkLocator <TMessage>(); pipeline.Inspect(inspector); if (inspector.Result.Count() > 0) { return(inspector.Result); } Thread.Sleep(20); } Assert.Fail("A subscription for " + typeof(TMessage).ToFriendlyName() + " was not found on the pipeline"); return(null); }
/// <summary> /// Dispatch a message through the pipeline /// </summary> /// <param name="pipeline">The pipeline instance</param> /// <param name="message">The message to dispatch</param> public static bool Dispatch <T>(this IInboundMessagePipeline pipeline, T message) where T : class { return(pipeline.Dispatch(message, x => true)); }