public static EventActivityBinder <TInstance> Produce <TInstance, TMessage>(this EventActivityBinder <TInstance> source,
AsyncEventMessageFactory <TInstance, TMessage> messageFactory, Action <KafkaSendContext <TMessage> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return(source.Add(new ProduceActivity <TInstance, TMessage>(messageFactory, contextCallback)));
}
public RequestActivity(Request <TInstance, TRequest, TResponse> request, ServiceAddressProvider <TInstance> serviceAddressProvider,
AsyncEventMessageFactory <TInstance, TRequest> messageFactory)
: base(request)
{
_asyncMessageFactory = messageFactory;
_serviceAddressProvider = context => serviceAddressProvider(context) ?? request.Settings.ServiceAddress;
}
public ProduceActivity(EventHubNameProvider <TInstance> nameProvider,
AsyncEventMessageFactory <TInstance, TMessage> messageFactory, Action <EventHubSendContext <TMessage> > contextCallback)
{
_nameProvider = nameProvider;
_asyncMessageFactory = messageFactory;
_pipe = contextCallback != null?Pipe.Execute(contextCallback) : Pipe.Empty <EventHubSendContext <TMessage> >();
}
public static EventActivityBinder <TInstance, TData> PublishAsync <TInstance, TData, TMessage>(this EventActivityBinder <TInstance, TData> source,
AsyncEventMessageFactory <TInstance, TData, TMessage> messageFactory, Action <PublishContext <TMessage> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TMessage : class
{
return(source.Add(new PublishActivity <TInstance, TData, TMessage>(messageFactory, contextCallback)));
}
public ScheduleActivity(AsyncEventMessageFactory <TInstance, TMessage> messageFactory, Schedule <TInstance> schedule,
ScheduleTimeProvider <TInstance> timeProvider, Action <SendContext <TMessage> > contextCallback)
: this(schedule, timeProvider, contextCallback)
{
_asyncMessageFactory = messageFactory;
}
/// <summary>
/// Publishes the <see cref="Automatonymous.Contracts.RequestCompleted{TResponse}"/> event, used by the request state machine to complete pending
/// requests.
/// </summary>
/// <param name="source"></param>
/// <param name="messageFactory"></param>
/// <typeparam name="TInstance"></typeparam>
/// <typeparam name="TData"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <returns></returns>
public static EventActivityBinder <TInstance, TData> RequestCompleted <TInstance, TData, TResponse>(this EventActivityBinder <TInstance, TData> source,
AsyncEventMessageFactory <TInstance, TData, TResponse> messageFactory)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TResponse : class
{
return(source.Add(new RequestCompletedActivity <TInstance, TData, TResponse>(messageFactory)));
}
public ProduceActivity(AsyncEventMessageFactory <TInstance, TMessage> messageFactory, Action <KafkaSendContext <TMessage> > contextCallback)
: this(contextCallback)
{
_asyncMessageFactory = messageFactory;
}
public SendActivity(AsyncEventMessageFactory <TInstance, TMessage> messageFactory, Action <SendContext <TMessage> > contextCallback)
: this(Convert(contextCallback))
{
_asyncMessageFactory = messageFactory;
}
public SendActivity(DestinationAddressProvider <TInstance> destinationAddressProvider, AsyncEventMessageFactory <TInstance, TMessage> messageFactory,
Action <SendContext <TMessage> > contextCallback)
: this(messageFactory, contextCallback)
{
_destinationAddressProvider = destinationAddressProvider;
}
public RespondActivity(AsyncEventMessageFactory <TInstance, TData, TMessage> messageFactory, Action <SendContext <TMessage> > contextCallback)
: this(contextCallback)
{
_asyncMessageFactory = messageFactory;
}
public static EventActivityBinder <TInstance, TData> Schedule <TInstance, TData, TMessage>(this EventActivityBinder <TInstance, TData> source,
Schedule <TInstance, TMessage> schedule,
AsyncEventMessageFactory <TInstance, TData, TMessage> messageFactory,
ScheduleTimeProvider <TInstance, TData> timeProvider, Action <SendContext <TMessage> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TMessage : class
{
return(source.Add(new ScheduleActivity <TInstance, TData, TMessage>(messageFactory, schedule, timeProvider, contextCallback)));
}
public static EventActivityBinder <TInstance, TData> SendAsync <TInstance, TData, TMessage>(this EventActivityBinder <TInstance, TData> source,
AsyncEventMessageFactory <TInstance, TData, TMessage> messageFactory, SendContextCallback <TInstance, TData, TMessage> contextCallback)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TMessage : class
{
return(source.Add(new SendActivity <TInstance, TData, TMessage>(messageFactory, contextCallback)));
}
public static EventActivityBinder <TInstance, TData> Produce <TInstance, TData, TMessage>(this EventActivityBinder <TInstance, TData> source,
EventHubNameProvider <TInstance, TData> nameProvider, AsyncEventMessageFactory <TInstance, TData, TMessage> messageFactory,
Action <EventHubSendContext <TMessage> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TMessage : class
{
return(source.Add(new ProduceActivity <TInstance, TData, TMessage>(nameProvider, messageFactory, contextCallback)));
}
public SendActivity(AsyncEventMessageFactory <TInstance, TMessage> messageFactory, SendContextCallback <TInstance, TMessage> contextCallback)
: this(contextCallback)
{
_asyncMessageFactory = messageFactory;
}
public static EventActivityBinder <TInstance> SendAsync <TInstance, TMessage>(this EventActivityBinder <TInstance> source,
DestinationAddressProvider <TInstance> destinationAddressProvider, AsyncEventMessageFactory <TInstance, TMessage> messageFactory,
Action <SendContext <TMessage> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
return(source.Add(new SendActivity <TInstance, TMessage>(destinationAddressProvider, messageFactory, contextCallback)));
}
public static EventActivityBinder <FutureState, T> SetFutureFaulted <T, TFault>(this EventActivityBinder <FutureState, T> binder,
AsyncEventMessageFactory <FutureState, T, TFault> messageFactory)
where T : class
where TFault : class
{
return(binder.ThenAsync(context => context.Instance.SetFault(context.CreateConsumeContext(), context.Instance.CorrelationId, messageFactory)));
}
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);
}));
}
public static EventActivityBinder <FutureState, T> NotifySubscribers <T, TResponse>(this EventActivityBinder <FutureState, T> binder,
AsyncEventMessageFactory <FutureState, TResponse> asyncMessageFactory)
where T : class
where TResponse : class
{
/// <summary>
/// Send a request to the configured service endpoint, and setup the state machine to accept the response.
/// </summary>
/// <typeparam name="TInstance">The state instance type</typeparam>
/// <typeparam name="TData">The event data type</typeparam>
/// <typeparam name="TRequest">The request message type</typeparam>
/// <typeparam name="TResponse">The response message type</typeparam>
/// <param name="binder">The event binder</param>
/// <param name="request">The configured request to use</param>
/// <param name="serviceAddressProvider">A provider for the address used for the request</param>
/// <param name="messageFactory">The request message factory</param>
/// <returns></returns>
public static EventActivityBinder <TInstance, TData> Request <TInstance, TData, TRequest, TResponse>(this EventActivityBinder <TInstance, TData> binder,
Request <TInstance, TRequest, TResponse> request, ServiceAddressProvider <TInstance, TData> serviceAddressProvider,
AsyncEventMessageFactory <TInstance, TData, TRequest> messageFactory)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TRequest : class
where TResponse : class
{
ScheduleTokenId.UseTokenId <RequestTimeoutExpired <TRequest> >(x => x.RequestId);
var activity = new RequestActivity <TInstance, TData, TRequest, TResponse>(request, serviceAddressProvider, messageFactory);
return(binder.Add(activity));
}
public PublishActivity(AsyncEventMessageFactory <TInstance, TMessage> messageFactory, Action <PublishContext <TMessage> > contextCallback)
: this(contextCallback)
{
_asyncMessageFactory = messageFactory;
}
public static EventActivityBinder <TInstance> Schedule <TInstance, TMessage>(this EventActivityBinder <TInstance> source,
Schedule <TInstance, TMessage> schedule, AsyncEventMessageFactory <TInstance, TMessage> messageFactory,
Action <SendContext <TMessage> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TMessage : class
{
DateTime TimeProvider(ConsumeEventContext <TInstance> context)
{
return(DateTime.UtcNow + schedule.Delay);
}
return(source.Add(new ScheduleActivity <TInstance, TMessage>(messageFactory, schedule, TimeProvider, contextCallback)));
}
/// <summary>
/// Responds to the previosly captured request token.
/// </summary>
/// <typeparam name="TInstance"></typeparam>
/// <typeparam name="TData"></typeparam>
/// <typeparam name="TRequest"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="source"></param>
/// <param name="requestTokenFactory"></param>
/// <param name="messageFactory"></param>
/// <param name="contextCallback"></param>
/// <returns></returns>
public static EventActivityBinder <TInstance, TData> RespondToAsync <TInstance, TData, TRequest, TResponse>(this EventActivityBinder <TInstance, TData> source, AsyncRequestTokenFactory <TInstance, TData, TRequest> requestTokenFactory, AsyncEventMessageFactory <TInstance, TData, TResponse> messageFactory, Action <SendContext <TResponse> > contextCallback = null)
where TInstance : class, SagaStateMachineInstance
where TData : class
where TRequest : class
where TResponse : class
{
return(source.Add(new RespondToActivity <TInstance, TData, TRequest, TResponse>(requestTokenFactory, messageFactory, contextCallback)));
}
public static async Task <TFault> SetFault <T, TFault>(this FutureState future,
ConsumeEventContext <FutureState, T> context, Guid id, AsyncEventMessageFactory <FutureState, T, TFault> factory)
where T : class
where TFault : class
{
var timestamp = context.SentTime ?? DateTime.UtcNow;
if (future.HasPending())
{
future.Pending?.Remove(id);
}
future.Faulted ??= timestamp;
var fault = await factory(context).ConfigureAwait(false);
future.Faults[id] = new FutureMessage <TFault>(fault);
return(fault);
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="requestTokenFactory"></param>
/// <param name="messageFactory"></param>
/// <param name="contextCallback"></param>
public RespondToActivity(AsyncRequestTokenFactory <TInstance, TData, TRequest> requestTokenFactory, AsyncEventMessageFactory <TInstance, TData, TResponse> messageFactory, Action <SendContext <TResponse> > contextCallback)
{
this.requestTokenFactory = requestTokenFactory ?? throw new ArgumentNullException(nameof(requestTokenFactory));
this.messageFactory = messageFactory ?? throw new ArgumentNullException(nameof(messageFactory));
this.contextCallback = contextCallback;
}
