public async Task SeeIfItWorks()
{
var callBackWasCalledAlright = Using(new ManualResetEvent(initialState: false));
var activator = Using(new BuiltinHandlerActivator());
Configure.With(activator)
.Transport(t =>
{
var options = new SqlServerTransportOptions(c =>
{
var connectionString = SqlTestHelper.ConnectionString;
var loggerFactory = c.Get <IRebusLoggerFactory>();
var connectionProvider = new DbConnectionProvider(connectionString, loggerFactory)
{
SqlConnectionOpening = async connection => callBackWasCalledAlright.Set()
};
return(connectionProvider);
});
t.UseSqlServer(options, "test-queue");
})
.Start();
callBackWasCalledAlright.WaitOrDie(
timeout: TimeSpan.FromSeconds(3),
errorMessage: $"The '{nameof(DbConnectionProvider.SqlConnectionOpening)}' callback was not invoked as expected"
);
}
public async Task Dispose_WhenAutoDeleteQueueEnabled_DropsInputQueue()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
const string queueName = "input";
var options = new SqlServerTransportOptions(SqlTestHelper.ConnectionString);
var activator = Using(new BuiltinHandlerActivator());
Configure.With(activator)
.Logging(l => l.Use(consoleLoggerFactory))
.Transport(t => t.UseSqlServer(options, queueName).SetAutoDeleteQueue(true))
.Start();
using (var connection = await connectionProvider.GetConnection())
{
Assert.That(connection.GetTableNames().Contains(TableName.Parse(queueName)), Is.True);
}
CleanUpDisposables();
using (var connection = await connectionProvider.GetConnection())
{
Assert.That(connection.GetTableNames().Contains(TableName.Parse(queueName)), Is.False);
}
}
public async Task CanConfigureIt()
{
var activator = Using(new BuiltinHandlerActivator());
var options = new SqlServerTransportOptions(SqlTestHelper.ConnectionString);
Configure.With(activator)
.Transport(t =>
{
t.UseSqlServer(options, TestConfig.GetName("whatever"))
.SetExpiredMessagesCleanupInterval(TimeSpan.FromSeconds(5));
})
.Start();
await Task.Delay(TimeSpan.FromSeconds(15));
}
private void ConfigureBus()
{
var config = Rebus.Config.Configure.With(new NetCoreServiceCollectionContainerAdapter(Services))
.Logging(l => l.Trace())
.Routing(r => r.TypeBased()
.MapAssemblyOf <IncomingInvoiceSaga>(Configuration["Rebus:QueueName"])
)
.Sagas(s => s.StoreInSqlServer(Configuration["Rebus:Sagas:ConnectionString"], Configuration["Rebus:Sagas:MessagesTableName"], Configuration["Rebus:Sagas:IndexesTableName"]));
if (Environment.IsDevelopment() || Environment.IsOnPremises())
{
config.Subscriptions(s => s.StoreInSqlServer(Configuration["Rebus:Subscriptions:ConnectionString"], Configuration["Rebus:Subscriptions:TableName"], isCentralized: true));
var transportOptions = new SqlServerTransportOptions(Configuration["Rebus:Transport:ConnectionString"]);
config.Transport(t => t.UseSqlServer(transportOptions, Configuration["Rebus:QueueName"]));
}
else if (Environment.IsAWS())
{
var sqsConfig = new AmazonSQSConfig()
{
RegionEndpoint = Amazon.RegionEndpoint.GetBySystemName(Configuration["Rebus:Transport:RegionEndpoint"])
};
config.Transport(t => t.UseAmazonSQS(Configuration["Rebus:Transport:AccessKey"], Configuration["Rebus:Transport:SecretKey"], sqsConfig, Configuration["Rebus:Transport:QueueAddress"]));
}
else if (Environment.IsAzure())
{
config.Transport(t => t.UseAzureServiceBus(Configuration["Rebus:Transport:ConnectionString"], Configuration["Rebus:QueueName"]));
}
else
{
throw new InvalidOperationException("Unknown execution environment");
}
var bus = config.Start();
Services.AddSingleton(bus);
Services.AddTransient <IEventDispatcher, RebusEventDispatcher>();
}
/// <summary>
/// Constructs the transport with the given <see cref="IDbConnectionProvider"/>
/// </summary>
public SqlServerTransport(IDbConnectionProvider connectionProvider, string inputQueueName, IRebusLoggerFactory rebusLoggerFactory, IAsyncTaskFactory asyncTaskFactory, IRebusTime rebusTime, SqlServerTransportOptions options)
{
if (rebusLoggerFactory == null)
{
throw new ArgumentNullException(nameof(rebusLoggerFactory));
}
if (asyncTaskFactory == null)
{
throw new ArgumentNullException(nameof(asyncTaskFactory));
}
_rebusTime = rebusTime ?? throw new ArgumentNullException(nameof(rebusTime));
ConnectionProvider = connectionProvider ?? throw new ArgumentNullException(nameof(connectionProvider));
ReceiveTableName = inputQueueName != null?TableName.Parse(inputQueueName) : null;
Log = rebusLoggerFactory.GetLogger <SqlServerTransport>();
var cleanupInterval = options.ExpiredMessagesCleanupInterval ?? DefaultExpiredMessagesCleanupInterval;
var intervalSeconds = (int)cleanupInterval.TotalSeconds;
_expiredMessagesCleanupTask = asyncTaskFactory.Create("ExpiredMessagesCleanup", PerformExpiredMessagesCleanupCycle, intervalSeconds: intervalSeconds);
_autoDeleteQueue = options.AutoDeleteQueue;
_nativeTimeoutManagerDisabled = options.NativeTimeoutManagerDisabled;
}
/// <summary>
/// Configures Rebus to use SQLServer as its transport in "one-way client mode" (i.e. as a send-only endpoint).
/// </summary>
/// <param name="configurer"></param>
/// <param name="transportOptions"></param>
/// <returns></returns>
public static SqlServerTransportOptions UseSqlServerAsOneWayClient(this StandardConfigurer <ITransport> configurer, SqlServerTransportOptions transportOptions)
{
return(Configure(
configurer,
(context, provider, inputQueue) => new SqlServerTransport(provider, inputQueue, context.Get <IRebusLoggerFactory>(), context.Get <IAsyncTaskFactory>(), context.Get <IRebusTime>(), transportOptions),
transportOptions
)
.AsOneWayClient());
}
/// <summary>
/// Configures Rebus to use SQL Server as its transport
/// </summary>
/// <param name="configurer">Static to extend</param>
/// <param name="transportOptions">Options controlling the transport setup</param>
/// <param name="inputQueueName">Queue name to process messages from</param>
public static SqlServerTransportOptions UseSqlServer(this StandardConfigurer <ITransport> configurer, SqlServerTransportOptions transportOptions, string inputQueueName)
{
return(Configure(
configurer,
(context, provider, inputQueue) => new SqlServerTransport(provider, inputQueue, context.Get <IRebusLoggerFactory>(), context.Get <IAsyncTaskFactory>(), context.Get <IRebusTime>(), transportOptions),
transportOptions
)
.ReadFrom(inputQueueName));
}
