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; }