async Task Execute(BehaviorContext <TInstance> context)
{
Guid?previousTokenId = _schedule.GetTokenId(context.Instance);
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var schedulerContext = context.GetPayload <MessageSchedulerContext>();
var message = _messageFactory?.Invoke(consumeContext) ?? await _asyncMessageFactory(consumeContext).ConfigureAwait(false);
var delay = _timeProvider(consumeContext);
ScheduledMessage <TMessage> scheduledMessage = await schedulerContext.ScheduleSend(delay, message, _sendPipe).ConfigureAwait(false);
_schedule?.SetTokenId(context.Instance, scheduledMessage.TokenId);
if (previousTokenId.HasValue)
{
Guid?messageTokenId = consumeContext.GetSchedulingTokenId();
if (!messageTokenId.HasValue || previousTokenId.Value != messageTokenId.Value)
{
await schedulerContext.CancelScheduledSend(consumeContext.ReceiveContext.InputAddress, previousTokenId.Value).ConfigureAwait(false);
}
}
}
private static CalculateCommand CreateCalculationCommand <TData>(ConsumeEventContext <CalculationInstance, TData> context)
where TData : class
{
return(new CalculateCommand {
Id = context.Instance.Id
});
}
protected override Task <OrderCompleted> CreateCompleted(ConsumeEventContext <FutureState, OrderLineCompleted> context)
{
return(Init <OrderLineCompleted, OrderCompleted>(context, new
{
LinesCompleted = context.Instance.Results.Select(x => x.Value.ToObject <OrderLineCompleted>()).ToDictionary(x => x.OrderLineId),
}));
}
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);
}
protected async Task <T> Init <TData, T>(ConsumeEventContext <FutureState, TData> context, object values = default)
where TData : class
where T : class
{
InitializeContext <T> initializeContext = await MessageInitializerCache <T> .Initialize(context.Data, context.CancellationToken);
initializeContext = await MessageInitializerCache <T> .Initialize(initializeContext, new
{
context.Instance.Canceled,
context.Instance.Completed,
context.Instance.Created,
context.Instance.Deadline,
context.Instance.Faulted,
context.Instance.Location,
});
var request = context.Instance.GetRequest <TRequest>();
if (request != null)
{
initializeContext = await MessageInitializerCache <T> .Initialize(initializeContext, request);
}
if (values != null)
{
initializeContext = await MessageInitializerCache <T> .Initialize(initializeContext, values);
}
return(initializeContext.Message);
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var message = _messageFactory?.Invoke(consumeContext) ?? await _asyncMessageFactory(consumeContext).ConfigureAwait(false);
IPipe <SendContext <TMessage> > sendPipe = _contextCallback != null
? Pipe.Execute <SendContext <TMessage> >(sendContext =>
{
_contextCallback(consumeContext, sendContext);
})
: Pipe.Empty <SendContext <TMessage> >();
if (_destinationAddressProvider != null)
{
var destinationAddress = _destinationAddressProvider(consumeContext);
var endpoint = await consumeContext.GetSendEndpoint(destinationAddress).ConfigureAwait(false);
await endpoint.Send(message, sendPipe).ConfigureAwait(false);
}
else
{
await consumeContext.Send(message, sendPipe).ConfigureAwait(false);
}
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
MessageSchedulerContext schedulerContext;
if (!((ConsumeContext)consumeContext).TryGetPayload(out schedulerContext))
{
throw new ContextException("The scheduler context could not be retrieved.");
}
var message = _messageFactory(consumeContext);
var delay = _delayProvider(consumeContext);
ScheduledMessage <TMessage> scheduledMessage = await schedulerContext.ScheduleSend(delay, message, _sendPipe).ConfigureAwait(false);
Guid?previousTokenId = _schedule.GetTokenId(context.Instance);
if (previousTokenId.HasValue)
{
await schedulerContext.CancelScheduledSend(previousTokenId.Value).ConfigureAwait(false);
}
_schedule?.SetTokenId(context.Instance, scheduledMessage.TokenId);
}
Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var requestMessage = _messageFactory(consumeContext);
return(SendRequest(context, consumeContext, requestMessage, _serviceAddressProvider(consumeContext)));
}
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 requestMessage = _messageFactory?.Invoke(consumeContext) ?? await _asyncMessageFactory(consumeContext).ConfigureAwait(false);
await SendRequest(context, consumeContext, requestMessage, _serviceAddressProvider(consumeContext)).ConfigureAwait(false);
}
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 override Task <CookOnionRings> CreateCommand(ConsumeEventContext <FutureState, OrderOnionRings> context)
{
return(context.Init <CookOnionRings>(new
{
context.Data.OrderId,
context.Data.OrderLineId,
context.Data.Quantity
}));
}
/// <summary>
/// Use when a request is received after the initial request is still awaiting completion
/// </summary>
/// <param name="binder"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static EventActivityBinder <FutureState, T> AddSubscription <T>(this EventActivityBinder <FutureState, T> binder)
where T : class
{
return(binder.Then(context =>
{
ConsumeEventContext <FutureState, T> consumeContext = context.CreateConsumeContext();
context.Instance.AddSubscription(consumeContext.ResponseAddress, consumeContext.RequestId);
}));
}
protected override Task <CookFry> CreateCommand(ConsumeEventContext <FutureState, OrderFry> context)
{
return(context.Init <CookFry>(new
{
context.Data.OrderId,
context.Data.OrderLineId,
context.Data.Size
}));
}
private Task <IChangeOrderStatus> CreateChangeOrderStatusMessage(ConsumeEventContext <OrderState, IOrderEvent> context, OrderStatus status)
{
return(context.Init <IChangeOrderStatus>(new
{
CorrelationId = context.Instance.CorrelationId,
OrderId = context.Instance.OrderId,
OrderStatusId = (byte)status
}));
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var message = _messageFactory(consumeContext);
var endpoint = await consumeContext.GetSendEndpoint(_destinationAddress).ConfigureAwait(false);
await endpoint.Send(message, _sendPipe).ConfigureAwait(false);
}
async Task Activity <TInstance, TData> .Execute(BehaviorContext <TInstance, TData> context, Behavior <TInstance, TData> next)
{
ConsumeEventContext <TInstance, TData> consumeContext = context.CreateConsumeContext();
var message = _messageFactory(consumeContext);
await consumeContext.RespondAsync(message, _responsePipe).ConfigureAwait(false);
await next.Execute(context).ConfigureAwait(false);
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var message = await _asyncMessageFactory(consumeContext).ConfigureAwait(false);
ITopicProducer <TMessage> producer = context.GetProducer <TMessage>();
await producer.Produce(message, _pipe).ConfigureAwait(false);
}
protected override Task <BurgerCompleted> CreateCompleted(ConsumeEventContext <FutureState, RoutingSlipCompleted> context)
{
var burger = context.Data.GetVariable <Burger>(nameof(BurgerCompleted.Burger));
return(Init <RoutingSlipCompleted, BurgerCompleted>(context, new
{
Burger = burger,
Description = burger.ToString()
}));
}
async Task Execute(BehaviorContext <TInstance> context)
{
ConsumeEventContext <TInstance> consumeContext = context.CreateConsumeContext();
var message = await _asyncMessageFactory(consumeContext).ConfigureAwait(false);
var producer = await context.GetProducer(consumeContext, _nameProvider(consumeContext));
await producer.Produce(message, _pipe).ConfigureAwait(false);
}
protected override Task <PourShake> CreateCommand(ConsumeEventContext <FutureState, OrderShake> context)
{
return(context.Init <PourShake>(new
{
context.Data.OrderId,
context.Data.OrderLineId,
context.Data.Flavor,
context.Data.Size
}));
}
protected override Task <OrderFaulted> CreateFaulted <T>(ConsumeEventContext <FutureState, T> context)
{
return(Init <T, OrderFaulted>(context,
new
{
LinesCompleted = context.Instance.Results.Select(x => x.Value.ToObject <OrderLineCompleted>()).ToDictionary(x => x.OrderLineId),
LinesFaulted = context.Instance.Faults.Select(x => x.Value.ToObject <Fault <OrderLine> >()).ToDictionary(x => x.Message.OrderLineId),
Exceptions = context.Instance.Faults.SelectMany(x => x.Value.ToObject <Fault>().Exceptions).ToArray()
}));
}
public static EventActivityBinder <FutureState, Fault <T> > SetFault <T>(this EventActivityBinder <FutureState, Fault <T> > binder,
Func <ConsumeEventContext <FutureState, Fault <T> >, Guid> getResultId, AsyncEventMessageFactory <FutureState, Fault <T>, Fault <T> > messageFactory)
{
return(binder.ThenAsync(context =>
{
ConsumeEventContext <FutureState, Fault <T> > consumeContext = context.CreateConsumeContext();
var resultId = getResultId(consumeContext);
return context.Instance.SetFault(consumeContext, resultId, messageFactory);
}));
}
/// <summary>
/// Set the result associated with the identifier using the message factory
/// </summary>
/// <param name="binder"></param>
/// <param name="getResultId">Should return the result identifier</param>
/// <param name="messageFactory">Should return the result message</param>
/// <typeparam name="T">The event type</typeparam>
/// <typeparam name="TResult">The result type</typeparam>
/// <returns></returns>
public static EventActivityBinder <FutureState, T> SetResult <T, TResult>(this EventActivityBinder <FutureState, T> binder,
Func <ConsumeEventContext <FutureState, T>, Guid> getResultId, EventMessageFactory <FutureState, T, TResult> messageFactory)
where T : class
where TResult : class
{
return(binder.ThenAsync(context =>
{
ConsumeEventContext <FutureState, T> consumeContext = context.CreateConsumeContext();
var resultId = getResultId(consumeContext);
return context.Instance.SetResult(consumeContext, resultId, x => Task.FromResult(messageFactory(x)));
}));
}
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);
}
}
protected virtual Task <Fault <TRequest> > CreateFaulted(ConsumeEventContext <FutureState, RoutingSlipFaulted> context)
{
var message = context.Instance.GetRequest <TRequest>();
return(context.Init <Fault <TRequest> >(new
{
FaultId = NewId.NextGuid(),
FaultedMessageId = context.Data.TrackingNumber,
FaultMessageTypes = TypeMetadataCache <TRequest> .MessageTypeNames,
context.Host,
context.Data.Timestamp,
Exceptions = context.Data.ActivityExceptions.Select(x => x.ExceptionInfo).ToArray(),
Message = message
}));
}
protected virtual Task <Fault <TRequest> > CreateFaulted(ConsumeEventContext <FutureState, Fault <TCommand> > context)
{
var message = context.Instance.GetRequest <TRequest>();
return(context.Init <Fault <TRequest> >(new
{
context.Data.FaultId,
context.Data.FaultedMessageId,
context.Data.Timestamp,
context.Data.Exceptions,
context.Data.Host,
context.Data.FaultMessageTypes,
Message = message
}));
}
protected override Task <Fault <OrderFryShake> > CreateFaulted <T>(ConsumeEventContext <FutureState, T> context)
{
var message = context.Instance.GetRequest <OrderFryShake>();
Fault <OrderLine> faulted = context.Instance.Faults.Select(x => x.Value.ToObject <Fault <OrderLine> >()).First();
return(context.Init <Fault <OrderFryShake> >(new
{
faulted.FaultId,
faulted.FaultedMessageId,
Timestamp = context.Instance.Faulted,
faulted.Exceptions,
faulted.Host,
faulted.FaultMessageTypes,
Message = message
}));
}
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, T> context, Behavior <FutureState, T> next)
{
ConsumeEventContext <FutureState, T> consumeContext = context.CreateConsumeContext();
// this will need to be done by a consumer at some point, to handle retry/fault handling
var trackingNumber = context.Instance.CorrelationId;
var builder = new RoutingSlipBuilder(trackingNumber);
builder.AddSubscription(consumeContext.ReceiveContext.InputAddress, RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
await _planner.PlanItinerary(consumeContext.Data, builder).ConfigureAwait(false);
var routingSlip = builder.Build();
await consumeContext.Execute(routingSlip).ConfigureAwait(false);
}
