public CommandDispatcher(ICommandHandlerProvider commandHandlerProvider)
{
commandHandlerTypes = commandHandlerProvider.GetCommandHandlers();
if (commandHandlerTypes != null)
{
MethodInfo registerMethod = this.GetType().GetMethod("Register", BindingFlags.Instance | BindingFlags.Public);
foreach (KeyValuePair <Type, Type> commandHandlerPair in commandHandlerTypes)
{
if (!EAppRuntime.Instance.CurrentApp.ObjectContainer.Registered(commandHandlerPair.Value))
{
EAppRuntime.Instance.CurrentApp.ObjectContainer.RegisterType(commandHandlerPair.Value);
}
MethodInfo genericRegisterMethod = registerMethod.MakeGenericMethod(commandHandlerPair.Key);
genericRegisterMethod.Invoke(this,
new object[]
{
EAppRuntime.Instance.CurrentApp.ObjectContainer.Resolve(commandHandlerPair.Value)
});
}
}
}
/// <summary>Parameterized constructor.
/// </summary>
/// <param name="processingCommandCache"></param>
/// <param name="commandAsyncResultManager"></param>
/// <param name="commandHandlerProvider"></param>
/// <param name="aggregateRootTypeProvider"></param>
/// <param name="eventSender"></param>
/// <param name="retryService"></param>
/// <param name="commandContext"></param>
/// <param name="loggerFactory"></param>
/// <exception cref="Exception"></exception>
public DefaultCommandExecutor(
IProcessingCommandCache processingCommandCache,
ICommandAsyncResultManager commandAsyncResultManager,
ICommandHandlerProvider commandHandlerProvider,
IAggregateRootTypeProvider aggregateRootTypeProvider,
IEventSender eventSender,
IRetryService retryService,
ICommandContext commandContext,
ILoggerFactory loggerFactory)
{
_processingCommandCache = processingCommandCache;
_commandAsyncResultManager = commandAsyncResultManager;
_commandHandlerProvider = commandHandlerProvider;
_aggregateRootTypeProvider = aggregateRootTypeProvider;
_eventSender = eventSender;
_retryService = retryService;
_commandContext = commandContext;
_trackingContext = commandContext as ITrackingContext;
_logger = loggerFactory.Create(GetType().Name);
if (_trackingContext == null)
{
throw new Exception("Command context must also implement ITrackingContext interface.");
}
}
public DefaultProcessingCommandHandler(
IJsonSerializer jsonSerializer,
IEventStore eventStore,
IMemoryCache memoryCache,
ICommandHandlerProvider commandHandlerProvider,
ICommandAsyncHandlerProvider commandAsyncHandlerProvider,
ITypeNameProvider typeNameProvider,
IEventCommittingService eventService,
IMessagePublisher <IApplicationMessage> applicationMessagePublisher,
IMessagePublisher <IPublishableException> exceptionPublisher,
IOHelper ioHelper,
ILoggerFactory loggerFactory,
ITimeProvider timeProvider)
{
_jsonSerializer = jsonSerializer;
_eventStore = eventStore;
_memoryCache = memoryCache;
_commandHandlerProvider = commandHandlerProvider;
_commandAsyncHandlerProvider = commandAsyncHandlerProvider;
_typeNameProvider = typeNameProvider;
_eventService = eventService;
_applicationMessagePublisher = applicationMessagePublisher;
_exceptionPublisher = exceptionPublisher;
_ioHelper = ioHelper;
_logger = loggerFactory.Create(GetType().FullName);
_timeProvider = timeProvider;
}
public WorkerServiceClient( ICommandExecutionRetryPolicy retryPolicy, ICommandHandlerProvider handlerProvider, IInterceptorProvider interceptorProvider, IValidatorsProvider validatorsProvider )
{
this.retryPolicy = retryPolicy;
this.handlerProvider = handlerProvider;
this.interceptorProvider = interceptorProvider;
this.validatorsProvider = validatorsProvider;
}
public WorkerServiceClient(ICommandExecutionRetryPolicy retryPolicy, ICommandHandlerProvider handlerProvider, IInterceptorProvider interceptorProvider, IValidatorsProvider validatorsProvider)
{
this.retryPolicy = retryPolicy;
this.handlerProvider = handlerProvider;
this.interceptorProvider = interceptorProvider;
this.validatorsProvider = validatorsProvider;
}
public DefaultCommandExecutor(
IProcessingCommandCache processingCommandCache,
ICommandAsyncResultManager commandAsyncResultManager,
ICommandHandlerProvider commandHandlerProvider,
IAggregateRootTypeProvider aggregateRootTypeProvider,
IMemoryCache memoryCache,
IRepository repository,
IRetryCommandService retryCommandService,
IEventStore eventStore,
IEventPublisher eventPublisher,
IEventPersistenceSynchronizerProvider eventPersistenceSynchronizerProvider,
ICommandContext commandContext,
ILoggerFactory loggerFactory)
{
_processingCommandCache = processingCommandCache;
_commandAsyncResultManager = commandAsyncResultManager;
_commandHandlerProvider = commandHandlerProvider;
_aggregateRootTypeProvider = aggregateRootTypeProvider;
_memoryCache = memoryCache;
_repository = repository;
_retryCommandService = retryCommandService;
_eventStore = eventStore;
_eventPublisher = eventPublisher;
_eventPersistenceSynchronizerProvider = eventPersistenceSynchronizerProvider;
_commandContext = commandContext;
_trackingContext = commandContext as ITrackingContext;
_logger = loggerFactory.Create(GetType().Name);
if (_trackingContext == null)
{
throw new Exception("command context must also implement ITrackingContext interface.");
}
}
public DefaultProcessingCommandHandler(
ICommandStore commandStore,
IEventStore eventStore,
ICommandHandlerProvider commandHandlerProvider,
ICommandAsyncHandlerProvider commandAsyncHandlerProvider,
ITypeCodeProvider aggregateRootTypeProvider,
IEventService eventService,
IMessagePublisher <IApplicationMessage> messagePublisher,
IMessagePublisher <IPublishableException> exceptionPublisher,
IMemoryCache memoryCache,
IOHelper ioHelper,
ILoggerFactory loggerFactory)
{
_commandStore = commandStore;
_eventStore = eventStore;
_commandHandlerProvider = commandHandlerProvider;
_commandAsyncHandlerProvider = commandAsyncHandlerProvider;
_aggregateRootTypeProvider = aggregateRootTypeProvider;
_eventService = eventService;
_messagePublisher = messagePublisher;
_exceptionPublisher = exceptionPublisher;
_memoryCache = memoryCache;
_ioHelper = ioHelper;
_logger = loggerFactory.Create(GetType().FullName);
_eventService.SetProcessingCommandHandler(this);
}
public void Setup()
{
_commandHandlerProvider = MockRepository.GenerateMock <ICommandHandlerProvider>();
_dbSessionManager = MockRepository.GenerateMock <IDbSessionManager>();
_prerequisitesChecker = MockRepository.GenerateMock <IPrerequisitesChecker>();
_bus = new CommandBus(_commandHandlerProvider, _dbSessionManager, _prerequisitesChecker);
}
public CommandDispatcher([NotNull] ICommandHandlerProvider commandHandlerProvider)
{
if (commandHandlerProvider == null)
{
throw new ArgumentNullException(nameof(commandHandlerProvider));
}
_commandHandlerProvider = commandHandlerProvider;
}
public CommandBus(
ICommandHandlerProvider commandHandlerProvider,
IDbSessionManager dbSessionManager,
IPrerequisitesChecker prerequisitesChecker)
{
_commandHandlerProvider = commandHandlerProvider;
_dbSessionManager = dbSessionManager;
_prerequisitesChecker = prerequisitesChecker;
}
public static ICommandDispatcher Configure(ICommandHandlerProvider commandHandlerProvider,
string dispatcherName)
{
ICommandDispatcher commandDispatcher = AppRuntime.Instance.CurrentApplication.ObjectContainer.Resolve <ICommandDispatcher>(dispatcherName);
CreateCommandHandlers(commandDispatcher, commandHandlerProvider);
return(commandDispatcher);
}
public WebApiCommandDispatcher(ICommandExecutionRetryPolicy retryPolicy, ICommandHandlerProvider handlerProvider, IInterceptorProvider interceptorProvider, IValidatorsProvider validatorsProvider, IJasonServerConfiguration configuration)
{
this.handlerProvider = handlerProvider;
this.retryPolicy = retryPolicy;
this.interceptorProvider = interceptorProvider;
this.validatorsProvider = validatorsProvider;
this.configuration = configuration;
logger.Debug("WebApiCommandDispatcher.ctor");
}
public WebApiCommandDispatcher( ICommandExecutionRetryPolicy retryPolicy, ICommandHandlerProvider handlerProvider, IInterceptorProvider interceptorProvider, IValidatorsProvider validatorsProvider, IJasonServerConfiguration configuration )
{
this.handlerProvider = handlerProvider;
this.retryPolicy = retryPolicy;
this.interceptorProvider = interceptorProvider;
this.validatorsProvider = validatorsProvider;
this.configuration = configuration;
logger.Debug( "WebApiCommandDispatcher.ctor" );
}
public CommandBus(ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
string receiveEndPoint,
bool inProc)
: base(receiveEndPoint)
{
CommandStateQueue = Hashtable.Synchronized(new Hashtable());
HandlerProvider = handlerProvider;
LinearCommandManager = linearCommandManager;
InProc = inProc;
}
public DistributableCommandBus(ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
IMessageConsumer commandConsumer,
string receiveEndPoint,
bool inProc)
: base(handlerProvider, linearCommandManager, receiveEndPoint, inProc)
{
_commandConsumer = commandConsumer as IInProcMessageConsumer;
_commandDistributor = _commandConsumer;
_isDistributor = _commandDistributor is IMessageDistributor;
}
public DistributableCommandBus(ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
IMessageConsumer commandConsumer,
string receiveEndPoint,
bool inProc)
: base(handlerProvider, linearCommandManager, receiveEndPoint, inProc)
{
_commandConsumer = commandConsumer as IInProcMessageConsumer;
_commandDistributor = _commandConsumer;
_isDistributor = _commandDistributor is IMessageDistributor;
}
public WorkerService(IJobHandlersProvider jobProvider, ICommandHandlerProvider handlerProvider, ICommandExecutionRetryPolicy retryPolicy, IInterceptorProvider interceptorProvider)
{
Ensure.That(jobProvider).Named(() => jobProvider).IsNotNull();
Ensure.That(handlerProvider).Named(() => handlerProvider).IsNotNull();
Ensure.That(retryPolicy).Named(() => retryPolicy).IsNotNull();
Ensure.That(interceptorProvider).Named(() => interceptorProvider).IsNotNull();
this.jobProvider = jobProvider;
this.handlerProvider = handlerProvider;
this.retryPolicy = retryPolicy;
this.interceptorProvider = interceptorProvider;
}
public WorkerService( IJobHandlersProvider jobProvider, ICommandHandlerProvider handlerProvider, ICommandExecutionRetryPolicy retryPolicy, IInterceptorProvider interceptorProvider )
{
Ensure.That( jobProvider ).Named( () => jobProvider ).IsNotNull();
Ensure.That( handlerProvider ).Named( () => handlerProvider ).IsNotNull();
Ensure.That( retryPolicy ).Named( () => retryPolicy ).IsNotNull();
Ensure.That( interceptorProvider ).Named( () => interceptorProvider ).IsNotNull();
this.jobProvider = jobProvider;
this.handlerProvider = handlerProvider;
this.retryPolicy = retryPolicy;
this.interceptorProvider = interceptorProvider;
}
public CommandBus(ICommandHandlerProvider handlerProvider,
IMessageConsumer commandConsumer,
bool inProc)
{
HandlerProvider = handlerProvider;
CommandConsumer = commandConsumer;
if (CommandConsumer != null)
{
CommandConsumer.MessageHandled += CommandConsumer_MessageHandled;
}
MessageStateQueue = Hashtable.Synchronized(new Hashtable());
InProc = inProc;
}
public Configuration CommandHandlerProviderBuild(ICommandHandlerProvider provider, params string[] assemblies)
{
if (provider == null)
{
provider = IoCFactory.Resolve <ICommandHandlerProvider>(new ParameterOverride("assemblies", assemblies));
}
else
{
IoCFactory.Instance.CurrentContainer
.RegisterInstance(typeof(ICommandHandlerProvider)
, provider
, new ContainerControlledLifetimeManager());
}
return(this);
}
/// <summary>Parameterized constructor.
/// </summary>
/// <param name="waitingCommandCache"></param>
/// <param name="commandHandlerProvider"></param>
/// <param name="aggregateRootTypeProvider"></param>
/// <param name="commitEventService"></param>
/// <param name="actionExecutionService"></param>
/// <param name="loggerFactory"></param>
public DefaultCommandExecutor(
IWaitingCommandCache waitingCommandCache,
ICommandHandlerProvider commandHandlerProvider,
IAggregateRootTypeCodeProvider aggregateRootTypeProvider,
ICommitEventService commitEventService,
IActionExecutionService actionExecutionService,
ILoggerFactory loggerFactory)
{
_waitingCommandCache = waitingCommandCache;
_commandHandlerProvider = commandHandlerProvider;
_aggregateRootTypeProvider = aggregateRootTypeProvider;
_commitEventService = commitEventService;
_actionExecutionService = actionExecutionService;
_logger = loggerFactory.Create(GetType().Name);
_commitEventService.SetCommandExecutor(this);
}
public CommandBus(ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
string serviceBusConnectionString,
string[] commandQueueNames,
string replyTopicName,
string replySubscriptionName)
{
_logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType());
_serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
_commandStateQueues = Hashtable.Synchronized(new Hashtable());
_handlerProvider = handlerProvider;
_linearCommandManager = linearCommandManager;
_replyTopicName = replyTopicName;
_replySubscriptionName = replySubscriptionName;
_commandQueueNames = commandQueueNames;
_commandQueueClients = new List <QueueClient>();
_toBeSentCommandQueue = new BlockingCollection <IMessageContext>();
}
public CommandBus(ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
string serviceBusConnectionString,
string[] commandQueueNames,
string replyTopicName,
string replySubscriptionName,
bool inProc)
: base(serviceBusConnectionString)
{
_commandStateQueues = Hashtable.Synchronized(new Hashtable());
_handlerProvider = handlerProvider;
_linearCommandManager = linearCommandManager;
_replyTopicName = replyTopicName;
_replySubscriptionName = replySubscriptionName;
_commandQueueNames = commandQueueNames;
_commandQueueClients = new List <QueueClient>();
_toBeSentCommandQueue = new BlockingCollection <IMessageContext>();
InProc = inProc;
}
public CommandBus(string name, ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
string brokerAddress,
int producerBrokerPort,
EQueueClientsConsumers.ConsumerSetting consumerSetting,
string groupName,
string replyTopic,
string commandTopic,
bool inProc)
: base(name, consumerSetting, groupName, replyTopic)
{
CommandStateQueue = Hashtable.Synchronized(new Hashtable());
ToBeSentCommandQueue = new BlockingCollection <MessageContext>();
HandlerProvider = handlerProvider;
LinearCommandManager = linearCommandManager;
CommandTopic = commandTopic;
ReplyTopic = replyTopic;
InProc = inProc;
ProducerSetting = new EQueueClientsProducers.ProducerSetting();
ProducerSetting.BrokerAddress = brokerAddress;
ProducerSetting.BrokerPort = producerBrokerPort;
ProducerName = name;
}
public DefaultCommandExecutor(
IProcessingCommandCache processingCommandCache,
ICommandAsyncResultManager commandAsyncResultManager,
ICommandHandlerProvider commandHandlerProvider,
IAggregateRootTypeProvider aggregateRootTypeProvider,
IMemoryCacheRefreshService memoryCacheRefreshService,
IRetryCommandService retryCommandService,
IEventStore eventStore,
IEventPublisher eventPublisher,
ICommandContext commandContext,
ILoggerFactory loggerFactory)
{
_processingCommandCache = processingCommandCache;
_commandAsyncResultManager = commandAsyncResultManager;
_commandHandlerProvider = commandHandlerProvider;
_aggregateRootTypeProvider = aggregateRootTypeProvider;
_memoryCacheRefreshService = memoryCacheRefreshService;
_retryCommandService = retryCommandService;
_eventStore = eventStore;
_eventPublisher = eventPublisher;
_commandContext = commandContext;
_trackingContext = commandContext as ITrackingContext;
_logger = loggerFactory.Create(GetType().Name);
}
public CommandBus(ICommandHandlerProvider handlerProvider,
ILinearCommandManager linearCommandManager,
string receiveEndPoint,
bool inProc,
string[] targetEndPoints)
: this(handlerProvider, linearCommandManager, receiveEndPoint, inProc)
{
_toBeSentCommandQueue = new BlockingCollection <IMessageContext>();
CommandSenders = new List <ZmqSocket>();
targetEndPoints.ForEach(targetEndPoint =>
{
try
{
var commandSender = ZeroMessageQueue.ZmqContext.CreateSocket(SocketType.PUSH);
commandSender.Connect(targetEndPoint);
CommandSenders.Add(commandSender);
}
catch (Exception ex)
{
_Logger.Error(ex.GetBaseException().Message, ex);
}
});
}
public FeatureRequestType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public WeatherType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public RockPaperScissorsType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public CommandDispatcher(ICommandHandlerProvider commandHandlerProvider)
{
_commandHandlerProvider = commandHandlerProvider;
}
public HelpType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public AcronymType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public CountdownType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public CircleController(ICommandHandlerProvider commandHandlerProvider, IPlayerAuthenticationService playerAuthenticationService)
{
_commandHandlerProvider = commandHandlerProvider;
_playerAuthenticationService = playerAuthenticationService;
}
public MartiniType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public LMGTFYType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
public EmojifyType(ICommandHandlerProvider commandHandlerProvider)
{
this.commandHandlerProvider = commandHandlerProvider;
}
