public async Task <CompensationResult> Compensate(CompensateContext <ReserveRoomLog> context) { await Console.Out.WriteLineAsync($"Cancelling reservationId: {context.Log.ReservationId}"); return(context.Compensated()); }
public async ValueTask <ICompensateActivityScopeContext <TActivity, TLog> > GetScope(CompensateContext <TLog> context) { if (context.TryGetPayload <ILifetimeScope>(out var existingLifetimeScope)) { var activity = existingLifetimeScope.Resolve <TActivity>(TypedParameter.From(context.Log)); CompensateActivityContext <TActivity, TLog> activityContext = context.CreateActivityContext(activity); return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext)); } var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context); var lifetimeScope = parentLifetimeScope.BeginLifetimeScope(_name, builder => { builder.ConfigureScope(context); _configureScope?.Invoke(builder, context); }); try { var activity = lifetimeScope.Resolve <TActivity>(TypedParameter.From(context.Log)); var compensateContext = lifetimeScope.Resolve <CompensateContext <TLog> >(); CompensateActivityContext <TActivity, TLog> activityContext = compensateContext.CreateActivityContext(activity); return(new CreatedCompensateActivityScopeContext <ILifetimeScope, TActivity, TLog>(lifetimeScope, activityContext)); } catch { await lifetimeScope.DisposeAsync().ConfigureAwait(false); throw; } }
public async Task <CompensationResult> Compensate(CompensateContext <ActivityLog> context) { Console.WriteLine("Compensating Activity..."); return(context.Compensated()); }
public async Task <CompensationResult> Compensate(CompensateContext <CardPaymentLog> context) { // cancel authorization return(context.Compensated()); }
public Task <ResultContext <CompensationResult> > Compensate(CompensateContext <TLog> context, IRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult> next) { return(_activityFactory.Compensate(context, next)); }
public async Task <CompensationResult> Compensate(CompensateContext <TestLog> context) { return(context.Compensated()); }
public async ValueTask <ICompensateActivityScopeContext <TActivity, TLog> > GetScope(CompensateContext <TLog> context) { if (context.TryGetPayload <Scope>(out var existingScope)) { existingScope.UpdateScope(context); var activity = existingScope .Container .GetInstance <TActivity>(); CompensateActivityContext <TActivity, TLog> activityContext = context.CreateActivityContext(activity); return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext)); } var scope = AsyncScopedLifestyle.BeginScope(_container); try { CompensateContext <TLog> scopeContext = new CompensateContextScope <TLog>(context, scope); scope.UpdateScope(scopeContext); var activity = scope.Container.GetInstance <TActivity>(); CompensateActivityContext <TActivity, TLog> activityContext = scopeContext.CreateActivityContext(activity); return(new CreatedCompensateActivityScopeContext <Scope, TActivity, TLog>(scope, activityContext)); } catch { await scope.DisposeScopeAsync().ConfigureAwait(false); throw; } }
public Task <CompensationResult> Compensate(CompensateContext <IAssignCatalogLog> context) { return(Task.FromResult(context.Compensated())); }
public Task <CompensationResult> Compensate(CompensateContext <Log> context) { Console.WriteLine("WE BLEW UP!!"); return(Task.FromResult(context.Compensated())); }
public async Task <CompensationResult> Compensate(CompensateContext <TestLog> context) { Console.WriteLine("FaultyCompensateActivity: Compensate: {0}", context.Log.OriginalValue); return(context.Failed()); }
public async Task Send(CompensateContext <TLog> context, IPipe <CompensateContext <TLog> > next) { using var scope = _scopeProvider.GetScope(context); await next.Send(scope.Context).ConfigureAwait(false); }
public async Task Send(CompensateContext <TLog> context, IPipe <CompensateContext <TLog> > next) { await _factory.Compensate(context, _pipe).ConfigureAwait(false); await next.Send(context).ConfigureAwait(false); }
public async Task <CompensationResult> Compensate(CompensateContext <IEventRegistrationLog> context) { WriteLine("Removing registration for event: {0} ({1})", context.Log.RegistrationId, context.Log.ParticipantEmailAddress); return(context.Compensated()); }
public async ValueTask <ICompensateActivityScopeContext <TActivity, TLog> > GetScope(CompensateContext <TLog> context) { if (context.TryGetPayload <IContainer>(out var existingContainer)) { existingContainer.Inject <ConsumeContext>(context); var activity = existingContainer .With(context.Log) .GetInstance <TActivity>(); CompensateActivityContext <TActivity, TLog> activityContext = context.CreateActivityContext(activity); return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext)); } var nestedContainer = _container.CreateNestedContainer(context); try { var activity = nestedContainer .With(context.Log) .GetInstance <TActivity>(); CompensateActivityContext <TActivity, TLog> activityContext = context.CreateActivityContext(activity); activityContext.UpdatePayload(nestedContainer); return(new CreatedCompensateActivityScopeContext <IContainer, TActivity, TLog>(nestedContainer, activityContext)); } catch { nestedContainer.Dispose(); throw; } }
static RetryCompensateContext <TLog> Factory(CompensateContext <TLog> context, IRetryPolicy retryPolicy, RetryContext retryContext) { return(context as RetryCompensateContext <TLog> ?? new RetryCompensateContext <TLog>(context, retryPolicy, retryContext)); }
public Task Compensate(CompensateContext <TLog> context, IPipe <CompensateActivityContext <TLog> > next) { return(_compensateFactory.Compensate(context, next)); }
static void ConfigureScope(ContainerBuilder containerBuilder, CompensateContext <TLog> compensateContext) { containerBuilder.RegisterInstance(compensateContext.ConsumeContext) .ExternallyOwned(); }
public async Task <CompensationResult> Compensate(CompensateContext <PaymentLog> context) { await Task.Delay(100); return(context.Compensated()); }
public InMemoryOutboxCompensateContext(CompensateContext <TLog> context) : base(context) { _context = context; }
public async Task <CompensationResult> Compensate(CompensateContext <ActivityNameLog> context) { await Task.Delay(100); return(context.Compensated()); }
public Task <CompensationResult> Compensate(CompensateContext <SaveOrderStockLog> context) { return(Task.FromResult(context.Compensated())); }
static TimeoutCompensateContext <TArguments> Factory(CompensateContext <TArguments> context, CancellationToken cancellationToken) { return(new TimeoutCompensateContext <TArguments>(context, cancellationToken)); }
public Task <CompensationResult> Compensate(CompensateContext <ICreatePartnerPlatformCustomerLog> context) { // Not sure what to do here!? return(Task.FromResult(context.Compensated())); }