Exemple #1
0
        protected async Task LoadData(StatefulIdentifier identifier, Guid correlationId)
        {
            var storedData = await _stateRepository.RetrieveStateData <ThirdPartyStateData, State>(identifier.Identifier, MachineName, null, identifier.ParentIdentifier);

            if (storedData != null)
            {
                Data            = storedData.Data;
                _created        = storedData.StateMetaData.Created;
                _modified       = storedData.StateMetaData.Modified;
                _sequenceNumber = storedData.StateMetaData.SequenceNumber;
            }
        }
Exemple #2
0
 protected virtual Task PersistData(ServiceResult result, StatefulIdentifier identifier, TData data, ServiceResponse <TResponse> response, CancellationToken cancellationToken)
 {
     return(Task.CompletedTask);
 }
Exemple #3
0
        public async Task <TResponse> Process(StatefulIdentifier identifier, TRequest request, Guid correlationId)
        {
            _statefulIdentifier = identifier;
            _correlationId      = correlationId;
            Data.Request        = request;
            await LoadData(identifier, correlationId);

            while (!_machine.IsInState(State.Terminal) && !_machine.IsInState(State.Manual) && Data.Attempts < MaxAttempts())
            {
                if (Data.Attempts > 0)
                {
                    await Task.Delay(DelayBetweenAttemptsMs());
                }

                if (_machine.CanFire(Trigger.Verify))
                {
                    await _machine.FireAsync(Trigger.Verify);
                }

                if (_machine.CanFire(Trigger.ExecuteRequest))
                {
                    await _machine.FireAsync(Trigger.ExecuteRequest);
                }

                if (_machine.CanFire(Trigger.Reset))
                {
                    await _machine.FireAsync(Trigger.Reset);
                }

                Data.Attempts++;
            }

            if (_machine.IsInState(State.Completed))
            {
                return(Data.Response);
            }

            if (AllowManualOverride())
            {
                if (_machine.CanFire(Trigger.ToManual))
                {
                    await _machine.FireAsync(Trigger.ToManual);
                }
                else
                {
                    if (_machine.CanFire(Trigger.ToFailed))
                    {
                        await _machine.FireAsync(Trigger.ToFailed);
                    }
                }
            }
            else
            {
                if (_machine.CanFire(Trigger.ToFailed))
                {
                    await _machine.FireAsync(Trigger.ToFailed);
                }
            }


            return(default(TResponse));
        }