public AzureStorageAuditQueueProcessorFactory(IAsynchronousBackoffPolicyFactory backoffPolicyFactory,
IAzureStorageQueueSerializer serializer,
ICommandAuditPipeline commandAuditPipeline,
ICloudAuditQueueProvider cloudAuditQueueProvider)
{
_backoffPolicyFactory = backoffPolicyFactory;
_serializer = serializer;
_commandAuditPipeline = commandAuditPipeline;
_cloudAuditQueueProvider = cloudAuditQueueProvider;
}
public CommandDispatcher(ICommandRegistry commandRegistry,
ICommandExecuter commandExecuter,
ICommandScopeManager commandScopeManager,
ICommandAuditPipeline auditPipeline,
IOptionsProvider optionsProvider)
{
_commandRegistry = commandRegistry;
_commandScopeManager = commandScopeManager;
_auditor = auditPipeline;
AssociatedExecuter = commandExecuter;
_collectMetrics = optionsProvider.Options.MetricCollectionEnabled;
}
public CommandExecuter(ICommandRegistry commandRegistry,
ICommandHandlerFactory commandHandlerFactory,
ICommandScopeManager commandScopeManager,
ICommandHandlerExecuter commandHandlerExecuter,
IPipelineAwareCommandHandlerExecuter pipelineAwareCommandHandlerExecuter,
ICommandExecutionExceptionHandler commandExecutionExceptionHandler,
ICommandAuditPipeline commandAuditPipeline,
IOptionsProvider optionsProvider)
{
_commandRegistry = commandRegistry;
_commandHandlerFactory = commandHandlerFactory;
_commandScopeManager = commandScopeManager;
_commandHandlerExecuter = commandHandlerExecuter;
_pipelineAwareCommandHandlerExecuter = pipelineAwareCommandHandlerExecuter;
_commandExecutionExceptionHandler = commandExecutionExceptionHandler;
_commandAuditPipeline = commandAuditPipeline;
_collectMetrics = optionsProvider.Options.MetricCollectionEnabled;
}
public ICommandRegistry UseCommanding(ICommandingDependencyResolver dependencyResolver,
IOptions options = null)
{
options = options ?? new Options();
dependencyResolver.AssociatedCommandingRuntime = this;
ICommandHandlerExecuter commandHandlerExecuter = new CommandHandlerExecuter();
dependencyResolver.RegisterInstance(commandHandlerExecuter);
IOptionsProvider optionsProvider = new OptionsProvider(options);
dependencyResolver.RegisterInstance(optionsProvider);
// the registry is always shared, but vagaries of different IoC containers mean its dangerous to rely
// on dependecy resolver checks for an existing registration
lock (_registryLockObject)
{
if (_registry == null || options.Reset)
{
Action <Type> resolverContainerRegistration = type => dependencyResolver.TypeMapping(type, type);
_registry = new CommandRegistry(commandHandlerExecuter, options.CommandHandlerContainerRegistration ?? resolverContainerRegistration);
}
dependencyResolver.RegisterInstance(_registry);
}
// the enricher is always shared, but vagaries of different IoC containers mean its dangerous to rely
// on dependecy resolver checks for an existing registration
lock (_enrichmentLockObject)
{
if (_dispatchContextEnrichment == null || options.Reset)
{
_dispatchContextEnrichment = new CommandDispatchContextEnrichment(options.Enrichers ?? new List <ICommandDispatchContextEnricher>());
}
else if (options.Enrichers != null)
{
_dispatchContextEnrichment.AddEnrichers(options.Enrichers);
}
dependencyResolver.RegisterInstance(_dispatchContextEnrichment);
}
lock (_auditItemEnricherPipelineLockObject)
{
if (_auditItemEnricherPipeline == null || options.Reset)
{
_auditItemEnricherPipeline = new AuditItemEnricherPipeline(
options.AuditItemEnricherFactoryFunc ?? (type => (IAuditItemEnricher)dependencyResolver.Resolve(type)));
}
dependencyResolver.RegisterInstance(_auditItemEnricherPipeline);
}
lock (_auditorPipelineLockObject)
{
if (_auditorPipeline == null || options.Reset)
{
_auditorPipeline = new CommandAuditPipeline(t => (ICommandAuditor)dependencyResolver.Resolve(t),
dependencyResolver.Resolve <ICommandAuditSerializer>,
_auditItemEnricherPipeline);
}
dependencyResolver.RegisterInstance(_auditorPipeline);
}
ICommandHandlerFactory commandHandlerFactory = new CommandHandlerFactory(options.CommandHandlerFactoryFunc ?? dependencyResolver.Resolve);
IPipelineAwareCommandHandlerExecuter pipelineAwareCommandHandlerExecuter = new PipelineAwareCommandHandlerExecuter();
dependencyResolver.RegisterInstance(commandHandlerFactory);
dependencyResolver.RegisterInstance(pipelineAwareCommandHandlerExecuter);
dependencyResolver.TypeMapping <ICommandAuditorFactory, NullCommandAuditorFactory>();
dependencyResolver.TypeMapping <ICommandScopeManager, AsyncLocalCommandScopeManager>();
dependencyResolver.TypeMapping <IFrameworkCommandDispatcher, CommandDispatcher>();
dependencyResolver.TypeMapping <ICommandDispatcher, CommandDispatcher>();
dependencyResolver.TypeMapping <IFrameworkCommandExecuter, CommandExecuter>();
dependencyResolver.TypeMapping <ICommandExecuter, CommandExecuter>();
dependencyResolver.TypeMapping <IDirectCommandExecuter, DirectCommandExecuter>();
if (options.DisableCorrelationIds)
{
dependencyResolver.TypeMapping <ICommandCorrelationIdProvider, DisabledCorrelationIdProvider>();
}
else
{
if (options.UseLocallyUniqueCorrelationIds)
{
dependencyResolver
.TypeMapping <ICommandCorrelationIdProvider, LocallyUniqueCommandCorrelationIdProvider>();
}
else
{
dependencyResolver.TypeMapping <ICommandCorrelationIdProvider, CommandCorrelationIdProvider>();
}
}
dependencyResolver.TypeMapping <ICommandAuditSerializer, CommandAuditSerializer>();
dependencyResolver.TypeMapping(typeof(ICommandExecutionExceptionHandler), options.CommandExecutionExceptionHandler ?? typeof(DefaultCommandExecutionExceptionHandler));
return(_registry);
}
