public MessageReceiver(
SqlServerTransport transport,
string receiverId,
string receiveAddress,
string errorQueueAddress,
Action <string, Exception, CancellationToken> criticalErrorAction,
Func <TransportTransactionMode, ProcessStrategy> processStrategyFactory,
Func <string, TableBasedQueue> queueFactory,
IPurgeQueues queuePurger,
IExpiredMessagesPurger expiredMessagesPurger,
IPeekMessagesInQueue queuePeeker,
QueuePeekerOptions queuePeekerOptions,
SchemaInspector schemaInspector,
TimeSpan waitTimeCircuitBreaker,
ISubscriptionManager subscriptionManager)
{
this.transport = transport;
this.processStrategyFactory = processStrategyFactory;
this.queuePurger = queuePurger;
this.queueFactory = queueFactory;
this.expiredMessagesPurger = expiredMessagesPurger;
this.queuePeeker = queuePeeker;
this.queuePeekerOptions = queuePeekerOptions;
this.schemaInspector = schemaInspector;
this.waitTimeCircuitBreaker = waitTimeCircuitBreaker;
this.errorQueueAddress = errorQueueAddress;
this.criticalErrorAction = criticalErrorAction;
Subscriptions = subscriptionManager;
Id = receiverId;
ReceiveAddress = receiveAddress;
}
SqlServerTransport GetTransport(string connectionString, IsolationLevel isolationLevel)
{
var rebusTime = new DefaultRebusTime();
var rebusLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(connectionString, rebusLoggerFactory)
{
IsolationLevel = isolationLevel
};
var taskFactory = new TplAsyncTaskFactory(rebusLoggerFactory);
var transport = new SqlServerTransport(
connectionProvider: connectionProvider,
inputQueueName: _queueName,
rebusLoggerFactory: rebusLoggerFactory,
asyncTaskFactory: taskFactory,
rebusTime: rebusTime,
options: new SqlServerTransportOptions(connectionProvider)
);
transport.Initialize();
return(transport);
}
void ConnectionFactory(EndpointConfiguration endpointConfiguration)
{
#region sqlserver-custom-connection-factory
var transport = new SqlServerTransport(
async cancellationToken =>
{
var connection = new SqlConnection("SomeConnectionString");
try
{
await connection.OpenAsync().ConfigureAwait(false);
// perform custom operations
return(connection);
}
catch
{
connection.Dispose();
throw;
}
});
#endregion
}
public static IEnumerable <TransportMessage> GetMessages(this SqlServerTransport transport)
{
var messages = new List <TransportMessage>();
AsyncHelpers.RunSync(async() =>
{
while (true)
{
using (var scope = new RebusTransactionScope())
{
var transportMessage = await transport.Receive(scope.TransactionContext, CancellationToken.None);
if (transportMessage == null)
{
break;
}
messages.Add(transportMessage);
await scope.CompleteAsync();
}
}
});
return(messages);
}
public async Task CountTheConnections()
{
var activeConnections = new ConcurrentDictionary <int, object>();
var bus = Configure.With(new BuiltinHandlerActivator())
.Transport(t => t.Register(c =>
{
var connectionProvider = new TestConnectionProvider(SqlTestHelper.ConnectionString, activeConnections);
var transport = new SqlServerTransport(connectionProvider, "RebusMessages", "bimse", c.Get <IRebusLoggerFactory>(), c.Get <IAsyncTaskFactory>());
transport.EnsureTableIsCreated();
return(transport);
}))
.Start();
using (var printTimer = new Timer(1000))
{
printTimer.Elapsed += delegate
{
Console.WriteLine("Active connections: {0}", activeConnections.Count);
};
printTimer.Start();
using (bus)
{
await Task.Delay(TimeSpan.FromSeconds(5));
}
}
}
public void It_rejects_connection_string_without_catalog_property()
{
var definition = new SqlServerTransport();
Assert.That(() => definition.Initialize(new SettingsHolder(), @"Data Source=.\SQLEXPRESS;Integrated Security=True"),
Throws.Exception.Message.Contains("Initial Catalog property is mandatory in the connection string."));
}
public void It_accepts_connection_string_with_catalog_property(string connectionString)
{
var definition = new SqlServerTransport();
definition.Initialize(new SettingsHolder(), connectionString);
Assert.Pass();
}
void ConnectionString(EndpointConfiguration endpointConfiguration)
{
#region sqlserver-config-connectionstring
var transport = new SqlServerTransport("Data Source=instance;Initial Catalog=db;Integrated Security=True;Max Pool Size=80");
#endregion
}
public void It_accepts_connection_string_with_catalog_property(string connectionString)
{
var transport = new SqlServerTransport(connectionString);
transport.ParseConnectionAttributes();
Assert.AreEqual("my.catalog", transport.Catalog);
}
public void It_rejects_connection_string_without_catalog_property()
{
var definition = new SqlServerTransport(@"Data Source=.\SQLEXPRESS;Integrated Security=True");
Assert.That(
async() => await definition.Initialize(settings, new ReceiveSettings[0], new string[0]).ConfigureAwait(false),
Throws.Exception.Message.Contains("Initial Catalog property is mandatory in the connection string."));
}
public Publisher()
{
var transport = new SqlServerTransport(PublisherConnectionString);
transport.Subscriptions.DisableCaching = true;
transport.Subscriptions.SubscriptionTableName = new SubscriptionTableName("SubscriptionRouting", "dbo", "nservicebus");
EndpointSetup(new CustomizedServer(transport), (c, rd) => { });
}
internal SqlServerTransportInfrastructure(SqlServerTransport transport, HostSettings hostSettings, QueueAddressTranslator addressTranslator, bool isEncrypted)
{
this.transport = transport;
this.hostSettings = hostSettings;
this.isEncrypted = isEncrypted;
this.addressTranslator = addressTranslator;
tableBasedQueueCache = new TableBasedQueueCache(addressTranslator, !isEncrypted);
connectionFactory = CreateConnectionFactory();
}
static async Task Main()
{
Console.Title = "Samples.Sql.Receiver";
#region ReceiverConfiguration
var endpointConfiguration = new EndpointConfiguration("Samples.Sql.Receiver");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.AuditProcessedMessagesTo("audit");
endpointConfiguration.EnableInstallers();
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesSql;Integrated Security=True;Max Pool Size=100";
var transport = new SqlServerTransport(connection)
{
DefaultSchema = "receiver",
TransportTransactionMode = TransportTransactionMode.SendsAtomicWithReceive,
Subscriptions =
{
CacheInvalidationPeriod = TimeSpan.FromMinutes(1),
SubscriptionTableName = new SubscriptionTableName(
table: "Subscriptions", schema: "dbo")
}
};
transport.SchemaAndCatalog.UseSchemaForQueue("error", "dbo");
transport.SchemaAndCatalog.UseSchemaForQueue("audit", "dbo");
transport.SchemaAndCatalog.UseSchemaForQueue("Samples.Sql.Sender", "sender");
var routing = endpointConfiguration.UseTransport(transport);
routing.RouteToEndpoint(typeof(OrderAccepted), "Samples.Sql.Sender");
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
var dialect = persistence.SqlDialect <SqlDialect.MsSqlServer>();
dialect.Schema("receiver");
persistence.ConnectionBuilder(
connectionBuilder: () =>
{
return(new SqlConnection(connection));
});
persistence.TablePrefix("");
#endregion
SqlHelper.CreateSchema(connection, "receiver");
var allText = File.ReadAllText("Startup.sql");
SqlHelper.ExecuteSql(connection, allText);
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
void MessageBodyStringConfiguration()
{
#region MessageBodyString-config
var transport = new SqlServerTransport("connectionString")
{
CreateMessageBodyComputedColumn = true
};
#endregion
}
public ConfigureEndpointSqlServerTransport()
{
var connectionString = Environment.GetEnvironmentVariable("SqlServerTransportConnectionString") ?? @"Data Source=.\SQLEXPRESS;Initial Catalog=nservicebus;Integrated Security=True";
transport = new SqlServerTransport(connectionString);
transport.Subscriptions.DisableCaching = true;
#if !NETFRAMEWORK
transport.TransportTransactionMode = TransportTransactionMode.SendsAtomicWithReceive;
#endif
}
void OverwriteDefaultCatalog()
{
#region sqlserver-default-catalog
var transport = new SqlServerTransport("connectionString")
{
DefaultCatalog = "mycatalog"
};
#endregion
}
public Subscriber()
{
var transport = new SqlServerTransport(SubscriberConnectionString);
transport.Subscriptions.SubscriptionTableName = new SubscriptionTableName("SubscriptionRouting", "dbo", "nservicebus");
EndpointSetup(new CustomizedServer(transport), (c, rd) =>
{
c.DisableFeature <AutoSubscribe>();
});
}
void NonStandardSchema(EndpointConfiguration endpointConfiguration)
{
#region sqlserver-non-standard-schema
var transport = new SqlServerTransport("connectionString")
{
DefaultSchema = "myschema"
};
#endregion
}
protected override void SetUp()
{
SqlTestHelper.DropTable(_tableName);
_transport = new SqlServerTransport(new DbConnectionProvider(SqlTestHelper.ConnectionString), _tableName, QueueName);
_transport.EnsureTableIsCreated();
Using(_transport);
_transport.Initialize();
}
static async Task Main()
{
Console.Title = "Samples.SQLOutboxEF.Receiver";
var connection = @"Data Source=.\SqlExpress;Database=NsbSamplesSqlOutbox;Integrated Security=True;Max Pool Size=100";
var endpointConfiguration = new EndpointConfiguration("Samples.SqlOutbox.Receiver");
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
#region ReceiverConfiguration
var transport = new SqlServerTransport(connection)
{
DefaultSchema = "receiver",
};
transport.SchemaAndCatalog.UseSchemaForQueue("error", "dbo");
transport.SchemaAndCatalog.UseSchemaForQueue("audit", "dbo");
var routing = endpointConfiguration.UseTransport(transport);
routing.UseSchemaForEndpoint("Samples.SqlOutbox.Sender", "sender");
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
persistence.ConnectionBuilder(
connectionBuilder: () =>
{
return(new SqlConnection(connection));
});
var dialect = persistence.SqlDialect <SqlDialect.MsSqlServer>();
dialect.Schema("receiver");
persistence.TablePrefix("");
transport.Subscriptions.DisableCaching = true;
transport.Subscriptions.SubscriptionTableName = new SubscriptionTableName(
table: "Subscriptions",
schema: "dbo");
endpointConfiguration.EnableOutbox();
#endregion
SqlHelper.CreateSchema(connection, "receiver");
SqlHelper.ExecuteSql(connection, File.ReadAllText("Startup.sql"));
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
ConfigurationSettings(EndpointConfiguration endpointConfiguration)
{
// ReSharper disable UseObjectOrCollectionInitializer
#region sqlserver-TimeToWaitBeforeTriggeringCircuitBreaker
var transport = new SqlServerTransport("connectionString")
{
TimeToWaitBeforeTriggeringCircuitBreaker = TimeSpan.FromMinutes(3)
};
#endregion
// ReSharper restore UseObjectOrCollectionInitializer
}
public ITransport CreateOneWayClient()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var transport = new SqlServerTransport(connectionProvider, null, consoleLoggerFactory, asyncTaskFactory);
_disposables.Add(transport);
transport.Initialize();
return(transport);
}
void ConfigureSubscriptionCache(EndpointConfiguration endpointConfiguration)
{
#region configure-subscription-cache
var transport = new SqlServerTransport("connectionString")
{
Subscriptions =
{
CacheInvalidationPeriod = TimeSpan.FromMinutes(1)
}
};
#endregion
}
protected override void SetUp()
{
SqlTestHelper.DropTable(_tableName);
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
_transport = new SqlServerTransport(connectionProvider, _tableName, QueueName, consoleLoggerFactory);
_transport.EnsureTableIsCreated();
Using(_transport);
_transport.Initialize();
}
public void It_overrides_catalog_with_default_catalog(string connectionString, string defaultCatalog)
{
var transport = new SqlServerTransport(connectionString)
{
DefaultCatalog = defaultCatalog
};
// Confirm Catalog is not set prior to parsing.
Assert.IsNull(transport.Catalog);
transport.ParseConnectionAttributes();
Assert.AreEqual(defaultCatalog, transport.Catalog);
}
public void It_uses_default_catalog_for_transport_addresses(string connectionString, string defaultCatalog)
{
var transport = new SqlServerTransport(connectionString)
{
DefaultCatalog = defaultCatalog
};
#pragma warning disable CS0618 // Type or member is obsolete
string transportAddress = transport.ToTransportAddress(new Transport.QueueAddress("endpointName", null, null, null));
#pragma warning restore CS0618 // Type or member is obsolete
var catalogName = transportAddress.Split('@').Last();
Assert.AreEqual($"[{defaultCatalog}]", catalogName);
}
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.");
}
public Subscriber()
{
var transport = new SqlServerTransport(SubscriberConnectionString);
transport.Subscriptions.SubscriptionTableName = new SubscriptionTableName("SubscriptionRouting", "dbo", "nservicebus");
EndpointSetup(new CustomizedServer(transport), (c, rd) =>
{
var routing = c.ConfigureRouting();
routing.EnableMessageDrivenPubSubCompatibilityMode()
.RegisterPublisher(typeof(Event), PublisherEndpoint);
routing.UseCatalogForEndpoint(PublisherEndpoint, "nservicebus1");
});
}
public void It_accepts_connection_string_with_catalog_property(string connectionString)
{
var definition = new SqlServerTransport();
var subscriptionSettings = new SubscriptionSettings();
subscriptionSettings.DisableSubscriptionCache();
var settings = new SettingsHolder();
settings.Set(subscriptionSettings);
definition.Initialize(settings, connectionString);
Assert.Pass();
}
void DisableSubscriptionCache(EndpointConfiguration endpointConfiguration)
{
#region disable-subscription-cache
var transport = new SqlServerTransport("connectionString")
{
Subscriptions =
{
DisableCaching = true
}
};
#endregion
}
