/// <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 IEnumerable <Action <IConsumeContext <Distributed <TMessage> > > > Enumerate( IConsumeContext <Distributed <TMessage> > context) { if (!_worker.CanAcceptMessage(context.Message)) { return(Enumerable.Empty <Action <IConsumeContext <Distributed <TMessage> > > >()); } var payloadContext = new ConsumeContext <TMessage>(context.BaseContext, context.Message.Payload); payloadContext.SetResponseAddress(context.Message.ResponseAddress); return(_sink.Enumerate(payloadContext).Select(action => (Action <IConsumeContext <Distributed <TMessage> > >)(m => { _worker.IncrementInProgress(); try { _worker.ConsumingMessage(context.Message); using (payloadContext.CreateScope()) { action(payloadContext); } } finally { _worker.DecrementInProgress(); } }))); }
async Task ISagaRepository <TSaga> .Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) { using (var lifetimeScope = _scope.BeginLifetimeScope(_name, x => ConfigureScope(x, context))) { ConsumeContext <T> proxy = context.CreateScope(lifetimeScope); await _repository.Send(proxy, policy, next).ConfigureAwait(false); } }
public async Task Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) where T : class { using (var scope = this._services.CreateScope()) { ConsumeContext <T> proxy = context.CreateScope(scope); await this._repository.Send(proxy, policy, next).ConfigureAwait(false); } }
public async Task Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) where T : class { using (var container = _container.CreateChildContainer()) { ConsumeContext <T> proxy = context.CreateScope(container); await _repository.Send(proxy, policy, next).ConfigureAwait(false); } }
public async Task Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) where T : class { using (var scope = _container.BeginExecutionContextScope()) { ConsumeContext <T> proxy = context.CreateScope(scope); await _repository.Send(proxy, policy, next).ConfigureAwait(false); } }
async Task ISagaRepository <TSaga> .Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) { using (var lifetimeScope = _scope.BeginLifetimeScope(_name, x => ConfigureScope(x, context))) { ConsumeContext <T> proxy = context.CreateScope(lifetimeScope); proxy.GetOrAddPayload <IStateMachineActivityFactory>(() => new AutofacStateMachineActivityFactory()); await _repository.Send(proxy, policy, next).ConfigureAwait(false); } }
async Task ISagaRepository <TSaga> .Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) { using (var nestedContainer = _container.GetNestedContainer()) { ConsumeContext <T> proxy = context.CreateScope(nestedContainer); nestedContainer.Inject(proxy); await _repository.Send(proxy, policy, next).ConfigureAwait(false); } }
async Task ISagaRepository <TSaga> .Send <T>(ConsumeContext <T> context, ISagaPolicy <TSaga, T> policy, IPipe <SagaConsumeContext <TSaga, T> > next) { using (var nestedContainer = _container.GetNestedContainer()) { ConsumeContext <T> proxy = context.CreateScope(nestedContainer); nestedContainer.Configure(x => { x.For <ConsumeContext>() .Use(proxy); x.For <ConsumeContext <T> >() .Use(proxy); }); proxy.GetOrAddPayload <IStateMachineActivityFactory>(() => new StructureMapStateMachineActivityFactory()); await _repository.Send(proxy, policy, next).ConfigureAwait(false); } }