public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context.ConsumeContext);
var activity = kernel.Resolve <TActivity>(new Arguments(new { context.Log }));
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext, ReleaseComponent));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
try
{
_kernel.UpdateScope(context.ConsumeContext);
var activity = _kernel.Resolve <TActivity>(new Arguments(new { context.Log }));
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
activityContext.UpdatePayload(_kernel);
return(new CreatedCompensateActivityScopeContext <IDisposable, TActivity, TLog>(scope, activityContext, ReleaseComponent));
}
catch
{
scope.Dispose();
throw;
}
}
public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <IUnityContainer>(out var existingContainer))
{
var activity = existingContainer.Resolve <TActivity>(new DependencyOverride(typeof(TLog), InjectionParameterValue.ToParameter(context.Log)));
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
var scope = _container.CreateChildContainer();
try
{
var activity = scope.Resolve <TActivity>(new DependencyOverride(typeof(TLog), InjectionParameterValue.ToParameter(context.Log)));
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
var contextScope = scope;
activityContext.GetOrAddPayload(() => contextScope);
return(new CreatedCompensateActivityScopeContext <IUnityContainer, TActivity, TLog>(contextScope, activityContext));
}
catch
{
scope.Dispose();
throw;
}
}
public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <IServiceScope>(out var existingContainer))
{
var activity = existingContainer.ServiceProvider.GetRequiredService <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
var serviceScope = _serviceProvider.CreateScope();
try
{
var activity = serviceScope.ServiceProvider.GetRequiredService <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
var scope = serviceScope;
activityContext.GetOrAddPayload(() => scope);
activityContext.GetOrAddPayload(() => scope.ServiceProvider);
return(new CreatedCompensateActivityScopeContext <IServiceScope, TActivity, TLog>(scope, activityContext));
}
catch
{
serviceScope.Dispose();
throw;
}
}
public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <IContainer>(out var existingContainer))
{
var activity = existingContainer
.With(context.Log)
.GetInstance <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
var scopeContainer = _container.CreateNestedContainer(context.ConsumeContext);
try
{
var activity = scopeContainer
.With(context.Log)
.GetInstance <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
var scope = scopeContainer;
activityContext.GetOrAddPayload(() => scope);
return(new CreatedCompensateActivityScopeContext <IContainer, TActivity, TLog>(scope, activityContext));
}
catch
{
scopeContainer.Dispose();
throw;
}
}
public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <Scope>(out var existingContainer))
{
var activity = existingContainer
.Container
.GetInstance <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
var scope = AsyncScopedLifestyle.BeginScope(_container);
try
{
var activity = scope
.Container
.GetInstance <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
var contextScope = scope;
activityContext.GetOrAddPayload(() => contextScope);
return(new CreatedCompensateActivityScopeContext <Scope, TActivity, TLog>(contextScope, activityContext));
}
catch
{
scope.Dispose();
throw;
}
}
public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <INestedContainer>(out var existingContainer))
{
existingContainer.Inject(context.ConsumeContext);
var activity = existingContainer.GetInstance <TActivity>();
var activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
var nestedContainer = _container.GetNestedContainer(context.ConsumeContext);
try
{
var activity = nestedContainer.GetInstance <TActivity>();
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
activityContext.UpdatePayload(nestedContainer);
return(new CreatedCompensateActivityScopeContext <INestedContainer, TActivity, TLog>(nestedContainer, activityContext));
}
catch
{
nestedContainer.Dispose();
throw;
}
}
public 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 = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context.ConsumeContext);
var lifetimeScope = parentLifetimeScope.BeginLifetimeScope(_name, builder => builder.ConfigureScope(context.ConsumeContext));
try
{
var activity = lifetimeScope.Resolve <TActivity>(TypedParameter.From(context.Log));
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
var scope = lifetimeScope;
activityContext.GetOrAddPayload(() => scope);
return(new CreatedCompensateActivityScopeContext <ILifetimeScope, TActivity, TLog>(scope, activityContext));
}
catch
{
lifetimeScope.Dispose();
throw;
}
}
public async Task Compensate(CompensateContext <TLog> context, IPipe <CompensateActivityContext <TLog> > next)
{
using (var scope = _lifetimeScope.BeginLifetimeScope(x => ConfigureScope(x, context)))
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("CompensateActivityFactory: Compensating: {0}", TypeMetadataCache <TActivity> .ShortName);
}
var activity = scope.Resolve <TActivity>(TypedParameter.From(context.Log));
var activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
await next.Send(activityContext).ConfigureAwait(false);
}
}
public ICompensateActivityScopeContext <TActivity, TLog> GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.UpdateScope(context.ConsumeContext);
var activity = existingServiceScope.ServiceProvider.GetService <TActivity>();
if (activity == null)
{
throw new ConsumerException($"Unable to resolve activity type '{TypeMetadataCache<TActivity>.ShortName}'.");
}
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope();
try
{
serviceScope.UpdateScope(context.ConsumeContext);
var activity = serviceScope.ServiceProvider.GetService <TActivity>();
if (activity == null)
{
throw new ConsumerException($"Unable to resolve activity type '{TypeMetadataCache<TActivity>.ShortName}'.");
}
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
activityContext.UpdatePayload(serviceScope);
return(new CreatedCompensateActivityScopeContext <IServiceScope, TActivity, TLog>(serviceScope, activityContext));
}
catch
{
serviceScope.Dispose();
throw;
}
}
public async Task Compensate(CompensateContext <TLog> context, IPipe <CompensateActivityContext <TActivity, TLog> > next)
{
TActivity activity = null;
try
{
activity = _compensateFactory(context.Log);
var activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
await next.Send(activityContext).ConfigureAwait(false);
}
finally
{
var disposable = activity as IDisposable;
disposable?.Dispose();
}
}
public async Task <ResultContext <CompensationResult> > Compensate(CompensateContext <TLog> context,
IRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult> next)
{
TActivity activity = null;
try
{
activity = _compensateFactory(context.Log);
var activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
return(await next.Send(activityContext).ConfigureAwait(false));
}
finally
{
var disposable = activity as IDisposable;
disposable?.Dispose();
}
}
public async Task <ResultContext <CompensationResult> > Compensate(CompensateContext <TLog> context,
IRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult> next)
{
using (var innerScope = _lifetimeScope.BeginLifetimeScope(x => ConfigureScope(x, context)))
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("CompensateActivityFactory: Compensating: {0}", TypeMetadataCache <TActivity> .ShortName);
}
var activity = innerScope.Resolve <TActivity>(TypedParameter.From(context.Log));
CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
var consumerLifetimeScope = innerScope;
activityContext.GetOrAddPayload(() => consumerLifetimeScope);
return(await next.Send(activityContext).ConfigureAwait(false));
}
}
public async Task Compensate(CompensateContext <TLog> context, IPipe <CompensateActivityContext <TLog> > next)
{
using (_kernel.RequireScope())
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("CompensateActivityFactory: Compensating: {0}", TypeMetadataCache <TActivity> .ShortName);
}
var activity = _kernel.Resolve <TActivity>(new { context.Log, context.ConsumeContext });
if (activity == null)
{
throw new ConsumerException($"Unable to resolve activity type '{TypeMetadataCache<TActivity>.ShortName}'.");
}
var activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context);
await next.Send(activityContext).ConfigureAwait(false);
}
}
