public async Task Should_stop_pumping_messages_after_first_unsuccessful_receive()
{
var successfulReceives = 46;
var queueSize = 1000;
var parser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var inputQueue = new FakeTableBasedQueue(parser.Parse("input").QualifiedTableName, queueSize, successfulReceives);
var pump = new MessagePump(
m => new ProcessWithNoTransaction(sqlConnectionFactory),
qa => qa == "input" ? (TableBasedQueue)inputQueue : new TableBasedQueue(parser.Parse(qa).QualifiedTableName, qa),
new QueuePurger(sqlConnectionFactory),
new ExpiredMessagesPurger(_ => sqlConnectionFactory.OpenNewConnection(), TimeSpan.MaxValue, 0),
new QueuePeeker(sqlConnectionFactory, new QueuePeekerOptions()),
new SchemaInspector(_ => sqlConnectionFactory.OpenNewConnection()),
TimeSpan.MaxValue);
await pump.Init(
_ => Task.FromResult(0),
_ => Task.FromResult(ErrorHandleResult.Handled),
new CriticalError(_ => Task.FromResult(0)),
new PushSettings("input", "error", false, TransportTransactionMode.None));
pump.Start(new PushRuntimeSettings(1));
await WaitUntil(() => inputQueue.NumberOfPeeks > 1);
await pump.Stop();
Assert.That(inputQueue.NumberOfReceives, Is.AtMost(successfulReceives + 2), "Pump should stop receives after first unsuccessful attempt.");
}
internal void ParseConnectionAttributes()
{
if (addressTranslator != null)
{
return;
}
var parser = GetConnectionStringBuilder();
if (DefaultCatalog != null)
{
Catalog = DefaultCatalog;
}
else
{
if (!parser.TryGetValue("Initial Catalog", out var catalogSetting) && !parser.TryGetValue("database", out catalogSetting))
{
throw new Exception("Initial Catalog property is mandatory in the connection string.");
}
Catalog = (string)catalogSetting;
}
if (parser.TryGetValue("Column Encryption Setting", out var enabled))
{
IsEncrypted = ((string)enabled).Equals("enabled", StringComparison.InvariantCultureIgnoreCase);
}
addressTranslator = new QueueAddressTranslator(Catalog, "dbo", DefaultSchema, SchemaAndCatalog);
}
public async Task SetUp()
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
await ResetQueue(addressParser);
queue = new TableBasedQueue(addressParser.Parse(QueueTableName).QualifiedTableName, QueueTableName);
}
static Task CreateQueueIfNotExists(QueueAddressTranslator addressTranslator)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressTranslator);
var queueBindings = new QueueBindings();
queueBindings.BindReceiving(QueueTableName);
return(queueCreator.CreateQueueIfNecessary(queueBindings, ""));
}
static Task CreateOutputQueueIfNecessary(QueueAddressTranslator addressParser, SqlConnectionFactory sqlConnectionFactory)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressParser, new CanonicalQueueAddress("Delayed", "dbo", "nservicebus"));
var queueBindings = new QueueBindings();
queueBindings.BindReceiving(validAddress);
return(queueCreator.CreateQueueIfNecessary(queueBindings, ""));
}
static Task CreateOutputQueueIfNecessary(QueueAddressTranslator addressParser)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressParser);
var queueBindings = new QueueBindings();
queueBindings.BindReceiving(validAddress);
return(queueCreator.CreateQueueIfNecessary(queueBindings, ""));
}
static Task CreateQueueIfNotExists(QueueAddressTranslator addressTranslator, SqlConnectionFactory sqlConnectionFactory)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressTranslator, new CanonicalQueueAddress("Delayed", "dbo", "nservicebus"));
var queueBindings = new QueueBindings();
queueBindings.BindReceiving(QueueTableName);
return(queueCreator.CreateQueueIfNecessary(queueBindings, ""));
}
Task PurgeOutputQueue(QueueAddressTranslator addressParser)
{
purger = new QueuePurger(sqlConnectionFactory);
var queueAddress = addressParser.Parse(validAddress);
queue = new TableBasedQueue(queueAddress.QualifiedTableName, queueAddress.Address, true);
return(purger.Purge(queue));
}
Task PurgeOutputQueue(QueueAddressTranslator addressParser, CancellationToken cancellationToken = default)
{
purger = new QueuePurger(sqlConnectionFactory);
var queueAddress = addressParser.Parse(ValidAddress);
queue = new TableBasedQueue(queueAddress.QualifiedTableName, queueAddress.Address, true);
return(purger.Purge(queue, cancellationToken));
}
public void Should_not_change_canonical_address()
{
var parser = new QueueAddressTranslator(null, "dbo", null, new QueueSchemaAndCatalogOptions());
var address = "my.tb[e@[my.[sch@ma]@[my.c@ta]]og]";
var canonicalAddress = parser.Parse(address).Address;
Assert.AreEqual(address, canonicalAddress);
}
public void It_deduplicates_based_on_message_id_and_address(TransportOperations transportOperations, int expectedDispatchedMessageCount)
{
var queueAddressTranslator = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var sortResult = transportOperations.UnicastTransportOperations.SortAndDeduplicate(queueAddressTranslator);
Assert.AreEqual(expectedDispatchedMessageCount, sortResult.DefaultDispatch.Count());
Assert.IsNull(sortResult.IsolatedDispatch);
}
/// <summary>
/// <see cref="TransportDefinition.Initialize" />
/// </summary>
public override TransportInfrastructure Initialize(SettingsHolder settings, string connectionString)
{
settings.TryGet(SettingsKeys.DefaultSchemaSettingsKey, out string defaultSchemaOverride);
var queueSchemaSettings = settings.GetOrDefault <QueueSchemaAndCatalogSettings>();
var catalog = GetDefaultCatalog(settings, connectionString);
var addressParser = new QueueAddressTranslator(catalog, "dbo", defaultSchemaOverride, queueSchemaSettings);
return(new SqlServerTransportInfrastructure(addressParser, settings, connectionString));
}
async Task PrepareAsync()
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, new QueueSchemaAndCatalogSettings());
await CreateOutputQueueIfNecessary(addressParser);
await PurgeOutputQueue(addressParser);
dispatcher = new MessageDispatcher(new TableBasedQueueDispatcher(sqlConnectionFactory, new TableBasedQueueOperationsReader(addressParser)), addressParser);
}
async Task PrepareAsync(CancellationToken cancellationToken = default)
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var tableCache = new TableBasedQueueCache(addressParser, true);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory, cancellationToken);
await PurgeOutputQueue(addressParser, cancellationToken);
dispatcher = new MessageDispatcher(addressParser, new NoOpMulticastToUnicastConverter(), tableCache, null, sqlConnectionFactory);
}
public async Task SetUp()
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
await ResetQueue(addressParser, sqlConnectionFactory);
queue = new TableBasedQueue(addressParser.Parse(QueueTableName).QualifiedTableName, QueueTableName, false);
}
public void It_sorts_isolated_and_default_dispatch()
{
var queueAddressTranslator = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var operations = new TransportOperations(
CreateTransportOperations("1", "dest", DispatchConsistency.Default),
CreateTransportOperations("2", "dest", DispatchConsistency.Isolated));
var sortResult = operations.UnicastTransportOperations.SortAndDeduplicate(queueAddressTranslator);
Assert.AreEqual(1, sortResult.DefaultDispatch.Count());
Assert.AreEqual(1, sortResult.IsolatedDispatch.Count());
}
public async Task Should_recover(Type contextProviderType, DispatchConsistency dispatchConsistency)
{
// Setup
var token = CancellationToken.None;
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var purger = new QueuePurger(sqlConnectionFactory);
await RemoveQueueIfPresent(QueueName, token);
await RemoveQueueIfPresent($"{QueueName}.Delayed", token);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory);
var tableCache = new TableBasedQueueCache(addressParser, true);
var queue = tableCache.Get(QueueName);
dispatcher = new MessageDispatcher(addressParser, new NoOpMulticastToUnicastConverter(), tableCache, null, sqlConnectionFactory);
// Run normally
int messagesSent = await RunTest(contextProviderType, dispatchConsistency, queue, purger, token);
Assert.AreEqual(1, messagesSent);
// Remove Recoverable column
await DropRecoverableColumn(token);
var exception = Assert.ThrowsAsync <Exception>(() => RunTest(contextProviderType, dispatchConsistency, queue, purger, token));
Assert.True(exception.Message.Contains("change in the existence of the Recoverable column"));
// Try again, should work
int messagesSentAttempt2 = await RunTest(contextProviderType, dispatchConsistency, queue, purger, token);
Assert.AreEqual(1, messagesSentAttempt2);
// Put the Recoverable column back
await AddRecoverableColumn(token);
var exception2 = Assert.ThrowsAsync <Exception>(() => RunTest(contextProviderType, dispatchConsistency, queue, purger, token));
Assert.True(exception2.Message.Contains("change in the existence of the Recoverable column"));
// Try again, should work
int messagesSentAttempt3 = await RunTest(contextProviderType, dispatchConsistency, queue, purger, token);
Assert.AreEqual(1, messagesSentAttempt3);
}
public async Task Should_stop_receiving_messages_after_first_unsuccessful_receive()
{
var successfulReceives = 46;
var queueSize = 1000;
var parser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var inputQueueAddress = parser.Parse("input").Address;
var inputQueue = new FakeTableBasedQueue(inputQueueAddress, queueSize, successfulReceives);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
}
var transport = new SqlServerTransport(SqlConnectionFactory.Default(connectionString).OpenNewConnection)
{
TransportTransactionMode = TransportTransactionMode.None,
TimeToWaitBeforeTriggeringCircuitBreaker = TimeSpan.MaxValue,
};
transport.Testing.QueueFactoryOverride = qa =>
qa == inputQueueAddress ? inputQueue : new TableBasedQueue(parser.Parse(qa).QualifiedTableName, qa, true);
var receiveSettings = new ReceiveSettings("receiver", inputQueueAddress, true, false, "error");
var hostSettings = new HostSettings("IntegrationTests", string.Empty, new StartupDiagnosticEntries(),
(_, __, ___) => { },
true);
var infrastructure = await transport.Initialize(hostSettings, new[] { receiveSettings }, new string[0]);
var receiver = infrastructure.Receivers.First().Value;
await receiver.Initialize(
new PushRuntimeSettings(1),
(_, __) => Task.CompletedTask,
(_, __) => Task.FromResult(ErrorHandleResult.Handled));
await receiver.StartReceive();
await WaitUntil(() => inputQueue.NumberOfPeeks > 1);
await receiver.StopReceive();
await infrastructure.Shutdown();
Assert.That(inputQueue.NumberOfReceives, Is.AtMost(successfulReceives + 2), "Receiver should stop receives after first unsuccessful attempt.");
}
static async Task ResetQueue(QueueAddressTranslator addressTranslator, SqlConnectionFactory sqlConnectionFactory, CancellationToken cancellationToken = default)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressTranslator);
using (var connection = await sqlConnectionFactory.OpenNewConnection(cancellationToken).ConfigureAwait(false))
{
using (var comm = connection.CreateCommand())
{
comm.CommandText = $"IF OBJECT_ID('{QueueTableName}', 'U') IS NOT NULL DROP TABLE {QueueTableName}";
comm.ExecuteNonQuery();
}
}
await queueCreator.CreateQueueIfNecessary(new[] { QueueTableName }, new CanonicalQueueAddress("Delayed", "dbo", "nservicebus"), cancellationToken).ConfigureAwait(false);
}
async Task PrepareAsync(CancellationToken cancellationToken = default)
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, new QueueSchemaAndCatalogOptions());
var tableCache = new TableBasedQueueCache(addressParser, true);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory, cancellationToken);
await PurgeOutputQueue(addressParser, cancellationToken);
dispatcher = new MessageDispatcher(addressParser, new NoOpMulticastToUnicastConverter(), tableCache, null, sqlConnectionFactory);
}
static async Task ResetQueue(QueueAddressTranslator addressTranslator)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressTranslator);
var queueBindings = new QueueBindings();
queueBindings.BindReceiving(QueueTableName);
using (var connection = await sqlConnectionFactory.OpenNewConnection().ConfigureAwait(false))
{
using (var comm = connection.CreateCommand())
{
comm.CommandText = $"IF OBJECT_ID('{QueueTableName}', 'U') IS NOT NULL DROP TABLE {QueueTableName}";
comm.ExecuteNonQuery();
}
}
await queueCreator.CreateQueueIfNecessary(queueBindings, "").ConfigureAwait(false);
}
async Task PrepareAsync()
{
var addressParser = new QueueAddressTranslator("nservicebus", "dbo", null, new QueueSchemaAndCatalogSettings());
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
}
sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
await CreateOutputQueueIfNecessary(addressParser, sqlConnectionFactory);
await PurgeOutputQueue(addressParser);
dispatcher = new MessageDispatcher(new TableBasedQueueDispatcher(sqlConnectionFactory, new TableBasedQueueOperationsReader(addressParser)), addressParser);
}
public async Task Should_stop_pumping_messages_after_first_unsuccessful_receive()
{
var successfulReceives = 46;
var queueSize = 1000;
var parser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var inputQueue = new FakeTableBasedQueue(parser.Parse("input").QualifiedTableName, queueSize, successfulReceives);
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString");
if (string.IsNullOrEmpty(connectionString))
{
connectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
}
var sqlConnectionFactory = SqlConnectionFactory.Default(connectionString);
var pump = new MessagePump(
m => new ProcessWithNoTransaction(sqlConnectionFactory, null),
qa => qa == "input" ? (TableBasedQueue)inputQueue : new TableBasedQueue(parser.Parse(qa).QualifiedTableName, qa, true),
new QueuePurger(sqlConnectionFactory),
new NoOpExpiredMessagesPurger(),
new QueuePeeker(sqlConnectionFactory, new QueuePeekerOptions()),
new QueuePeekerOptions(),
new SchemaInspector(_ => sqlConnectionFactory.OpenNewConnection(), false),
TimeSpan.MaxValue);
await pump.Init(
_ => Task.FromResult(0),
_ => Task.FromResult(ErrorHandleResult.Handled),
new CriticalError(_ => Task.FromResult(0)),
new PushSettings("input", "error", false, TransportTransactionMode.None));
pump.Start(new PushRuntimeSettings(1));
await WaitUntil(() => inputQueue.NumberOfPeeks > 1);
await pump.Stop();
Assert.That(inputQueue.NumberOfReceives, Is.AtMost(successfulReceives + 2), "Pump should stop receives after first unsuccessful attempt.");
}
static Task CreateOutputQueueIfNecessary(QueueAddressTranslator addressParser, SqlConnectionFactory sqlConnectionFactory, CancellationToken cancellationToken = default)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressParser);
return(queueCreator.CreateQueueIfNecessary(new[] { ValidAddress }, new CanonicalQueueAddress("Delayed", "dbo", "nservicebus"), cancellationToken));
}
static Task CreateQueueIfNotExists(QueueAddressTranslator addressTranslator, SqlConnectionFactory sqlConnectionFactory, CancellationToken cancellationToken = default)
{
var queueCreator = new QueueCreator(sqlConnectionFactory, addressTranslator, false);
return(queueCreator.CreateQueueIfNecessary(new[] { QueueTableName }, new CanonicalQueueAddress("Delayed", "dbo", "nservicebus"), cancellationToken));
}
