Example #1
0
        public void Configure(IReceiveEndpointConfigurator configurator, IConfigurationServiceProvider configurationServiceProvider)
        {
            ISagaStateMachineFactory     stateMachineFactory = configurationServiceProvider.GetRequiredService <ISagaStateMachineFactory>();
            SagaStateMachine <TInstance> stateMachine        = stateMachineFactory.CreateStateMachine <TInstance>();

            IStateMachineActivityFactory activityFactory = configurationServiceProvider.GetRequiredService <IStateMachineActivityFactory>();

            void AddStateMachineActivityFactory(ConsumeContext context)
            {
                context.GetOrAddPayload(() => activityFactory);
            }

            var repositoryFactory = configurationServiceProvider.GetRequiredService <ISagaRepositoryFactory>();
            ISagaRepository <TInstance> repository = repositoryFactory.CreateSagaRepository <TInstance>(AddStateMachineActivityFactory);
            var stateMachineConfigurator           = new StateMachineSagaConfigurator <TInstance>(stateMachine, repository, configurator);

            GetSagaDefinition(configurationServiceProvider)
            .Configure(configurator, stateMachineConfigurator);

            foreach (Action <ISagaConfigurator <TInstance> > action in _configureActions)
            {
                action(stateMachineConfigurator);
            }

            configurator.AddEndpointSpecification(stateMachineConfigurator);
        }
        public WindsorSagaScopeProvider(IKernel kernel)
        {
            _kernel       = kernel;
            _scopeActions = new List <Action <ConsumeContext> >();

            _factory = new WindsorStateMachineActivityFactory();
        }
Example #3
0
        public ImageRetrievalStateMachine(IStateMachineActivityFactory activityFactory)
        {
            _activityFactory = activityFactory;

            State(() => Pending);
            State(() => Available);
            State(() => Faulted);

            Event(() => Requested);
            Event(() => Retrieved);
            Event(() => RetrieveFailed);
            Event(() => NotFound);

            Initially(
                When(Requested)
                .Then((state, message) =>
            {
                _log.DebugFormat("Requested: {0} ({1})", message.SourceAddress, message.RequestId);

                state.Created        = DateTime.UtcNow;
                state.FirstRequested = message.Timestamp;
                state.SourceAddress  = message.SourceAddress;
                state.LocalAddress   = new Uri("urn:unknown");
            })
                .Then(() => _activityFactory.GetActivity <SendRetrieveImageCommandActivity, ImageRetrievalState>())
                .Publish((_, message) => new ImageRequestedEvent(message.RequestId, message.SourceAddress))
                .TransitionTo(Pending));

            During(Pending,
                   // this is to handle the contract of publishing the event but an existing request is
                   // already pending
                   When(Requested)
                   .Then(
                       (state, message) =>
                       { _log.DebugFormat("Pending: {0} ({1})", state.SourceAddress, message.RequestId); })
                   .Publish((_, message) => new ImageRequestedEvent(message.RequestId, message.SourceAddress)),
                   // this event is observed when the service completes the image retrieval
                   When(Retrieved)
                   .Then((state, message) =>
            {
                _log.DebugFormat("Retrieved: {0} ({1})", message.LocalAddress, state.CorrelationId);

                state.LastRetrieved = message.Timestamp;
                state.LocalAddress  = message.LocalAddress;
                state.ContentType   = message.ContentType;
                state.ContentLength = message.ContentLength;
            })
                   .TransitionTo(Available),
                   When(RetrieveFailed)
                   .Then((state, message) => state.Reason = message.Reason)
                   .TransitionTo(Faulted)
                   .Publish((_, message) => new ImageRequestFaultedEvent(message.SourceAddress, message.Reason))
                   );

            During(Available,
                   When(Requested)
                   .Then((state, message) =>
            {
                _log.DebugFormat("Available: {0} {2} ({1})", state.LocalAddress, message.RequestId,
                                 state.SourceAddress);
            })
                   .Publish((_, message) => new ImageRequestedEvent(message.RequestId, message.SourceAddress))
                   .Respond((state, message) =>
                            new ImageRequestCompletedEvent(state.ContentLength.Value, state.ContentType,
                                                           state.LocalAddress, state.SourceAddress, state.LastRetrieved.Value)));
        }
Example #4
0
 public static void Configure(Type sagaType, IReceiveEndpointConfigurator configurator, ISagaStateMachineFactory sagaStateMachineFactory,
                              ISagaRepositoryFactory repositoryFactory, IStateMachineActivityFactory activityFactory)
 {
     GetOrAdd(sagaType).Configure(configurator, sagaStateMachineFactory, repositoryFactory, activityFactory);
 }