public IConsumerScopeContext GetScope(ConsumeContext context)
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context);
return(new ExistingConsumerScopeContext(context));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope(context);
try
{
var proxy = new ConsumeContextScope(context, _kernel);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedConsumerScopeContext <IDisposable>(scope, proxy));
}
catch
{
scope?.Dispose();
throw;
}
}
public ISagaScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context);
return(new ExistingSagaScopeContext <T>(context));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
try
{
_kernel.UpdateScope(context);
var proxy = new ConsumeContextProxy <T>(context, new PayloadCacheScope(context));
proxy.UpdatePayload(_kernel);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaScopeContext <IDisposable, T>(scope, proxy));
}
catch
{
scope.Dispose();
throw;
}
}
public async ValueTask<IConsumerScopeContext> GetScope(ConsumeContext context)
{
if (context.TryGetPayload<IKernel>(out var kernel))
{
kernel.UpdateScope(context);
return new ExistingConsumerScopeContext(context);
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
try
{
var scopeContext = new ConsumeContextScope(context, _kernel);
_kernel.UpdateScope(scopeContext);
foreach (Action<ConsumeContext> scopeAction in _scopeActions)
scopeAction(scopeContext);
return new CreatedConsumerScopeContext<IDisposable>(scope, scopeContext);
}
catch
{
scope?.Dispose();
throw;
}
}
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 IExecuteActivityScopeContext <TActivity, TArguments> GetScope(ExecuteContext <TArguments> context)
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context.ConsumeContext);
var activity = kernel.Resolve <TActivity>(new Arguments().AddTyped(context.Arguments));
ExecuteActivityContext <TActivity, TArguments> activityContext = new HostExecuteActivityContext <TActivity, TArguments>(activity, context);
return(new ExistingExecuteActivityScopeContext <TActivity, TArguments>(activityContext, ReleaseComponent));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope(context.ConsumeContext);
try
{
var activity = _kernel.Resolve <TActivity>(new Arguments().AddTyped(context.Arguments));
ExecuteActivityContext <TActivity, TArguments> activityContext = new HostExecuteActivityContext <TActivity, TArguments>(activity, context);
activityContext.UpdatePayload(_kernel);
return(new CreatedExecuteActivityScopeContext <IDisposable, TActivity, TArguments>(scope, activityContext, ReleaseComponent));
}
catch
{
scope.Dispose();
throw;
}
}
public async ValueTask <ICompensateActivityScopeContext <TActivity, TLog> > GetScope(CompensateContext <TLog> context)
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context);
var activity = kernel.Resolve <TActivity>(new Arguments().AddTyped(context.Log));
CompensateActivityContext <TActivity, TLog> activityContext = context.CreateActivityContext(activity);
return(new ExistingCompensateActivityScopeContext <TActivity, TLog>(activityContext, ReleaseComponent));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
try
{
CompensateContext <TLog> scopeContext = new CompensateContextScope <TLog>(context, _kernel);
_kernel.UpdateScope(scopeContext);
var activity = _kernel.Resolve <TActivity>(new Arguments().AddTyped(context.Log));
CompensateActivityContext <TActivity, TLog> activityContext = scopeContext.CreateActivityContext(activity);
return(new CreatedCompensateActivityScopeContext <IDisposable, TActivity, TLog>(scope, activityContext, ReleaseComponent));
}
catch
{
scope.Dispose();
throw;
}
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (context.TryGetPayload <IKernel>(out var existingKernel))
{
existingKernel.UpdateScope(context);
context.GetOrAddPayload(() => existingKernel.TryResolve <IStateMachineActivityFactory>() ?? WindsorStateMachineActivityFactory.Instance);
var factory = existingKernel.Resolve <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
async Task CreateMessageScope()
{
try
{
var scopeContext = new ConsumeContextScope <T>(context, _kernel);
_kernel.UpdateScope(scopeContext);
var activityFactory = _kernel.TryResolve <IStateMachineActivityFactory>() ?? WindsorStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(scopeContext, activityFactory);
var factory = _kernel.Resolve <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
finally
{
scope.Dispose();
}
}
return(CreateMessageScope());
}