public async Task Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next)
{
ConsumeEventContext <TInstance, TData> consumeContext = context.CreateConsumeContext();
var payload = context.Data as Fault;
InitializeContext <RequestFaulted <TRequest> > initializeContext = await MessageInitializerCache <RequestFaulted <TRequest> > .Initialize(new
{
context.Instance.CorrelationId,
PayloadType = TypeMetadataCache <Fault <TRequest> > .MessageTypeNames,
Payload = new
{
payload.FaultId,
payload.FaultedMessageId,
payload.Timestamp,
payload.Host,
payload.Exceptions
}
}).ConfigureAwait(false);
object message = initializeContext.Message;
await consumeContext.Publish(message, typeof(RequestFaulted)).ConfigureAwait(false);
await next.Execute(context).ConfigureAwait(false);
}
Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var message = _messageFactory(consumeContext);
return(consumeContext.Publish(message, _publishPipe));
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var message = _messageFactory?.Invoke(consumeContext) ?? await _asyncMessageFactory(consumeContext).ConfigureAwait(false);
await consumeContext.Publish(message, _publishPipe).ConfigureAwait(false);
}
protected virtual async Task SendCommand(ConsumeEventContext <FutureState, TRequest> context, IPipe <SendContext <TCommand> > pipe)
{
var command = await CreateCommand(context).ConfigureAwait(false);
if (DestinationAddress != null)
{
var endpoint = await context.GetSendEndpoint(DestinationAddress).ConfigureAwait(false);
await endpoint.Send(command, pipe).ConfigureAwait(false);
}
else
{
await context.Publish(command, pipe).ConfigureAwait(false);
}
}
public async Task Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next)
{
ConsumeEventContext <TInstance, TData> consumeContext = context.CreateConsumeContext();
InitializeContext <RequestCompleted <TData> > initializeContext = await MessageInitializerCache <RequestCompleted <TData> > .Initialize(new
{
context.Instance.CorrelationId,
InVar.Timestamp,
PayloadType = TypeMetadataCache <TData> .MessageTypeNames,
Payload = context.Data
}).ConfigureAwait(false);
object message = initializeContext.Message;
await consumeContext.Publish(message, typeof(RequestCompleted)).ConfigureAwait(false);
await next.Execute(context).ConfigureAwait(false);
}
public async Task Execute(BehaviorContext <FutureState, OrderFryShake> context, Behavior <FutureState, OrderFryShake> next)
{
ConsumeEventContext <FutureState, OrderFryShake> consumeContext = context.CreateConsumeContext();
var orderLineId = NewId.NextGuid();
await consumeContext.Publish <OrderFry>(new
{
OrderId = context.Instance.CorrelationId,
OrderLineId = orderLineId,
context.Data.Size,
__RequestId = InVar.Id,
__ResponseAddress = consumeContext.ReceiveContext.InputAddress
}, context.CancellationToken);
context.Instance.Pending.Add(orderLineId);
await next.Execute(context);
}
public async Task Execute(BehaviorContext <FutureState, SubmitOrder> context, Behavior <FutureState, SubmitOrder> next)
{
if (context.Data.Fries != null)
{
ConsumeEventContext <FutureState, SubmitOrder> consumeContext = context.CreateConsumeContext();
await Task.WhenAll(context.Data.Fries.Select(fry => consumeContext.Publish <OrderFry>(new
{
context.Data.OrderId,
OrderLineId = fry.FryId,
fry.Size,
__RequestId = InVar.Id,
__ResponseAddress = consumeContext.ReceiveContext.InputAddress
}, context.CancellationToken)));
context.Instance.Pending.UnionWith(context.Data.Fries.Select(x => x.FryId));
}
await next.Execute(context);
}
public async Task Execute(BehaviorContext <FutureState, SubmitOrder> context, Behavior <FutureState, SubmitOrder> next)
{
Burger[] burgers = context.Data.Burgers;
if (burgers != null)
{
ConsumeEventContext <FutureState, SubmitOrder> consumeContext = context.CreateConsumeContext();
await Task.WhenAll(burgers.Select(burger => consumeContext.Publish <OrderBurger>(new
{
context.Data.OrderId,
OrderLineId = burger.BurgerId,
Burger = burger,
__RequestId = InVar.Id,
__ResponseAddress = consumeContext.ReceiveContext.InputAddress
}, context.CancellationToken)));
context.Instance.Pending.UnionWith(burgers.Select(x => x.BurgerId));
}
await next.Execute(context);
}
public async Task Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next)
{
ConsumeEventContext <TInstance, TData> consumeContext = context.CreateConsumeContext();
var initializeContext = await MessageInitializerCache <RequestStarted <TData> > .Initialize(new
{
context.Instance.CorrelationId,
consumeContext.RequestId,
consumeContext.ResponseAddress,
consumeContext.FaultAddress,
consumeContext.ExpirationTime,
PayloadType = TypeMetadataCache <TData> .MessageTypeNames,
Payload = context.Data
}).ConfigureAwait(false);
object message = initializeContext.Message;
await consumeContext.Publish(message, typeof(RequestStarted)).ConfigureAwait(false);
await next.Execute(context).ConfigureAwait(false);
}
