/// <summary>
/// Overloaded constructor to bring up form upon entering the baseURL
/// </summary>
/// <param name="driver"></param>
/// <param name="registrationType"></param>
public FiveKRegistrationForm(IWebDriver driver, RegistrationTypes registrationType) :
base(driver)
{
this.NavigateToBaseURL();
this.SelectRegistrationType(registrationType);
Thread.Sleep(3000); // Wait for form to render.
}
/// <inheritdoc />
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
string connection, string queue)
{
var myType = Assembly.GetAssembly(GetType());
var baseType = Assembly.GetAssembly(typeof(IDbFactory));
base.RegisterImplementations(container, registrationType, connection, queue, myType, baseType);
container.Register <IDbDataSource, DbDataSource>(LifeStyles.Singleton);
container.Register <IGetFileNameFromConnectionString, GetFileNameFromConnectionString>(LifeStyles.Singleton);
container.Register <IDbFactory, DbFactory>(LifeStyles.Singleton);
container.Register <IReaderAsync, ReaderAsync>(LifeStyles.Singleton);
container.Register <DatabaseExists>(LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateJobTablesCommand <ITable>, QueueCreationResult>),
typeof(CreateJobTablesCommandDecorator), LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateQueueTablesAndSaveConfigurationCommand <ITable>,
QueueCreationResult>),
typeof(CreateQueueTablesAndSaveConfigurationDecorator), LifeStyles.Singleton);
}
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, QueueConnection queueConnection)
{
container.Register <IConnectionInformation>(() => new BaseConnectionInformation(queueConnection), LifeStyles.Singleton);
container.Register <ISendMessages, SendMessagesNoOp>(LifeStyles.Singleton);
container.Register <IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTimeNoOp>(LifeStyles.Singleton);
container.Register(() => Substitute.For <ICorrelationIdFactory>(),
LifeStyles.Singleton);
container.Register(
() => Substitute.For <IReceiveMessagesFactory>(), LifeStyles.Singleton);
container.Register(
() => Substitute.For <IJobSchedulerLastKnownEvent>(), LifeStyles.Singleton);
container.Register(
() => Substitute.For <ISendJobToQueue>(), LifeStyles.Singleton);
container.Register(
() => Substitute.For <IJobTableCreation>(), LifeStyles.Singleton);
container.Register <ATaskScheduler, TaskSchedulerNoOp>(LifeStyles.Singleton);
container.Register <IClearExpiredMessages, ClearExpiredMessagesNoOp>(LifeStyles.Singleton);
container.Register <IClearErrorMessages, ClearErrorMessagesNoOp>(LifeStyles.Singleton);
container.Register <ISendHeartBeat, SendHeartBeatNoOp>(LifeStyles.Singleton);
container.Register <IReceiveMessagesError, ReceiveMessagesErrorNoOp>(LifeStyles.Singleton);
container.Register <IReceivePoisonMessage, ReceivePoisonMessageNoOp>(LifeStyles.Singleton);
container.Register <IResetHeartBeat, ResetHeartBeatNoOp>(LifeStyles.Singleton);
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
var options = container.GetInstance <RedisQueueTransportOptions>();
var configurationSend = container.GetInstance <QueueProducerConfiguration>();
var configurationReceive = container.GetInstance <QueueConsumerConfiguration>();
configurationSend.AdditionalConfiguration.SetSetting("RedisQueueTransportOptions", options);
configurationReceive.AdditionalConfiguration.SetSetting("RedisQueueTransportOptions", options);
var transportReceive = container.GetInstance <TransportConfigurationReceive>();
transportReceive.HeartBeatSupported = true;
transportReceive.MessageExpirationSupported = true;
transportReceive.MessageRollbackSupported = true;
transportReceive.QueueDelayBehavior.Clear();
transportReceive.QueueDelayBehavior.Add(DefaultQueueDelay());
transportReceive.FatalExceptionDelayBehavior.Clear();
transportReceive.FatalExceptionDelayBehavior.Add(ExceptionDelay());
options.TimeServer = TimeLocations.RedisServer;
transportReceive.LockFeatures();
SetupHeartBeat(container);
SetupMessageExpiration(container);
//only compile scripts if the container is not in verification mode
if (!container.IsVerifying)
{
SetupScripts(container);
}
}
/// <summary>
/// Suppress warnings for specific cases.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void SuppressWarningsIfNeeded(IContainer container, RegistrationTypes registrationType)
{
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive)
{
container.SuppressDiagnosticWarning(typeof(IMessageContext),
DiagnosticTypes.DisposableTransientComponent,
"IMessageContext is explicitly disposed of via a using statement");
container.SuppressDiagnosticWarning(typeof(MessageContext),
DiagnosticTypes.DisposableTransientComponent,
"MessageContext is explicitly disposed of via a using statement");
container.SuppressDiagnosticWarning(typeof(ATaskScheduler),
DiagnosticTypes.DisposableTransientComponent,
"ATaskScheduler is disposed of via its parent queue if created by this library. Otherwise, the caller of this library is responsible for disposing the task scheduler");
container.SuppressDiagnosticWarning(typeof(IWorker),
DiagnosticTypes.DisposableTransientComponent,
"IWorker is disposed of via the worker collection");
container.SuppressDiagnosticWarning(typeof(IPrimaryWorker),
DiagnosticTypes.DisposableTransientComponent,
"IPrimaryWorker is disposed of via the queue");
}
}
/// <inheritdoc />
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
var init = new RelationalDatabaseMessageQueueInit <long, Guid>();
init.SetDefaultsIfNeeded(container, "PostgreSQLMessageQueueTransportOptions", "PostgreSQLMessageQueueTransportOptions");
SetupPolicy(container);
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType,
ConnectionTypes connectionType)
{
var init = new RelationalDatabaseMessageQueueInit <long, Guid>();
init.SetDefaultsIfNeeded(container, "SQLiteMessageQueueTransportOptions",
"SQLiteMessageQueueTransportOptions");
SetupPolicy(container);
//create in memory hold
var getFileName = container.GetInstance <IGetFileNameFromConnectionString>();
var connection = container.GetInstance <IConnectionInformation>();
var fileName = getFileName.GetFileName(connection.ConnectionString);
if (!fileName.IsInMemory)
{
return;
}
var scope = container.GetInstance <ICreationScope>();
var holder = new SqLiteHoldConnection(getFileName, container.GetInstance <IDbFactory>());
holder.AddConnectionIfNeeded(connection);
scope.AddScopedObject(holder);
}
/// <summary>
/// Allows a transport to register its dependencies in the IoC container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connection">The connection.</param>
/// <param name="queue">The queue.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue)
{
container.Register<IConnectionInformation>(() => new BaseConnectionInformation(queue, connection),
LifeStyles.Singleton);
container.Register<IInternalSerializer, JsonSerializerInternal>(LifeStyles.Singleton);
container.Register<IWorkerNotificationFactory, WorkerNotificationFactoryNoOp>(LifeStyles.Singleton);
}
/// <inheritdoc />
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
QueueConnection queueConnection)
{
var myType = Assembly.GetAssembly(GetType());
var baseType = Assembly.GetAssembly(typeof(IDbFactory));
base.RegisterImplementations(container, registrationType, queueConnection, myType, baseType);
container.Register <IDbDataSource, DbDataSource>(LifeStyles.Singleton);
container.Register <IGetFileNameFromConnectionString, GetFileNameFromConnectionString>(LifeStyles.Singleton);
container.Register <IDbFactory, DbFactory>(LifeStyles.Singleton);
container.Register <IReaderAsync, ReaderAsync>(LifeStyles.Singleton);
container.Register <DatabaseExists>(LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateJobTablesCommand <ITable>, QueueCreationResult>),
typeof(CreateJobTablesCommandDecorator), LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateQueueTablesAndSaveConfigurationCommand <ITable>,
QueueCreationResult>),
typeof(CreateQueueTablesAndSaveConfigurationDecorator), LifeStyles.Singleton);
//some SQLite errors should be warnings, not errors
container.RegisterDecorator(
typeof(IQueryHandler <FindMessagesToResetByHeartBeatQuery <long>, IEnumerable <MessageToReset <long> > >),
typeof(FindRecordsToResetByHeartBeatErrorDecorator), LifeStyles.Singleton);
//some SQLite errors should be warnings, not errors
container.RegisterDecorator(
typeof(IQueryHandler <FindExpiredMessagesToDeleteQuery <long>, IEnumerable <long> >),
typeof(FindExpiredRecordsToDeleteQueryHandlerErrorDecorator), LifeStyles.Singleton);
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
//create in memory hold
var scope = container.GetInstance <ICreationScope>();
var holder = container.GetInstance <IDataStorage>();
scope.AddScopedObject(holder);
var factory = container.GetInstance <ITransportOptionsFactory>();
var options = factory.Create();
var configurationSend = container.GetInstance <QueueProducerConfiguration>();
var configurationReceive = container.GetInstance <QueueConsumerConfiguration>();
configurationSend.AdditionalConfiguration.SetSetting("MemoryTransportOptions", options);
configurationReceive.AdditionalConfiguration.SetSetting("MemoryTransportOptions", options);
var transportReceive = container.GetInstance <TransportConfigurationReceive>();
transportReceive.HeartBeatSupported = false;
transportReceive.MessageExpirationSupported = false;
transportReceive.MessageRollbackSupported = false;
transportReceive.QueueDelayBehavior.Clear();
transportReceive.QueueDelayBehavior.Add(GetQueueDelay());
transportReceive.FatalExceptionDelayBehavior.Clear();
transportReceive.LockFeatures();
}
/// <summary>
/// Allows a transport to register its dependencies in the IoC container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="queueConnection">Queue and connection information.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, QueueConnection queueConnection)
{
container.Register <IConnectionInformation>(() => new BaseConnectionInformation(queueConnection), LifeStyles.Singleton);
container.Register <IInternalSerializer, JsonSerializerInternal>(LifeStyles.Singleton);
container.Register <IWorkerNotificationFactory, WorkerNotificationFactoryNoOp>(LifeStyles.Singleton);
container.Register <IJobScheduler, JobScheduler>(LifeStyles.Singleton);
container.Register <IJobQueue, JobQueue>(LifeStyles.Singleton);
}
/// <summary>
/// Registers the implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="queueConnection">Queue and connection information.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
QueueConnection queueConnection)
{
Guard.NotNull(() => container, container);
container.RegisterNonScopedSingleton <ICreationScope>(new CreationScope());
//**all
container.Register <IJobTableCreation, JobTableCreation>(LifeStyles.Singleton);
container.Register <CreateJobMetaData>(LifeStyles.Singleton);
container.Register <ICorrelationIdFactory, CorrelationIdFactory>(LifeStyles.Singleton);
container.Register <IClearExpiredMessages, ClearExpiredMessages>(LifeStyles.Singleton);
container.Register <IClearErrorMessages, ClearErrorMessages>(LifeStyles.Singleton);
container.Register <IDataStorage, DataStorage>(LifeStyles.Singleton);
container.Register <IDataStorageSendMessage, DataStorage>(LifeStyles.Singleton);
container.Register <IRemoveMessage, RemoveMessage>(LifeStyles.Singleton);
container.Register <IGetHeader, GetHeader>(LifeStyles.Singleton);
container.Register <IGetPreviousMessageErrors, GetPreviousMessageErrorsNoOp>(LifeStyles.Singleton);
//**all
//**send
container.Register <ISendMessages, SendMessages>(LifeStyles.Singleton);
//**send
//**receive
container.Register <IResetHeartBeat, ResetHeartBeat>(LifeStyles.Singleton);
container.Register <ISendHeartBeat, SendHeartBeat>(LifeStyles.Singleton);
container.Register <IReceiveMessagesFactory, ReceiveMessagesFactory>(LifeStyles.Singleton);
container.Register <IReceivePoisonMessage, ReceivePoisonMessage>(LifeStyles.Singleton);
container.Register <IReceiveMessagesError, ReceiveErrorMessage>(LifeStyles.Singleton);
//**receive
//**all
container.RegisterNonScopedSingleton <ICreationScope>(new CreationScope());
container.Register <IQueueCreation, MessageQueueCreation>(LifeStyles.Singleton);
container.Register <IJobSchedulerLastKnownEvent, JobSchedulerLastKnownEvent>(LifeStyles.Singleton);
container.Register <ISendJobToQueue, SendToJobQueue>(LifeStyles.Singleton);
container.Register <ITransportOptionsFactory, TransportOptionsFactory>(LifeStyles.Singleton);
container.Register <IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
container.Register <IConnectionInformation>(() => new ConnectionInformation(queueConnection),
LifeStyles.Singleton);
container.Register <TransportOptions>(LifeStyles.Singleton);
//**all
//**receive
container.Register <IReceiveMessages, MessageQueueReceive>(LifeStyles.Transient);
//**receive
//decorators
//this is required for tracing to correctly add the root trace
container.RegisterDecorator <IDataStorageSendMessage, DataStorageSendMessageDecorator>(LifeStyles.Singleton);
}
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, QueueConnection queueConnectione)
{
container.Register <ISendMessages, SendMessagesNoOp>(LifeStyles.Singleton);
container.Register(() => Substitute.For <IConnectionInformation>(), LifeStyles.Singleton);
container.Register(() => Substitute.For <ICorrelationIdFactory>(),
LifeStyles.Singleton);
container.Register <IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTimeNoOp>(LifeStyles.Singleton);
container.Register <IInternalSerializer, InternalSerializerNoOp>(LifeStyles.Singleton);
}
/// <summary>
/// Registers the fall backs for generic types
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void RegisterFallbacks(IContainer container, RegistrationTypes registrationType)
{
container.RegisterConditional(typeof(ICachePolicy <>), typeof(CachePolicy <>), LifeStyles.Singleton);
if ((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.RegisterConditional(typeof(IProducerQueue <>), typeof(ProducerQueue <>),
LifeStyles.Singleton);
}
}
/// <summary>
/// Select the registration type, and get the affiliated registration form.
/// </summary>
/// <param name="registrationType"></param>
/// <returns>Returns 5KRegistration Form unless RegistrationType is "None"</returns>
public FiveKRegistrationForm SelectRegistrationType(RegistrationTypes registrationType)
{
selectRegistrationType.SelectDropdownItem((int)registrationType);
if (registrationType != RegistrationTypes.None)
{
//linkAddToCart.ScrollToElement(Driver);
linkAddToCart.Click();
return(new FiveKRegistrationForm(Driver));
}
else
{
return(null);
}
}
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
QueueConnection queueConnection)
{
container.Register(() => Substitute.For <IConnectionInformation>(),
LifeStyles.Singleton);
container.Register(() => Substitute.For <ICorrelationIdFactory>(),
LifeStyles.Singleton);
container.Register(
() => Substitute.For <IReceiveMessagesFactory>(), LifeStyles.Singleton);
container.Register(
() => Substitute.For <IReceiveMessagesError>(), LifeStyles.Singleton);
container.Register <IInternalSerializer, InternalSerializerNoOp>(LifeStyles.Singleton);
container.Register <IWorkerNotificationFactory, WorkerNotificationFactoryNoOp>(LifeStyles.Singleton);
}
/// <summary>
/// Setup the default policies.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void SetupDefaultPolicies(IContainer container, RegistrationTypes registrationType)
{
var policies = container.GetInstance <IPolicies>();
var noOp = Policy.NoOp(); //thread safe - can be re-used
var noOpAsync = Policy.NoOpAsync();
//ReceiveMessageFromTransport
policies.Registry[policies.Definition.ReceiveMessageFromTransport] = noOp;
//SendHeartBeat
policies.Registry[policies.Definition.SendHeartBeat] = noOp;
//SendMessage
policies.Registry[policies.Definition.SendMessage] = noOp;
//ReceiveMessageFromTransportASync
policies.Registry[policies.Definition.ReceiveMessageFromTransportAsync] = noOpAsync;
//SendHeartBeatAsync
policies.Registry[policies.Definition.SendHeartBeatAsync] = noOpAsync;
//SendMessageAsync
policies.Registry[policies.Definition.SendMessageAsync] = noOpAsync;
}
/// <summary>
/// Registers the fall backs for generic types
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void RegisterFallbacks(IContainer container, RegistrationTypes registrationType)
{
container.RegisterConditional(typeof(ICachePolicy <>), typeof(CachePolicy <>), LifeStyles.Singleton);
if ((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.RegisterConditional(typeof(IProducerQueue <>), typeof(ProducerQueue <>),
LifeStyles.Singleton);
}
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive &&
(registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.RegisterConditional(typeof(IProducerQueueRpc <>), typeof(ProducerQueueRpc <>), LifeStyles.Singleton);
container.RegisterConditional(typeof(IRpcQueue <,>), typeof(RpcQueue <,>), LifeStyles.Singleton);
container.RegisterConditional(typeof(IMessageProcessingRpcSend <>), typeof(MessageProcessingRpcSend <>), LifeStyles.Singleton);
container.RegisterConditional(typeof(IMessageProcessingRpcReceive <>), typeof(MessageProcessingRpcReceive <>), LifeStyles.Singleton);
}
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
//direct (or memory) connection
//create in memory hold
var connection = container.GetInstance <LiteDbConnectionManager>();
if (!connection.IsSharedConnection)
{
var scope = container.GetInstance <ICreationScope>();
scope.AddScopedObject(connection);
}
var factory = container.GetInstance <LiteDbMessageQueueTransportOptionsFactory>();
var options = factory.Create();
var configurationSend = container.GetInstance <QueueProducerConfiguration>();
var configurationReceive = container.GetInstance <QueueConsumerConfiguration>();
configurationSend.AdditionalConfiguration.SetSetting("LiteDBMessageQueueTransportOptions", options);
configurationReceive.AdditionalConfiguration.SetSetting("LiteDBMessageQueueTransportOptions", options);
var transportReceive = container.GetInstance <TransportConfigurationReceive>();
transportReceive.HeartBeatSupported = options.EnableHeartBeat && options.EnableStatus;
transportReceive.MessageExpirationSupported = options.EnableMessageExpiration;
transportReceive.MessageRollbackSupported = options.EnableStatus;
transportReceive.QueueDelayBehavior.Clear();
transportReceive.QueueDelayBehavior.Add(DefaultQueueDelay());
transportReceive.FatalExceptionDelayBehavior.Clear();
transportReceive.FatalExceptionDelayBehavior.Add(ExceptionDelay());
transportReceive.LockFeatures();
SetupHeartBeat(container);
SetupMessageExpiration(container);
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the requested connection.</param>
public virtual void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
}
/// <summary>
/// Allows a transport to suppress specific warnings for specific types if need.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public virtual void SuppressWarningsIfNeeded(IContainer container, RegistrationTypes registrationType)
{
}
/// <summary> /// Allows a transport to register its dependencies in the IoC container. /// </summary> /// <param name="container">The container.</param> /// <param name="registrationType">Type of the registration.</param> /// <param name="connection">The connection.</param> /// <param name="queue">The queue.</param> public abstract void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue);
/// <summary>
/// Registers the implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connection">The connection.</param>
/// <param name="queue">The queue.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue)
{
Guard.NotNull(() => container, container);
var init = new RelationalDatabaseMessageQueueInit();
init.RegisterStandardImplementations(container, Assembly.GetAssembly(GetType()));
//**all
container.Register <IDbConnectionFactory, DbConnectionFactory>(LifeStyles.Singleton);
container.Register <SqlServerMessageQueueSchema>(LifeStyles.Singleton);
container.Register <IQueueCreation, SqlServerMessageQueueCreation>(LifeStyles.Singleton);
container.Register <IJobSchedulerLastKnownEvent, SqlServerJobSchedulerLastKnownEvent>(LifeStyles.Singleton);
container.Register <SqlServerJobSchema>(LifeStyles.Singleton);
container.Register <ISendJobToQueue, SqlServerSendJobToQueue>(LifeStyles.Singleton);
container.Register <CommandStringCache, SqlServerCommandStringCache>(LifeStyles.Singleton);
container.Register <IOptionsSerialization, OptionsSerialization>(LifeStyles.Singleton);
container.Register <IJobSchema, SqlServerJobSchema>(LifeStyles.Singleton);
container.Register <IReadColumn, ReadColumn>(LifeStyles.Singleton);
container.Register <IBuildMoveToErrorQueueSql, BuildMoveToErrorQueueSql>(LifeStyles.Singleton);
container.Register <ITransportOptionsFactory, TransportOptionsFactory>(LifeStyles.Singleton);
container.Register <IGetTime, SqlServerTime>(LifeStyles.Singleton);
container.Register <IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
container
.Register
<ISqlServerMessageQueueTransportOptionsFactory, SqlServerMessageQueueTransportOptionsFactory>(
LifeStyles.Singleton);
container.Register <ICreationScope, CreationScopeNoOp>(LifeStyles.Singleton);
container.Register <SqlServerCommandStringCache>(LifeStyles.Singleton);
container.Register <IConnectionInformation>(() => new SqlConnectionInformation(queue, connection), LifeStyles.Singleton);
container.Register <SqlServerMessageQueueTransportOptions>(LifeStyles.Singleton);
container.Register <IConnectionHeader <SqlConnection, SqlTransaction, SqlCommand>, ConnectionHeader <SqlConnection, SqlTransaction, SqlCommand> >(LifeStyles.Singleton);
//**all
//**receive
container.Register <IReceiveMessages, SqlServerMessageQueueReceive>(LifeStyles.Transient);
container.Register <IConnectionHolderFactory <SqlConnection, SqlTransaction, SqlCommand>, ConnectionHolderFactory>(LifeStyles.Singleton);
container.Register <CommitMessage>(LifeStyles.Transient);
container.Register <RollbackMessage>(LifeStyles.Transient);
container.Register <HandleMessage>(LifeStyles.Transient);
container.Register <ReceiveMessage>(LifeStyles.Transient);
container.Register <CreateDequeueStatement>(LifeStyles.Singleton);
container.Register <BuildDequeueCommand>(LifeStyles.Singleton);
container.Register <ReadMessage>(LifeStyles.Singleton);
//**receive
//explicit registration of our job exists query
container
.Register <IQueryHandler <DoesJobExistQuery <SqlConnection, SqlTransaction>,
QueueStatuses>,
DoesJobExistQueryHandler <SqlConnection, SqlTransaction> >(LifeStyles.Singleton);
//because we have an explicit registration for job exists, we need to explicitly register the prepare statement
container
.Register <IPrepareQueryHandler <DoesJobExistQuery <SqlConnection, SqlTransaction>,
QueueStatuses>,
DoesJobExistQueryPrepareHandler <SqlConnection, SqlTransaction> >(LifeStyles.Singleton);
container
.Register <ICommandHandlerWithOutput <SendHeartBeatCommand, DateTime?>,
SendHeartBeatCommandHandler>(LifeStyles.Singleton);
container
.Register <ICommandHandler <MoveRecordToErrorQueueCommand>,
MoveRecordToErrorQueueCommandHandler <SqlConnection, SqlTransaction, SqlCommand> >(LifeStyles.Singleton);
//explicit registration of options
container
.Register <IQueryHandler <GetQueueOptionsQuery <SqlServerMessageQueueTransportOptions>, SqlServerMessageQueueTransportOptions>,
GetQueueOptionsQueryHandler <SqlServerMessageQueueTransportOptions> >(LifeStyles.Singleton);
container
.Register <ICommandHandlerWithOutput <DeleteTransactionalMessageCommand, long>,
DeleteTransactionalMessageCommandHandler <SqlConnection, SqlTransaction, SqlCommand> >(LifeStyles.Singleton);
container
.Register <IPrepareQueryHandler <GetQueueOptionsQuery <SqlServerMessageQueueTransportOptions>,
SqlServerMessageQueueTransportOptions>,
GetQueueOptionsQueryPrepareHandler <SqlServerMessageQueueTransportOptions> >(LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandlerWithOutput <,>),
typeof(RetryCommandHandlerOutputDecorator <,>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandler <>),
typeof(RetryCommandHandlerDecorator <>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandlerWithOutputAsync <,>),
typeof(RetryCommandHandlerOutputDecoratorAsync <,>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(IQueryHandler <,>),
typeof(RetryQueryHandlerDecorator <,>), LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateJobTablesCommand <ITable>, QueueCreationResult>),
typeof(CreateJobTablesCommandDecorator), LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateQueueTablesAndSaveConfigurationCommand <ITable>, QueueCreationResult>),
typeof(CreateQueueTablesAndSaveConfigurationDecorator), LifeStyles.Singleton);
}
/// <summary>
/// Allows a transport to register its dependencies in the IoC container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="queueConnection">Queue and connection information.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
QueueConnection queueConnection)
{
RegisterImplementations(container, registrationType, queueConnection, Assembly.GetAssembly(GetType()));
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
var options = container.GetInstance<RedisQueueTransportOptions>();
var configurationSend = container.GetInstance<QueueProducerConfiguration>();
var configurationReceive = container.GetInstance<QueueConsumerConfiguration>();
configurationSend.AdditionalConfiguration.SetSetting("RedisQueueTransportOptions", options);
configurationReceive.AdditionalConfiguration.SetSetting("RedisQueueTransportOptions", options);
var transportReceive = container.GetInstance<TransportConfigurationReceive>();
transportReceive.HeartBeatSupported = true;
transportReceive.MessageExpirationSupported = true;
transportReceive.MessageRollbackSupported = true;
transportReceive.QueueDelayBehavior.Clear();
transportReceive.QueueDelayBehavior.Add(DefaultQueueDelay());
transportReceive.FatalExceptionDelayBehavior.Clear();
transportReceive.FatalExceptionDelayBehavior.Add(ExceptionDelay());
options.TimeServer = TimeLocations.RedisServer;
transportReceive.LockFeatures();
SetupHeartBeat(container);
SetupMessageExpiration(container);
//only compile scripts if the container is not in verification mode
if (!container.IsVerifying)
{
SetupScripts(container);
}
}
/// <summary>
/// Registers the defaults implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void RegisterDefaults(IContainer container,
RegistrationTypes registrationType)
{
Guard.NotNull(() => container, container);
//default types that are always registered in the container for both send and receive
RegisterSharedDefaults(container);
//object cache
container.Register<ObjectCache>(() => new MemoryCache("DotNetWorkQueueCache"), LifeStyles.Singleton);
//object pool for linq
container.Register<IObjectPool<DynamicCodeCompiler>>(
() =>
new ObjectPool<DynamicCodeCompiler>(20,
() => new DynamicCodeCompiler(container.GetInstance<ILogFactory>())), LifeStyles.Singleton);
//created outside of the queue as part of setup, this must be a singleton.
//all queues created from the setup class share the same message interceptors
container.Register<IMessageInterceptorRegistrar, Interceptors.MessageInterceptors>(LifeStyles.Singleton);
container.Register<MessageProcessingMode>(LifeStyles.Singleton);
container.Register<IMessageFactory, MessageFactory>(LifeStyles.Singleton);
container.Register<IMessageContextDataFactory, MessageContextDataFactory>(LifeStyles.Singleton);
container.Register<IJobSchedulerMetaData, JobSchedulerMetaData>(LifeStyles.Singleton);
container.Register<IQueueCancelWork, QueueCancelWork>(LifeStyles.Singleton);
container.Register<ASerializer, RootSerializer>(LifeStyles.Singleton);
container.Register<ISerializer, JsonSerializer>(LifeStyles.Singleton);
container.Register<IExpressionSerializer, JsonExpressionSerializer>(LifeStyles.Singleton);
container.Register<IQueueDelayFactory, QueueDelayFactory>(LifeStyles.Singleton);
container.Register<ILinqCompiler, LinqCompiler>(LifeStyles.Singleton);
container.Register<IInternalSerializer, JsonSerializerInternal>(LifeStyles.Singleton);
container.Register<ICompositeSerialization, CompositeSerialization>(LifeStyles.Singleton);
container.Register<IHeaders, Headers>(LifeStyles.Singleton);
container.Register<IStandardHeaders, StandardHeaders>(LifeStyles.Singleton);
container.Register<ICustomHeaders, CustomHeaders>(LifeStyles.Singleton);
//because of it's usage in 'standard' modules, this must always be added, even if RPC is not enabled.
//otherwise, the IoC container can't create the producer queue.
container.Register<IRpcTimeoutFactory, RpcTimeoutFactory>(LifeStyles.Singleton);
container.Register<IMessageMethodHandling, MessageMethodHandling>(LifeStyles.Singleton);
container.Register<IRegisterMessagesAsync, RegisterMessagesAsync>(LifeStyles.Singleton);
container.Register<IRegisterMessages, RegisterMessages>(LifeStyles.Singleton);
container.Register<IMessageHandlerRegistration, MessageHandlerRegistration>(LifeStyles.Singleton);
container
.Register<IMessageHandlerRegistrationAsync, MessageHandlerRegistrationAsync>(LifeStyles.Singleton);
container.Register<IGenerateReceivedMessage, GenerateReceivedMessage>(LifeStyles.Singleton);
container.Register<IMetrics, MetricsNoOp>(LifeStyles.Singleton);
//implementations required to send messages
if ((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.Register<ISentMessageFactory, SentMessageFactory>(LifeStyles.Singleton);
container.Register<QueueConfigurationSend>(LifeStyles.Singleton);
container.Register<QueueProducerConfiguration>(LifeStyles.Singleton);
container.Register<TransportConfigurationSend>(LifeStyles.Singleton);
container.Register<GenerateMessageHeaders>(LifeStyles.Singleton);
container.Register<AddStandardMessageHeaders>(LifeStyles.Singleton);
container.Register<IProducerMethodQueue, ProducerMethodQueue>(LifeStyles.Singleton);
container.Register<IProducerMethodJobQueue, ProducerMethodJobQueue>(LifeStyles.Singleton);
}
//implementations for Receiving messages
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive)
{
container.Register<TransportConfigurationReceive>(LifeStyles.Singleton);
container.Register<IConsumerQueue, ConsumerQueue>(LifeStyles.Singleton);
container.Register<IConsumerMethodQueue, ConsumerMethodQueue>(LifeStyles.Singleton);
container.Register<IConsumerQueueAsync, ConsumerQueueAsync>(LifeStyles.Singleton);
container.Register<IConsumerQueueScheduler, Scheduler>(LifeStyles.Singleton);
container.Register<IConsumerMethodQueueScheduler, SchedulerMethod>(LifeStyles.Singleton);
container.Register<QueueConsumerConfiguration>(LifeStyles.Singleton);
container.Register<IHandleMessage, HandleMessage>(LifeStyles.Singleton);
container.Register<IReceivedMessageFactory, ReceivedMessageFactory>(LifeStyles.Singleton);
container.Register<IRetryDelayFactory, RetryDelayFactory>(LifeStyles.Singleton);
container.Register<IRetryDelay, RetryDelay>(LifeStyles.Transient);
container.Register<IWorkGroup, WorkGroupNoOp>(LifeStyles.Singleton);
container.Register<IRetryInformationFactory, RetryInformationFactory>(LifeStyles.Singleton);
container.Register<IWorkerWaitForEventOrCancel, WorkerWaitForEventOrCancel>(LifeStyles.Singleton);
container.Register<IWaitForEventOrCancelThreadPool, WaitForEventOrCancelThreadPool>(LifeStyles.Singleton);
container.Register<IMessageContext, MessageContext>(LifeStyles.Transient);
container.Register<IMessageContextFactory, MessageContextFactory>(LifeStyles.Singleton);
container.Register<IWorkerCollection, WorkerCollection>(LifeStyles.Singleton);
container.Register<IWorker, Worker>(LifeStyles.Transient);
container.Register<IPrimaryWorker, PrimaryWorker>(LifeStyles.Transient);
container.Register<IPrimaryWorkerFactory, PrimaryWorkerFactory>(LifeStyles.Singleton);
container.Register<IWorkerNameFactory, WorkerNameFactory>(LifeStyles.Singleton);
container
.Register
<IWorkerHeartBeatNotificationFactory, WorkerHeartBeatNotificationFactory>(LifeStyles.Singleton);
container.Register<IWorkerHeartBeatNotification, WorkerHeartBeatNotification>(LifeStyles.Transient);
container.Register<ProcessMessage, ProcessMessage>(LifeStyles.Transient);
container.Register<IMessageProcessingFactory, MessageProcessingFactory>(LifeStyles.Singleton);
container.Register<MessageProcessing, MessageProcessing>(LifeStyles.Transient);
container.Register<ITaskSchedulerConfiguration, TaskSchedulerConfiguration>(LifeStyles.Singleton);
container.Register<ATaskScheduler, SmartThreadPoolTaskScheduler>(LifeStyles.Singleton);
container.Register<SchedulerMessageHandler, SchedulerMessageHandler>(LifeStyles.Singleton);
container.Register<ITaskFactory, SchedulerTaskFactory>(LifeStyles.Singleton);
container.Register<ITaskSchedulerFactory, TaskSchedulerFactory>(LifeStyles.Singleton);
container.Register<ITaskFactoryFactory, TaskFactoryFactory>(LifeStyles.Singleton);
container.Register<IWorkerNotification, WorkerNotification>(LifeStyles.Transient);
container.Register<IWorkerNotificationFactory, WorkerNotificationFactory>(LifeStyles.Singleton);
container.Register<IAbortWorkerThread, AbortWorkerThread>(LifeStyles.Singleton);
container.Register<StopThread>(LifeStyles.Singleton);
container.Register<MessageExceptionHandler>(LifeStyles.Singleton);
container.Register<MessageProcessingAsync>(LifeStyles.Transient);
container.Register<ProcessMessageAsync>(LifeStyles.Singleton);
container.Register<IClearExpiredMessagesMonitor, ClearExpiredMessagesMonitor>(LifeStyles.Singleton);
container.Register<IHeartBeatThreadPoolFactory, HeartBeatThreadPoolFactory>(LifeStyles.Singleton);
container.Register<IHeartBeatThreadPool, HeartBeatThreadPool>(LifeStyles.Singleton);
container.Register<IHeartBeatWorkerFactory, HeartBeatWorkerFactory>(LifeStyles.Singleton);
container.Register<IQueueWaitFactory, QueueWaitFactory>(LifeStyles.Singleton);
container.Register<IHeartBeatMonitor, HeartBeatMonitor>(LifeStyles.Singleton);
container.Register<IQueueMonitor, QueueMonitor>(LifeStyles.Singleton);
container.Register<HeartBeatMonitorNoOp>(LifeStyles.Singleton);
container.Register<ClearExpiredMessagesMonitorNoOp>(LifeStyles.Singleton);
container.Register<IWorkerConfiguration, WorkerConfiguration>(LifeStyles.Singleton);
container.Register<IHeartBeatConfiguration, HeartBeatConfiguration>(LifeStyles.Singleton);
container.Register<IHeartBeatThreadPoolConfiguration, HeartBeatThreadPoolConfiguration>(
LifeStyles.Singleton);
container.Register<IMessageExpirationConfiguration, MessageExpirationConfiguration>(LifeStyles.Singleton);
container.Register<IMessageHandler, MessageHandler>(LifeStyles.Singleton);
container.Register<IMessageHandlerAsync, MessageHandlerAsync>(LifeStyles.Singleton);
container.Register<IWorkerFactory, WorkerFactory>(LifeStyles.Singleton);
container.Register<StopWorker>(LifeStyles.Singleton);
container.Register<ICommitMessage, CommitMessage>(LifeStyles.Singleton);
container.Register<IRollbackMessage, RollbackMessage>(LifeStyles.Singleton);
container.Register<WaitForThreadToFinish>(LifeStyles.Singleton);
container.Register<WorkerTerminate>(LifeStyles.Singleton);
container.Register<IWaitForEventOrCancelWorker, WaitForEventOrCancelWorker>(LifeStyles.Singleton);
container.Register<IWaitForEventOrCancelFactory, WaitForEventOrCancelFactory>(LifeStyles.Singleton);
container.Register<ThreadPoolConfiguration>(LifeStyles.Singleton);
}
//implementations for RPC / or a duplex transport
//NOTE - we don't bother to tell the difference between RPC / duplex
//so it's possible these are registered, but never actually used.
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive &&
((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send))
{
container.Register<IRpcMethodQueue, RpcMethodQueue>(LifeStyles.Singleton);
container.Register<IClearExpiredMessagesRpcMonitor, ClearExpiredMessagesRpcMonitor>
(LifeStyles.Singleton);
container.Register<IResponseIdFactory, ResponseIdFactory>(LifeStyles.Singleton);
container.Register<IRpcContextFactory, RpcContextFactory>(LifeStyles.Singleton);
container.Register<QueueRpcConfiguration>(LifeStyles.Singleton);
}
}
/// <summary>
/// Allows a transport to register its dependencies in the IoC container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="queueConnection">Queue and connection information.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, QueueConnection queueConnection)
{
RegisterConnectionImplementation.RegisterImplementations(container, queueConnection);
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the requested connection.</param>
public virtual void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
}
/// <summary> /// Allows a transport to register its dependencies in the IoC container. /// </summary> /// <param name="container">The container.</param> /// <param name="registrationType">Type of the registration.</param> /// <param name="queueConnection">Queue and connection information.</param> public abstract void RegisterImplementations(IContainer container, RegistrationTypes registrationType, QueueConnection queueConnection);
/// <summary>
/// Allows a transport to suppress specific warnings for specific types if newed.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public virtual void SuppressWarningsIfNeeded(IContainer container, RegistrationTypes registrationType)
{
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
var factory = container.GetInstance<ISqLiteMessageQueueTransportOptionsFactory>();
var options = factory.Create();
var configurationSend = container.GetInstance<QueueProducerConfiguration>();
var configurationReceive = container.GetInstance<QueueConsumerConfiguration>();
configurationSend.AdditionalConfiguration.SetSetting("SQLiteMessageQueueTransportOptions", options);
configurationReceive.AdditionalConfiguration.SetSetting("SQLiteMessageQueueTransportOptions", options);
var transportReceive = container.GetInstance<TransportConfigurationReceive>();
transportReceive.HeartBeatSupported = options.EnableHeartBeat && options.EnableStatus;
transportReceive.MessageExpirationSupported = options.EnableMessageExpiration ||
options.QueueType == QueueTypes.RpcReceive ||
options.QueueType == QueueTypes.RpcSend;
transportReceive.MessageRollbackSupported = options.EnableStatus;
transportReceive.QueueDelayBehavior.Clear();
transportReceive.QueueDelayBehavior.Add(DefaultQueueDelay());
transportReceive.FatalExceptionDelayBehavior.Clear();
transportReceive.FatalExceptionDelayBehavior.Add(ExceptionDelay());
transportReceive.LockFeatures();
SetupHeartBeat(container);
SetupMessageExpiration(container);
//create in memory hold
var connection = container.GetInstance<IConnectionInformation>();
var fileName = GetFileNameFromConnectionString.GetFileName(connection.ConnectionString);
if(fileName.IsInMemory)
{
var scope = container.GetInstance<ICreationScope>();
var holder = new SqLiteHoldConnection();
holder.AddConnectionIfNeeded(connection);
scope.AddScopedObject(holder);
}
}
/// <summary>
/// Registers the defaults implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void RegisterDefaults(IContainer container,
RegistrationTypes registrationType)
{
Guard.NotNull(() => container, container);
//default types that are always registered in the container for both send and receive
RegisterSharedDefaults(container);
//object cache
var memoryCache = new MemoryCache(new MemoryCacheOptions());
var memoryCacheProvider = new MemoryCacheProvider(memoryCache);
container.Register(() => memoryCacheProvider, LifeStyles.Singleton);
//object pool for linq
container.Register <IObjectPool <DynamicCodeCompiler> >(
() =>
new ObjectPool <DynamicCodeCompiler>(20,
() => new DynamicCodeCompiler(container.GetInstance <ILogger>())), LifeStyles.Singleton);
//created outside of the queue as part of setup, this must be a singleton.
//all queues created from the setup class share the same message interceptors
container.Register <IMessageInterceptorRegistrar, MessageInterceptors>(LifeStyles.Singleton);
container.Register <MessageProcessingMode>(LifeStyles.Singleton);
container.Register <IGetPreviousMessageErrors, GetPreviousMessageErrorsNoOp>(LifeStyles.Singleton);
container.Register <IMessageFactory, MessageFactory>(LifeStyles.Singleton);
container.Register <IJobSchedulerMetaData, JobSchedulerMetaData>(LifeStyles.Singleton);
container.Register <IQueueCancelWork, QueueCancelWork>(LifeStyles.Singleton);
container.Register <ASerializer, RootSerializer>(LifeStyles.Singleton);
container.Register <ISerializer, JsonSerializer>(LifeStyles.Singleton);
container.Register <IExpressionSerializer, JsonExpressionSerializer>(LifeStyles.Singleton);
container.Register <IQueueDelayFactory, QueueDelayFactory>(LifeStyles.Singleton);
container.Register <ILinqCompiler, LinqCompiler>(LifeStyles.Singleton);
container.Register <IGetHeader, GetHeaderDefault>(LifeStyles.Singleton);
container.Register <IInternalSerializer, JsonSerializerInternal>(LifeStyles.Singleton);
container.Register <ICompositeSerialization, CompositeSerialization>(LifeStyles.Singleton);
container.Register <IMessageMethodHandling, MessageMethodHandling>(LifeStyles.Singleton);
container.Register <IRegisterMessagesAsync, RegisterMessagesAsync>(LifeStyles.Singleton);
container.Register <IRegisterMessages, RegisterMessages>(LifeStyles.Singleton);
container.Register <IMessageHandlerRegistration, MessageHandlerRegistration>(LifeStyles.Singleton);
container
.Register <IMessageHandlerRegistrationAsync, MessageHandlerRegistrationAsync>(LifeStyles.Singleton);
container.Register <IGenerateReceivedMessage, GenerateReceivedMessage>(LifeStyles.Singleton);
container.Register <IMetrics, MetricsNoOp>(LifeStyles.Singleton);
//implementations required to send messages
if ((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.Register <ISentMessageFactory, SentMessageFactory>(LifeStyles.Singleton);
container.Register <QueueConfigurationSend>(LifeStyles.Singleton);
container.Register <QueueProducerConfiguration>(LifeStyles.Singleton);
container.Register <TransportConfigurationSend>(LifeStyles.Singleton);
container.Register <GenerateMessageHeaders>(LifeStyles.Singleton);
container.Register <AddStandardMessageHeaders>(LifeStyles.Singleton);
container.Register <IProducerMethodQueue, ProducerMethodQueue>(LifeStyles.Singleton);
container.Register <IProducerMethodJobQueue, ProducerMethodJobQueue>(LifeStyles.Singleton);
}
//implementations for Receiving messages
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive)
{
container.Register <TransportConfigurationReceive>(LifeStyles.Singleton);
container.Register <IConsumerQueue, ConsumerQueue>(LifeStyles.Singleton);
container.Register <IConsumerMethodQueue, ConsumerMethodQueue>(LifeStyles.Singleton);
container.Register <IConsumerQueueAsync, ConsumerQueueAsync>(LifeStyles.Singleton);
container.Register <IConsumerQueueScheduler, Scheduler>(LifeStyles.Singleton);
container.Register <IConsumerMethodQueueScheduler, SchedulerMethod>(LifeStyles.Singleton);
container.Register <QueueConsumerConfiguration>(LifeStyles.Singleton);
container.Register <IHandleMessage, HandleMessage>(LifeStyles.Singleton);
container.Register <IReceivedMessageFactory, ReceivedMessageFactory>(LifeStyles.Singleton);
container.Register <IRetryDelayFactory, RetryDelayFactory>(LifeStyles.Singleton);
container.Register <IRetryDelay, RetryDelay>(LifeStyles.Transient);
container.Register <IWorkGroup, WorkGroupNoOp>(LifeStyles.Singleton);
container.Register <IRetryInformationFactory, RetryInformationFactory>(LifeStyles.Singleton);
container.Register <IWorkerWaitForEventOrCancel, WorkerWaitForEventOrCancel>(LifeStyles.Singleton);
container.Register <IWaitForEventOrCancelThreadPool, WaitForEventOrCancelThreadPool>(LifeStyles.Singleton);
container.Register <IMessageContext, MessageContext>(LifeStyles.Transient);
container.AddTypeThatNeedsWarningSuppression(typeof(IMessageContext));
container.AddTypeThatNeedsWarningSuppression(typeof(MessageContext));
container.Register <IMessageContextFactory, MessageContextFactory>(LifeStyles.Singleton);
container.Register <IWorkerCollection, WorkerCollection>(LifeStyles.Singleton);
container.Register <IWorker, Worker>(LifeStyles.Transient);
container.AddTypeThatNeedsWarningSuppression(typeof(IWorker));
container.Register <IPrimaryWorker, PrimaryWorker>(LifeStyles.Transient);
container.AddTypeThatNeedsWarningSuppression(typeof(IPrimaryWorker));
container.Register <IPrimaryWorkerFactory, PrimaryWorkerFactory>(LifeStyles.Singleton);
container.Register <IWorkerNameFactory, WorkerNameFactory>(LifeStyles.Singleton);
container
.Register
<IWorkerHeartBeatNotificationFactory, WorkerHeartBeatNotificationFactory>(LifeStyles.Singleton);
container.Register <IWorkerHeartBeatNotification, WorkerHeartBeatNotification>(LifeStyles.Transient);
container.Register <ProcessMessage, ProcessMessage>(LifeStyles.Transient);
container.Register <IMessageProcessingFactory, MessageProcessingFactory>(LifeStyles.Singleton);
container.Register <MessageProcessing, MessageProcessing>(LifeStyles.Transient);
container.Register <ITaskSchedulerConfiguration, TaskSchedulerConfiguration>(LifeStyles.Singleton);
container.Register <ATaskScheduler, SmartThreadPoolTaskScheduler>(LifeStyles.Singleton);
container.Register <ISchedulerMessageHandler, SchedulerMessageHandler>(LifeStyles.Singleton);
container.Register <ITaskFactory, SchedulerTaskFactory>(LifeStyles.Singleton);
container.Register <ITaskSchedulerFactory, TaskSchedulerFactory>(LifeStyles.Singleton);
container.Register <ITaskFactoryFactory, TaskFactoryFactory>(LifeStyles.Singleton);
container.Register <IWorkerNotification, WorkerNotification>(LifeStyles.Transient);
container.Register <IWorkerNotificationFactory, WorkerNotificationFactory>(LifeStyles.Singleton);
container.Register <IAbortWorkerThread, AbortWorkerThread>(LifeStyles.Singleton);
container.Register <StopThread>(LifeStyles.Singleton);
container.Register <MessageExceptionHandler>(LifeStyles.Singleton);
container.Register <MessageProcessingAsync>(LifeStyles.Transient);
container.Register <ProcessMessageAsync>(LifeStyles.Singleton);
container.Register <IClearExpiredMessagesMonitor, ClearExpiredMessagesMonitor>(LifeStyles.Singleton);
container.Register <IClearErrorMessagesMonitor, ClearErrorMessagesMonitor>(LifeStyles.Singleton);
container.Register <IHeartBeatScheduler, HeartBeatScheduler>(LifeStyles.Singleton);
container.Register <IHeartBeatWorkerFactory, HeartBeatWorkerFactory>(LifeStyles.Singleton);
container.Register <IQueueWaitFactory, QueueWaitFactory>(LifeStyles.Singleton);
container.Register <IHeartBeatMonitor, HeartBeatMonitor>(LifeStyles.Singleton);
container.Register <IQueueMonitor, QueueMonitor>(LifeStyles.Singleton);
container.Register <HeartBeatMonitorNoOp>(LifeStyles.Singleton);
container.Register <ClearExpiredMessagesMonitorNoOp>(LifeStyles.Singleton);
container.Register <IWorkerConfiguration, WorkerConfiguration>(LifeStyles.Singleton);
container.Register <IHeartBeatConfiguration, HeartBeatConfiguration>(LifeStyles.Singleton);
container.Register <IHeartBeatThreadPoolConfiguration, HeartBeatThreadPoolConfiguration>(
LifeStyles.Singleton);
container.Register <IMessageExpirationConfiguration, MessageExpirationConfiguration>(LifeStyles.Singleton);
container.Register <IMessageErrorConfiguration, MessageErrorConfiguration>(LifeStyles.Singleton);
container.Register <IMessageHandler, MessageHandler>(LifeStyles.Singleton);
container.Register <IMessageHandlerAsync, MessageHandlerAsync>(LifeStyles.Singleton);
container.Register <IWorkerFactory, WorkerFactory>(LifeStyles.Singleton);
container.Register <StopWorker>(LifeStyles.Singleton);
container.Register <ICommitMessage, CommitMessage>(LifeStyles.Singleton);
container.Register <IRollbackMessage, RollbackMessage>(LifeStyles.Singleton);
container.Register <WaitForThreadToFinish>(LifeStyles.Singleton);
container.Register <WorkerTerminate>(LifeStyles.Singleton);
container.Register <IWaitForEventOrCancelWorker, WaitForEventOrCancelWorker>(LifeStyles.Singleton);
container.Register <IWaitForEventOrCancelFactory, WaitForEventOrCancelFactory>(LifeStyles.Singleton);
container.Register <ThreadPoolConfiguration>(LifeStyles.Singleton);
}
}
/// <summary>
/// Registers the fall backs for generic types
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void RegisterFallbacks(IContainer container, RegistrationTypes registrationType)
{
container.RegisterConditional(typeof(ICachePolicy<>), typeof(CachePolicy<>), LifeStyles.Singleton);
if ((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.RegisterConditional(typeof (IProducerQueue<>), typeof (ProducerQueue<>),
LifeStyles.Singleton);
}
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive &&
((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send))
{
container.RegisterConditional(typeof(IProducerQueueRpc<>), typeof(ProducerQueueRpc<>), LifeStyles.Singleton);
container.RegisterConditional(typeof(IRpcQueue<,>), typeof(RpcQueue<,>), LifeStyles.Singleton);
container.RegisterConditional(typeof(IMessageProcessingRpcSend<>), typeof(MessageProcessingRpcSend<>), LifeStyles.Singleton);
container.RegisterConditional(typeof(IMessageProcessingRpcReceive<>), typeof(MessageProcessingRpcReceive<>), LifeStyles.Singleton);
}
}
/// <summary>
/// Allows the transport to set default configuration settings or other values
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connectionType">Type of the connection.</param>
public override void SetDefaultsIfNeeded(IContainer container, RegistrationTypes registrationType, ConnectionTypes connectionType)
{
var factory = container.GetInstance<IPostgreSqlMessageQueueTransportOptionsFactory>();
var options = factory.Create();
var configurationSend = container.GetInstance<QueueProducerConfiguration>();
var configurationReceive = container.GetInstance<QueueConsumerConfiguration>();
configurationSend.AdditionalConfiguration.SetSetting("PostgreSQLMessageQueueTransportOptions", options);
configurationReceive.AdditionalConfiguration.SetSetting("PostgreSQLMessageQueueTransportOptions", options);
var transportReceive = container.GetInstance<TransportConfigurationReceive>();
transportReceive.HeartBeatSupported = options.EnableHeartBeat && options.EnableStatus &&
!options.EnableHoldTransactionUntilMessageCommited;
transportReceive.MessageExpirationSupported = options.EnableMessageExpiration ||
options.QueueType == QueueTypes.RpcReceive ||
options.QueueType == QueueTypes.RpcSend;
transportReceive.MessageRollbackSupported = options.EnableStatus ||
options.EnableHoldTransactionUntilMessageCommited;
transportReceive.QueueDelayBehavior.Clear();
transportReceive.QueueDelayBehavior.Add(DefaultQueueDelay());
transportReceive.FatalExceptionDelayBehavior.Clear();
transportReceive.FatalExceptionDelayBehavior.Add(ExceptionDelay());
transportReceive.LockFeatures();
SetupHeartBeat(container);
SetupMessageExpiration(container);
}
/// <summary>
/// Suppress warnings for specific cases.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void SuppressWarningsIfNeeded(IContainer container, RegistrationTypes registrationType)
{
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive)
{
container.SuppressDiagnosticWarning(typeof(IMessageContext),
DiagnosticTypes.DisposableTransientComponent,
"IMessageContext is explicitly disposed of via a using statement");
container.SuppressDiagnosticWarning(typeof(MessageContext),
DiagnosticTypes.DisposableTransientComponent,
"MessageContext is explicitly disposed of via a using statement");
container.SuppressDiagnosticWarning(typeof(ATaskScheduler),
DiagnosticTypes.DisposableTransientComponent,
"ATaskScheduler is disposed of via its parent queue if created by this library. Otherwise, the caller of this library is responsible for disposing the task scheduler");
container.SuppressDiagnosticWarning(typeof(IWorker),
DiagnosticTypes.DisposableTransientComponent,
"IWorker is disposed of via the worker collection");
container.SuppressDiagnosticWarning(typeof(IPrimaryWorker),
DiagnosticTypes.DisposableTransientComponent,
"IPrimaryWorker is disposed of via the queue");
}
}
/// <summary>
/// Registers the defaults implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
public static void RegisterDefaults(IContainer container,
RegistrationTypes registrationType)
{
Guard.NotNull(() => container, container);
//default types that are always registered in the container for both send and receive
RegisterSharedDefaults(container);
//object cache
container.Register(() => CacheFactory.Build("DotNetWorkQueueCache", settings =>
{
#if NETFULL
settings.WithSystemRuntimeCacheHandle("LinqCache");
#else
settings.WithMicrosoftMemoryCacheHandle("LinqCache");
#endif
}), LifeStyles.Singleton);
//object pool for linq
container.Register <IObjectPool <DynamicCodeCompiler> >(
() =>
new ObjectPool <DynamicCodeCompiler>(20,
() => new DynamicCodeCompiler(container.GetInstance <ILogFactory>())), LifeStyles.Singleton);
//created outside of the queue as part of setup, this must be a singleton.
//all queues created from the setup class share the same message interceptors
container.Register <IMessageInterceptorRegistrar, MessageInterceptors>(LifeStyles.Singleton);
container.Register <MessageProcessingMode>(LifeStyles.Singleton);
container.Register <IMessageFactory, MessageFactory>(LifeStyles.Singleton);
container.Register <IMessageContextDataFactory, MessageContextDataFactory>(LifeStyles.Singleton);
container.Register <IJobSchedulerMetaData, JobSchedulerMetaData>(LifeStyles.Singleton);
container.Register <IQueueCancelWork, QueueCancelWork>(LifeStyles.Singleton);
container.Register <ASerializer, RootSerializer>(LifeStyles.Singleton);
container.Register <ISerializer, JsonSerializer>(LifeStyles.Singleton);
container.Register <IExpressionSerializer, JsonExpressionSerializer>(LifeStyles.Singleton);
container.Register <IQueueDelayFactory, QueueDelayFactory>(LifeStyles.Singleton);
container.Register <ILinqCompiler, LinqCompiler>(LifeStyles.Singleton);
container.Register <IInternalSerializer, JsonSerializerInternal>(LifeStyles.Singleton);
container.Register <ICompositeSerialization, CompositeSerialization>(LifeStyles.Singleton);
container.Register <IHeaders, Headers>(LifeStyles.Singleton);
container.Register <IStandardHeaders, StandardHeaders>(LifeStyles.Singleton);
container.Register <ICustomHeaders, CustomHeaders>(LifeStyles.Singleton);
//because of it's usage in 'standard' modules, this must always be added, even if RPC is not enabled.
//otherwise, the IoC container can't create the producer queue.
container.Register <IRpcTimeoutFactory, RpcTimeoutFactory>(LifeStyles.Singleton);
container.Register <IMessageMethodHandling, MessageMethodHandling>(LifeStyles.Singleton);
container.Register <IRegisterMessagesAsync, RegisterMessagesAsync>(LifeStyles.Singleton);
container.Register <IRegisterMessages, RegisterMessages>(LifeStyles.Singleton);
container.Register <IMessageHandlerRegistration, MessageHandlerRegistration>(LifeStyles.Singleton);
container
.Register <IMessageHandlerRegistrationAsync, MessageHandlerRegistrationAsync>(LifeStyles.Singleton);
container.Register <IGenerateReceivedMessage, GenerateReceivedMessage>(LifeStyles.Singleton);
container.Register <IMetrics, MetricsNoOp>(LifeStyles.Singleton);
//implementations required to send messages
if ((registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.Register <ISentMessageFactory, SentMessageFactory>(LifeStyles.Singleton);
container.Register <QueueConfigurationSend>(LifeStyles.Singleton);
container.Register <QueueProducerConfiguration>(LifeStyles.Singleton);
container.Register <TransportConfigurationSend>(LifeStyles.Singleton);
container.Register <GenerateMessageHeaders>(LifeStyles.Singleton);
container.Register <AddStandardMessageHeaders>(LifeStyles.Singleton);
container.Register <IProducerMethodQueue, ProducerMethodQueue>(LifeStyles.Singleton);
container.Register <IProducerMethodJobQueue, ProducerMethodJobQueue>(LifeStyles.Singleton);
}
//implementations for Receiving messages
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive)
{
container.Register <TransportConfigurationReceive>(LifeStyles.Singleton);
container.Register <IConsumerQueue, ConsumerQueue>(LifeStyles.Singleton);
container.Register <IConsumerMethodQueue, ConsumerMethodQueue>(LifeStyles.Singleton);
container.Register <IConsumerQueueAsync, ConsumerQueueAsync>(LifeStyles.Singleton);
container.Register <IConsumerQueueScheduler, Scheduler>(LifeStyles.Singleton);
container.Register <IConsumerMethodQueueScheduler, SchedulerMethod>(LifeStyles.Singleton);
container.Register <QueueConsumerConfiguration>(LifeStyles.Singleton);
container.Register <IHandleMessage, HandleMessage>(LifeStyles.Singleton);
container.Register <IReceivedMessageFactory, ReceivedMessageFactory>(LifeStyles.Singleton);
container.Register <IRetryDelayFactory, RetryDelayFactory>(LifeStyles.Singleton);
container.Register <IRetryDelay, RetryDelay>(LifeStyles.Transient);
container.Register <IWorkGroup, WorkGroupNoOp>(LifeStyles.Singleton);
container.Register <IRetryInformationFactory, RetryInformationFactory>(LifeStyles.Singleton);
container.Register <IWorkerWaitForEventOrCancel, WorkerWaitForEventOrCancel>(LifeStyles.Singleton);
container.Register <IWaitForEventOrCancelThreadPool, WaitForEventOrCancelThreadPool>(LifeStyles.Singleton);
container.Register <IMessageContext, MessageContext>(LifeStyles.Transient);
container.Register <IMessageContextFactory, MessageContextFactory>(LifeStyles.Singleton);
container.Register <IWorkerCollection, WorkerCollection>(LifeStyles.Singleton);
container.Register <IWorker, Worker>(LifeStyles.Transient);
container.Register <IPrimaryWorker, PrimaryWorker>(LifeStyles.Transient);
container.Register <IPrimaryWorkerFactory, PrimaryWorkerFactory>(LifeStyles.Singleton);
container.Register <IWorkerNameFactory, WorkerNameFactory>(LifeStyles.Singleton);
container
.Register
<IWorkerHeartBeatNotificationFactory, WorkerHeartBeatNotificationFactory>(LifeStyles.Singleton);
container.Register <IWorkerHeartBeatNotification, WorkerHeartBeatNotification>(LifeStyles.Transient);
container.Register <ProcessMessage, ProcessMessage>(LifeStyles.Transient);
container.Register <IMessageProcessingFactory, MessageProcessingFactory>(LifeStyles.Singleton);
container.Register <MessageProcessing, MessageProcessing>(LifeStyles.Transient);
container.Register <ITaskSchedulerConfiguration, TaskSchedulerConfiguration>(LifeStyles.Singleton);
container.Register <ATaskScheduler, SmartThreadPoolTaskScheduler>(LifeStyles.Singleton);
container.Register <SchedulerMessageHandler, SchedulerMessageHandler>(LifeStyles.Singleton);
container.Register <ITaskFactory, SchedulerTaskFactory>(LifeStyles.Singleton);
container.Register <ITaskSchedulerFactory, TaskSchedulerFactory>(LifeStyles.Singleton);
container.Register <ITaskFactoryFactory, TaskFactoryFactory>(LifeStyles.Singleton);
container.Register <IWorkerNotification, WorkerNotification>(LifeStyles.Transient);
container.Register <IWorkerNotificationFactory, WorkerNotificationFactory>(LifeStyles.Singleton);
container.Register <IAbortWorkerThread, AbortWorkerThread>(LifeStyles.Singleton);
container.Register <StopThread>(LifeStyles.Singleton);
container.Register <MessageExceptionHandler>(LifeStyles.Singleton);
container.Register <MessageProcessingAsync>(LifeStyles.Transient);
container.Register <ProcessMessageAsync>(LifeStyles.Singleton);
container.Register <IClearExpiredMessagesMonitor, ClearExpiredMessagesMonitor>(LifeStyles.Singleton);
container.Register <IHeartBeatScheduler, HeartBeatScheduler>(LifeStyles.Singleton);
container.Register <IHeartBeatWorkerFactory, HeartBeatWorkerFactory>(LifeStyles.Singleton);
container.Register <IQueueWaitFactory, QueueWaitFactory>(LifeStyles.Singleton);
container.Register <IHeartBeatMonitor, HeartBeatMonitor>(LifeStyles.Singleton);
container.Register <IQueueMonitor, QueueMonitor>(LifeStyles.Singleton);
container.Register <HeartBeatMonitorNoOp>(LifeStyles.Singleton);
container.Register <ClearExpiredMessagesMonitorNoOp>(LifeStyles.Singleton);
container.Register <IWorkerConfiguration, WorkerConfiguration>(LifeStyles.Singleton);
container.Register <IHeartBeatConfiguration, HeartBeatConfiguration>(LifeStyles.Singleton);
container.Register <IHeartBeatThreadPoolConfiguration, HeartBeatThreadPoolConfiguration>(
LifeStyles.Singleton);
container.Register <IMessageExpirationConfiguration, MessageExpirationConfiguration>(LifeStyles.Singleton);
container.Register <IMessageHandler, MessageHandler>(LifeStyles.Singleton);
container.Register <IMessageHandlerAsync, MessageHandlerAsync>(LifeStyles.Singleton);
container.Register <IWorkerFactory, WorkerFactory>(LifeStyles.Singleton);
container.Register <StopWorker>(LifeStyles.Singleton);
container.Register <ICommitMessage, CommitMessage>(LifeStyles.Singleton);
container.Register <IRollbackMessage, RollbackMessage>(LifeStyles.Singleton);
container.Register <WaitForThreadToFinish>(LifeStyles.Singleton);
container.Register <WorkerTerminate>(LifeStyles.Singleton);
container.Register <IWaitForEventOrCancelWorker, WaitForEventOrCancelWorker>(LifeStyles.Singleton);
container.Register <IWaitForEventOrCancelFactory, WaitForEventOrCancelFactory>(LifeStyles.Singleton);
container.Register <ThreadPoolConfiguration>(LifeStyles.Singleton);
}
//implementations for RPC / or a duplex transport
//NOTE - we don't bother to tell the difference between RPC / duplex
//so it's possible these are registered, but never actually used.
if ((registrationType & RegistrationTypes.Receive) == RegistrationTypes.Receive &&
(registrationType & RegistrationTypes.Send) == RegistrationTypes.Send)
{
container.Register <IRpcMethodQueue, RpcMethodQueue>(LifeStyles.Singleton);
container.Register <IClearExpiredMessagesRpcMonitor, ClearExpiredMessagesRpcMonitor>
(LifeStyles.Singleton);
container.Register <IResponseIdFactory, ResponseIdFactory>(LifeStyles.Singleton);
container.Register <IRpcContextFactory, RpcContextFactory>(LifeStyles.Singleton);
container.Register <QueueRpcConfiguration>(LifeStyles.Singleton);
}
}
/// <summary>
/// Registers the implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="queueConnection">Queue and connection information.</param>
/// <param name="assemblies">The assemblies.</param>
public virtual void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
QueueConnection queueConnection, params Assembly[] assemblies)
{
Guard.NotNull(() => container, container);
base.RegisterImplementations(container, registrationType, queueConnection);
var init = new RelationalDatabaseMessageQueueInit <long, Guid>();
init.RegisterStandardImplementations(container, assemblies);
//**all
container.RegisterNonScopedSingleton <ICreationScope>(new CreationScope());
container.Register <SqLiteMessageQueueSchema>(LifeStyles.Singleton);
container.Register <IQueueCreation, SqLiteMessageQueueCreation>(LifeStyles.Singleton);
container.Register <IJobSchedulerLastKnownEvent, SqliteJobSchedulerLastKnownEvent>(LifeStyles.Singleton);
container.Register <ISendJobToQueue, SqliteSendToJobQueue>(LifeStyles.Singleton);
container.Register <IDbConnectionFactory, DbConnectionFactory>(LifeStyles.Singleton);
container.Register <SqliteJobSchema>(LifeStyles.Singleton);
container.Register <IOptionsSerialization, OptionsSerialization>(LifeStyles.Singleton);
container.Register <CommandStringCache, IDbCommandStringCache>(LifeStyles.Singleton);
container.Register <ITransportOptionsFactory, TransportOptionsFactory>(LifeStyles.Singleton);
container.Register <ITransactionFactory, TransactionFactory>(LifeStyles.Singleton);
container.Register <IJobSchema, SqliteJobSchema>(LifeStyles.Singleton);
container.Register <IReadColumn, ReadColumn>(LifeStyles.Singleton);
container.Register <IBuildMoveToErrorQueueSql, BuildMoveToErrorQueueSql>(LifeStyles.Singleton);
container.Register <IGetPreviousMessageErrors, GetPreviousMessageErrors <long> >(LifeStyles.Singleton);
container.Register <IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
container
.Register
<ISqLiteMessageQueueTransportOptionsFactory, SqLiteMessageQueueTransportOptionsFactory>(
LifeStyles.Singleton);
container.Register <IDbCommandStringCache>(LifeStyles.Singleton);
container.Register <IConnectionInformation>(
() => new SqliteConnectionInformation(queueConnection, container.GetInstance <IDbDataSource>()),
LifeStyles.Singleton);
container.Register <BuildDequeueCommand>(LifeStyles.Singleton);
container.Register <MessageDeQueue>(LifeStyles.Singleton);
container.Register <SqLiteMessageQueueTransportOptions>(LifeStyles.Singleton);
container
.Register <IConnectionHeader <IDbConnection, IDbTransaction, IDbCommand>,
ConnectionHeader <IDbConnection, IDbTransaction, IDbCommand> >(LifeStyles.Singleton);
container.Register <ISQLiteTransactionWrapper, SqLiteTransactionWrapper>(LifeStyles.Transient);
//**all
//**receive
container.Register <IReceiveMessages, SqLiteMessageQueueReceive>(LifeStyles.Transient);
container.Register <ITransportRollbackMessage, RollbackMessage>(LifeStyles.Singleton);
container.Register <ReceiveMessage>(LifeStyles.Transient);
//**receive
//reset heart beat
container
.Register <IPrepareCommandHandler <ResetHeartBeatCommand <long> >,
ResetHeartBeatCommandPrepareHandler>(LifeStyles.Singleton);
container
.Register <IPrepareCommandHandler <MoveRecordToErrorQueueCommand <long> >,
MoveRecordToErrorQueueCommandPrepareHandler>(LifeStyles.Singleton);
//explicit registration of our job exists query
container
.Register <IQueryHandler <DoesJobExistQuery <IDbConnection, IDbTransaction>,
QueueStatuses>,
DoesJobExistQueryHandler <IDbConnection, IDbTransaction> >(LifeStyles.Singleton);
//because we have an explicit registration for job exists, we need to explicitly register the prepare statement
container
.Register <IPrepareQueryHandler <DoesJobExistQuery <IDbConnection, IDbTransaction>,
QueueStatuses>,
DoesJobExistQueryPrepareHandler <IDbConnection, IDbTransaction> >(LifeStyles.Singleton);
container
.Register <ICommandHandler <MoveRecordToErrorQueueCommand <long> >,
MoveRecordToErrorQueueCommandHandler <IDbConnection, IDbTransaction, IDbCommand> >(LifeStyles
.Singleton);
//expired messages
container
.Register <IPrepareQueryHandler <FindExpiredMessagesToDeleteQuery <long>, IEnumerable <long> >,
FindExpiredRecordsToDeleteQueryPrepareHandler>(LifeStyles.Singleton);
//error messages
container
.Register <IPrepareQueryHandler <FindErrorMessagesToDeleteQuery <long>, IEnumerable <long> >,
FindErrorRecordsToDeleteQueryPrepareHandler>(LifeStyles.Singleton);
//heartbeat
container
.Register <IPrepareQueryHandler <FindMessagesToResetByHeartBeatQuery <long>, IEnumerable <MessageToReset <long> > >,
FindRecordsToResetByHeartBeatQueryPrepareHandler>(LifeStyles.Singleton);
//explicit registration of options
container
.Register <IQueryHandler <GetQueueOptionsQuery <SqLiteMessageQueueTransportOptions>,
SqLiteMessageQueueTransportOptions>,
GetQueueOptionsQueryHandler <SqLiteMessageQueueTransportOptions> >(LifeStyles.Singleton);
container
.Register <IPrepareQueryHandler <GetQueueOptionsQuery <SqLiteMessageQueueTransportOptions>,
SqLiteMessageQueueTransportOptions>,
GetQueueOptionsQueryPrepareHandler <SqLiteMessageQueueTransportOptions> >(LifeStyles.Singleton);
container.RegisterDecorator(typeof(ISQLiteTransactionWrapper),
typeof(BeginTransactionRetryDecorator), LifeStyles.Transient);
//register our decorator for deleting messages
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <DeleteMessageCommand <long>, long>),
typeof(DeleteMessageCommandDecorator), LifeStyles.Singleton);
//register our decorator for setting the status
container.RegisterDecorator(
typeof(ICommandHandler <DeleteStatusTableStatusCommand <long> >),
typeof(SetStatusTableStatusCommandDecorator), LifeStyles.Singleton);
//register our decorator for resetting the heart beat
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <ResetHeartBeatCommand <long>, long>),
typeof(ResetHeartBeatCommandDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(ICommandHandler <MoveRecordToErrorQueueCommand <long> >),
typeof(MoveRecordToErrorQueueCommandDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(IQueryHandler <GetErrorRecordExistsQuery <long>, bool>),
typeof(GetErrorRecordExistsQueryDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(IQueryHandler <FindExpiredMessagesToDeleteQuery <long>, IEnumerable <long> >),
typeof(FindExpiredRecordsToDeleteDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(IQueryHandler <FindMessagesToResetByHeartBeatQuery <long>, IEnumerable <MessageToReset <long> > >),
typeof(FindRecordsToResetByHeartBeatDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(IQueryHandler <GetColumnNamesFromTableQuery, List <string> >),
typeof(GetColumnNamesFromTableDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(IQueryHandler <GetTableExistsQuery, bool>),
typeof(GetTableExistsDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(IQueryHandler <DoesJobExistQuery <IDbConnection, IDbTransaction>, QueueStatuses>),
typeof(DoesJobExistDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <DeleteQueueTablesCommand, QueueRemoveResult>),
typeof(DeleteQueueTablesDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(ICommandHandler <SetErrorCountCommand <long> >),
typeof(SetErrorCountCommandDecorator), LifeStyles.Singleton);
//trace fallback command
container.RegisterDecorator(
typeof(ICommandHandler <RollbackMessageCommand <long> >),
typeof(DotNetWorkQueue.Transport.SQLite.Trace.Decorator.RollbackMessageCommandHandlerDecorator), LifeStyles.Singleton);
//trace sending a message so that we can add specific tags
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <SendMessageCommand, long>),
typeof(DotNetWorkQueue.Transport.SQLite.Trace.Decorator.SendMessageCommandHandlerDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(ICommandHandlerWithOutputAsync <SendMessageCommand, long>),
typeof(DotNetWorkQueue.Transport.SQLite.Trace.Decorator.SendMessageCommandHandlerAsyncDecorator), LifeStyles.Singleton);
}
/// <summary>
/// Allows a transport to register its dependencies in the IoC container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="queueConnection">Queue and connection information.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, QueueConnection queueConnection)
{
container.Register <ITransportCommitMessage, TransportCommitMessage>(LifeStyles.Singleton);
container.Register <ITransportHandleMessage, TransportHandleMessage>(LifeStyles.Singleton);
}
/// <summary>
/// Allows a transport to register its dependencies in the IoC container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connection">The connection.</param>
/// <param name="queue">The queue.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue)
{
Guard.NotNull(() => container, container);
//**all
container.Register<IConnectionInformation>(() => new RedisConnectionInfo(queue, connection), LifeStyles.Singleton);
container.Register<IQueueStatusProvider, RedisQueueStatusProvider>(LifeStyles.Singleton);
container.Register<IJobSchedulerLastKnownEvent, RedisJobSchedulerLastKnownEvent>(LifeStyles.Singleton);
container.Register<ISendJobToQueue, RedisSendJobToQueue>(LifeStyles.Singleton);
container.Register<IJobTableCreation, RedisJobTableCreationNoOp>(LifeStyles.Singleton);
container.Register<IQueueCreation, RedisQueueCreation>(LifeStyles.Singleton);
container.Register<IRedisConnection, RedisConnection>(LifeStyles.Singleton);
container.Register<RedisNames>(LifeStyles.Singleton);
container.Register<RedisQueueTransportOptions>(LifeStyles.Singleton);
container.Register<DelayedProcessingConfiguration>(LifeStyles.Singleton);
container.Register<ICorrelationIdFactory, RedisQueueCorrelationIdFactory>(
LifeStyles.Singleton);
container.Register<ICreationScope, CreationScopeNoOp>(LifeStyles.Singleton);
container.Register<IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
container.Register<IGetTimeFactory, GetRedisTimeFactory>(LifeStyles.Singleton);
container.Register<LuaScripts>(LifeStyles.Singleton);
container.Register<IUnixTimeFactory, UnixTimeFactory>(LifeStyles.Singleton);
container.Register<LocalMachineUnixTime>(LifeStyles.Singleton);
container.Register<RedisServerUnixTime>(LifeStyles.Singleton);
container.Register<SntpUnixTime>(LifeStyles.Singleton);
container.Register<SntpTimeConfiguration>(LifeStyles.Singleton);
container.Register<RedisHeaders>(LifeStyles.Singleton);
container.Register<IClearExpiredMessages, RedisQueueClearExpiredMessages>(LifeStyles.Singleton);
//**all
//**send
container.Register<ISendMessages, RedisQueueSend>(LifeStyles.Singleton);
container.Register<CommitMessage>(LifeStyles.Singleton);
container.Register<RollbackMessage>(LifeStyles.Singleton);
container.Register<HandleMessage>(LifeStyles.Singleton);
container.Register<IGetMessageIdFactory, GetMessageIdFactory>(LifeStyles.Singleton);
container.Register<GetUuidMessageId>(LifeStyles.Singleton);
container.Register<GetRedisIncrId>(LifeStyles.Singleton);
container.Register<ISendBatchSize, RedisSimpleBatchSize>(LifeStyles.Singleton);
//**send
//**receive
container.Register<IDelayedProcessingAction, DelayedProcessingAction>(LifeStyles.Singleton);
container.Register<IQueueMonitor, RedisQueueMonitor>(LifeStyles.Singleton);
container.Register<IReceiveMessages, RedisQueueReceiveMessages>(LifeStyles.Transient);
container.Register<IDelayedProcessingMonitor, RedisDelayedProcessingMonitor>(LifeStyles.Singleton);
container.Register<IResetHeartBeat, RedisQueueResetHeartBeat>(LifeStyles.Singleton);
container.Register<ISendHeartBeat, RedisQueueSendHeartBeat>(LifeStyles.Singleton);
container.Register<IReceiveMessagesFactory, ReceiveMessagesFactory>(LifeStyles.Singleton);
container.Register<IReceivePoisonMessage, RedisQueueReceivePoisonMessage>(LifeStyles.Singleton);
container.Register<IRedisQueueWorkSubFactory, RedisQueueWorkSubFactory>(LifeStyles.Singleton);
container.Register<IReceiveMessagesError, RedisQueueReceiveMessagesError>(LifeStyles.Singleton);
//**receive
//commands
var target = Assembly.GetAssembly(GetType());
container.Register(typeof(ICommandHandlerWithOutput<,>), LifeStyles.Singleton,
target);
container.Register(typeof(ICommandHandler<>), LifeStyles.Singleton,
target);
container.Register(typeof(IQueryHandler<,>), LifeStyles.Singleton,
target);
//LUA scripts
container.Register<DequeueLua>(LifeStyles.Singleton);
container.Register<DequeueRpcLua>(LifeStyles.Singleton);
container.Register<EnqueueLua>(LifeStyles.Singleton);
container.Register<EnqueueDelayedLua>(LifeStyles.Singleton);
container.Register<EnqueueExpirationLua>(LifeStyles.Singleton);
container.Register<EnqueueDelayedAndExpirationLua>(LifeStyles.Singleton);
container.Register<DeleteLua>(LifeStyles.Singleton);
container.Register<RollbackLua>(LifeStyles.Singleton);
container.Register<RollbackDelayLua>(LifeStyles.Singleton);
container.Register<ErrorLua>(LifeStyles.Singleton);
container.Register<MoveDelayedToPendingLua>(LifeStyles.Singleton);
container.Register<SendHeartbeatLua>(LifeStyles.Singleton);
container.Register<ClearExpiredMessagesLua>(LifeStyles.Singleton);
container.Register<ResetHeartbeatLua>(LifeStyles.Singleton);
container.Register<TimeLua>(LifeStyles.Singleton);
container.Register<EnqueueBatchLua>(LifeStyles.Singleton);
container.Register<CommitLua>(LifeStyles.Singleton);
container.Register<DoesJobExistLua>(LifeStyles.Singleton);
var types = target.GetTypes().Where(x => x.IsSubclassOf(typeof(BaseLua)));
container.RegisterCollection<BaseLua>(types);
//metric decorators
container.RegisterDecorator<IDelayedProcessingAction, DelayedProcessingActionDecorator>(LifeStyles.Singleton);
container.RegisterDecorator<IQueryHandler<ReceiveMessageQuery, RedisMessage>, ReceiveMessageQueryDecorator>(
LifeStyles.Singleton);
//logging decorators
container.RegisterDecorator<IQueryHandler<ReceiveMessageQuery, RedisMessage>, Logging.Decorator.ReceiveMessageQueryDecorator>(
LifeStyles.Singleton);
container.RegisterDecorator<IDelayedProcessingAction, Logging.Decorator.DelayedProcessingActionDecorator>(LifeStyles.Singleton);
}
/// <inheritdoc />
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType,
QueueConnection queueConnection)
{
Guard.NotNull(() => container, container);
base.RegisterImplementations(container, registrationType, queueConnection);
var init = new RelationalDatabaseMessageQueueInit <long, Guid>();
init.RegisterStandardImplementations(container, Assembly.GetAssembly(GetType()));
//**all
container.Register <IDbConnectionFactory, DbConnectionFactory>(LifeStyles.Singleton);
container.Register <PostgreSqlMessageQueueSchema>(LifeStyles.Singleton);
container.Register <IQueueCreation, PostgreSqlMessageQueueCreation>(LifeStyles.Singleton);
container.Register <IJobSchedulerLastKnownEvent, PostgreSqlJobSchedulerLastKnownEvent>(LifeStyles.Singleton);
container.Register <IOptionsSerialization, OptionsSerialization>(LifeStyles.Singleton);
container.Register <PostgreSqlJobSchema>(LifeStyles.Singleton);
container.Register <ISendJobToQueue, PostgreSqlSendJobToQueue>(LifeStyles.Singleton);
container.Register <CommandStringCache, PostgreSqlCommandStringCache>(LifeStyles.Singleton);
container.Register <IJobSchema, PostgreSqlJobSchema>(LifeStyles.Singleton);
container.Register <IReadColumn, ReadColumn>(LifeStyles.Singleton);
container.Register <ITransportOptionsFactory, TransportOptionsFactory>(LifeStyles.Singleton);
container.Register <IGetPreviousMessageErrors, GetPreviousMessageErrors <long> >(LifeStyles.Singleton);
container.Register <IRemoveMessage, RemoveMessage>(LifeStyles.Singleton);
container.Register <IGetTime, PostgreSqlTime>(LifeStyles.Singleton);
container.Register <IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
container
.Register
<IPostgreSqlMessageQueueTransportOptionsFactory, PostgreSqlMessageQueueTransportOptionsFactory>(
LifeStyles.Singleton);
container.Register <PostgreSqlCommandStringCache>(LifeStyles.Singleton);
container.Register <IConnectionInformation>(() => new SqlConnectionInformation(queueConnection),
LifeStyles.Singleton);
container.Register <PostgreSqlMessageQueueTransportOptions>(LifeStyles.Singleton);
container.Register <IConnectionHeader <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand>, ConnectionHeader <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> >(LifeStyles.Singleton);
//**all
//**receive
container.Register <IReceiveMessages, PostgreSqlMessageQueueReceive>(LifeStyles.Transient);
container.Register <IConnectionHolderFactory <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand>, ConnectionHolderFactory>(LifeStyles.Singleton);
container.Register <ITransportRollbackMessage, RollbackMessage>(LifeStyles.Singleton);
container.Register <ReceiveMessage>(LifeStyles.Transient);
container.Register <IBuildMoveToErrorQueueSql, BuildMoveToErrorQueueSql>(LifeStyles.Singleton);
//**receive
//reset heart beat
container
.Register <IPrepareCommandHandler <ResetHeartBeatCommand <long> >,
ResetHeartBeatCommandPrepareHandler>(LifeStyles.Singleton);
//delete table - need lower case
container
.Register <IPrepareCommandHandler <DeleteTableCommand>,
DeleteTableCommandPrepareHandler>(LifeStyles.Singleton);
//explicit registration of our job exists query
container
.Register <IQueryHandler <DoesJobExistQuery <NpgsqlConnection, NpgsqlTransaction>,
QueueStatuses>,
DoesJobExistQueryHandler <NpgsqlConnection, NpgsqlTransaction> >(LifeStyles.Singleton);
//because we have an explicit registration for job exists, we need to explicitly register the prepare statement
container
.Register <IPrepareQueryHandler <DoesJobExistQuery <NpgsqlConnection, NpgsqlTransaction>,
QueueStatuses>,
DoesJobExistQueryPrepareHandler <NpgsqlConnection, NpgsqlTransaction> >(LifeStyles.Singleton);
//expired messages
container
.Register <IPrepareQueryHandler <FindExpiredMessagesToDeleteQuery <long>, IEnumerable <long> >,
FindExpiredRecordsToDeleteQueryPrepareHandler>(LifeStyles.Singleton);
//error messages
container
.Register <IPrepareQueryHandler <FindErrorMessagesToDeleteQuery <long>, IEnumerable <long> >,
FindErrorRecordsToDeleteQueryPrepareHandler>(LifeStyles.Singleton);
//heartbeat
container
.Register <IPrepareQueryHandler <FindMessagesToResetByHeartBeatQuery <long>, IEnumerable <MessageToReset <long> > >,
FindRecordsToResetByHeartBeatQueryPrepareHandler>(LifeStyles.Singleton);
container
.Register <ICommandHandlerWithOutput <DeleteTransactionalMessageCommand, long>,
DeleteTransactionalMessageCommandHandler <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> >(LifeStyles.Singleton);
container
.Register <ICommandHandler <MoveRecordToErrorQueueCommand <long> >,
MoveRecordToErrorQueueCommandHandler <NpgsqlConnection, NpgsqlTransaction, NpgsqlCommand> >(LifeStyles.Singleton);
//explicit registration of options
container
.Register <IQueryHandler <GetQueueOptionsQuery <PostgreSqlMessageQueueTransportOptions>,
PostgreSqlMessageQueueTransportOptions>,
GetQueueOptionsQueryHandler <PostgreSqlMessageQueueTransportOptions> >(LifeStyles.Singleton);
container
.Register <IPrepareQueryHandler <GetQueueOptionsQuery <PostgreSqlMessageQueueTransportOptions>,
PostgreSqlMessageQueueTransportOptions>,
GetQueueOptionsQueryPrepareHandler <PostgreSqlMessageQueueTransportOptions> >(LifeStyles.Singleton);
container.RegisterDecorator(typeof(IPrepareQueryHandler <GetColumnNamesFromTableQuery, List <string> >),
typeof(GetColumnNamesFromTableQueryPrepareDecorator), LifeStyles.Singleton);
container.RegisterDecorator(typeof(IPrepareQueryHandler <GetTableExistsQuery, bool>),
typeof(GetTableExistsQueryPrepareDecorator), LifeStyles.Singleton);
container.RegisterDecorator(typeof(IPrepareQueryHandler <GetTableExistsTransactionQuery, bool>),
typeof(GetTableExistsTransactionQueryPrepareDecorator), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandlerWithOutput <,>),
typeof(RetryCommandHandlerOutputDecorator <,>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandler <>),
typeof(RetryCommandHandlerDecorator <>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandlerWithOutputAsync <,>),
typeof(RetryCommandHandlerOutputDecoratorAsync <,>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(IQueryHandler <,>),
typeof(RetryQueryHandlerDecorator <,>), LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateJobTablesCommand <ITable>, QueueCreationResult>),
typeof(CreateJobTablesCommandDecorator), LifeStyles.Singleton);
//register our decorator that handles table creation errors
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <CreateQueueTablesAndSaveConfigurationCommand <ITable>,
QueueCreationResult>),
typeof(CreateQueueTablesAndSaveConfigurationDecorator), LifeStyles.Singleton);
//trace fallback command
container.RegisterDecorator(
typeof(ICommandHandler <RollbackMessageCommand <long> >),
typeof(DotNetWorkQueue.Transport.PostgreSQL.Trace.Decorator.RollbackMessageCommandHandlerDecorator), LifeStyles.Singleton);
//trace sending a message so that we can add specific tags
container.RegisterDecorator(
typeof(ICommandHandlerWithOutput <SendMessageCommand, long>),
typeof(DotNetWorkQueue.Transport.PostgreSQL.Trace.Decorator.SendMessageCommandHandlerDecorator), LifeStyles.Singleton);
container.RegisterDecorator(
typeof(ICommandHandlerWithOutputAsync <SendMessageCommand, long>),
typeof(DotNetWorkQueue.Transport.PostgreSQL.Trace.Decorator.SendMessageCommandHandlerAsyncDecorator), LifeStyles.Singleton);
}
/// <summary> /// Allows a transport to register its dependencies in the IoC container. /// </summary> /// <param name="container">The container.</param> /// <param name="registrationType">Type of the registration.</param> /// <param name="connection">The connection.</param> /// <param name="queue">The queue.</param> public abstract void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue);
/// <summary>
/// Registers the implementations.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="registrationType">Type of the registration.</param>
/// <param name="connection">The connection.</param>
/// <param name="queue">The queue.</param>
public override void RegisterImplementations(IContainer container, RegistrationTypes registrationType, string connection, string queue)
{
Guard.NotNull(() => container, container);
//**all
container.Register<PostgreSqlMessageQueueSchema>(LifeStyles.Singleton);
container.Register<IQueueCreation, PostgreSqlMessageQueueCreation>(LifeStyles.Singleton);
container.Register<PostgreSqlMessageQueueStatusQueries>(LifeStyles.Singleton);
container.Register<IQueueStatusProvider, PostgreSqlQueueStatusProvider>(LifeStyles.Singleton);
container.Register<IJobSchedulerLastKnownEvent, PostgreSqlJobSchedulerLastKnownEvent>(LifeStyles.Singleton);
container.Register<IJobTableCreation, PostgreSqlJobTableCreation>(LifeStyles.Singleton);
container.Register<PostgreSqlJobSchema>(LifeStyles.Singleton);
container.Register<ISendJobToQueue, PostgreSqlSendJobToQueue>(LifeStyles.Singleton);
container.Register<CreateJobMetaData>(LifeStyles.Singleton);
container.Register<IGetTime, PostgreSqlTime>(LifeStyles.Singleton);
container.Register<IGetFirstMessageDeliveryTime, GetFirstMessageDeliveryTime>(LifeStyles.Singleton);
container
.Register
<IPostgreSqlMessageQueueTransportOptionsFactory, PostgreSqlMessageQueueTransportOptionsFactory>(
LifeStyles.Singleton);
container.Register<ICreationScope, CreationScopeNoOp>(LifeStyles.Singleton);
container.Register<PostgreSqlCommandStringCache>(LifeStyles.Singleton);
container.Register<IConnectionInformation>(() => new SqlConnectionInformation(queue, connection), LifeStyles.Singleton);
container.Register<ICorrelationIdFactory, PostgreSqlMessageQueueCorrelationIdFactory>(
LifeStyles.Singleton);
container.Register<PostgreSqlMessageQueueTransportOptions>(LifeStyles.Singleton);
container.Register<TableNameHelper>(LifeStyles.Singleton);
container.Register<SqlHeaders>(LifeStyles.Singleton);
container.Register<ThreadSafeRandom>(LifeStyles.Singleton);
container.Register<IClearExpiredMessages, PostgreSqlMessageQueueClearExpiredMessages>(LifeStyles.Singleton);
//**all
//**send
container.Register<ISendMessages, PostgreSqlMessageQueueSend>(LifeStyles.Singleton);
//**send
//**receive
container.Register<IReceiveMessages, PostgreSqlMessageQueueReceive>(LifeStyles.Transient);
container.Register<IConnectionFactory, ConnectionFactory>(LifeStyles.Singleton);
container.Register<CommitMessage>(LifeStyles.Transient);
container.Register<RollbackMessage>(LifeStyles.Transient);
container.Register<HandleMessage>(LifeStyles.Transient);
container.Register<ReceiveMessage>(LifeStyles.Transient);
container.Register<IResetHeartBeat, PostgreSqlMessageQueueResetHeartBeat>(LifeStyles.Singleton);
container.Register<ISendHeartBeat, PostgreSqlMessageQueueSendHeartBeat>(LifeStyles.Singleton);
container.Register<IReceiveMessagesFactory, ReceiveMessagesFactory>(LifeStyles.Singleton);
container.Register<IReceivePoisonMessage, PostgreSqlQueueReceivePoisonMessage>(LifeStyles.Singleton);
container.Register<IReceiveMessagesError, PostgreSqlMessageQueueReceiveErrorMessage>(LifeStyles.Singleton);
//**receive
var target = Assembly.GetAssembly(GetType());
//commands and decorators
// Go look in all assemblies and register all implementations
// of ICommandHandlerWithOutput<T> by their closed interface:
container.Register(typeof (ICommandHandlerWithOutput<,>), LifeStyles.Singleton,
target);
//commands and decorators
// Go look in all assemblies and register all implementations
// of ICommandHandlerWithOutputAsync<T> by their closed interface:
container.Register(typeof(ICommandHandlerWithOutputAsync<,>), LifeStyles.Singleton,
target);
// Go look in all assemblies and register all implementations
// of ICommandHandler<T> by their closed interface:
container.Register(typeof (ICommandHandler<>), LifeStyles.Singleton,
target);
// Go look in all assemblies and register all implementations
// of IQueryHandler<T> by their closed interface:
container.Register(typeof (IQueryHandler<,>), LifeStyles.Singleton,
target);
container.RegisterDecorator(typeof (ICommandHandlerWithOutput<,>),
typeof (RetryCommandHandlerOutputDecorator<,>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandler<>),
typeof(RetryCommandHandlerDecorator<>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(ICommandHandlerWithOutputAsync<,>),
typeof(RetryCommandHandlerOutputDecoratorAsync<,>), LifeStyles.Singleton);
container.RegisterDecorator(typeof(IQueryHandler<,>),
typeof(RetryQueryHandlerDecorator<,>), LifeStyles.Singleton);
}
