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 }