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