public DelaysMigrateCommand(RabbitMQ.ConnectionFactory connectionFactory, IRoutingTopology routingTopology, bool quietMode, IConsole console) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; this.quietMode = quietMode; this.console = console; }
public MessagePump( ReceiveSettings settings, ConnectionFactory connectionFactory, IRoutingTopology routingTopology, MessageConverter messageConverter, string consumerTag, ChannelProvider channelProvider, TimeSpan timeToWaitBeforeTriggeringCircuitBreaker, PrefetchCountCalculation prefetchCountCalculation, Action <string, Exception, CancellationToken> criticalErrorAction, TimeSpan retryDelay) { this.settings = settings; this.connectionFactory = connectionFactory; this.messageConverter = messageConverter; this.consumerTag = consumerTag; this.channelProvider = channelProvider; this.timeToWaitBeforeTriggeringCircuitBreaker = timeToWaitBeforeTriggeringCircuitBreaker; this.prefetchCountCalculation = prefetchCountCalculation; this.criticalErrorAction = criticalErrorAction; this.retryDelay = retryDelay; ReceiveAddress = RabbitMQTransportInfrastructure.TranslateAddress(settings.ReceiveAddress); if (settings.UsePublishSubscribe) { Subscriptions = new SubscriptionManager(connectionFactory, routingTopology, ReceiveAddress); } queuePurger = new QueuePurger(connectionFactory); name = $"{ReceiveAddress} MessagePump"; }
public RabbitMQTransportInfrastructure(SettingsHolder settings, string connectionString) { this.settings = settings; var connectionConfiguration = ConnectionConfiguration.Create(connectionString, settings.EndpointName()); X509CertificateCollection clientCertificates; settings.TryGet(SettingsKeys.ClientCertificates, out clientCertificates); connectionFactory = new ConnectionFactory(connectionConfiguration, clientCertificates); routingTopology = CreateRoutingTopology(); routingTopologySupportsDelayedDelivery = routingTopology is ISupportDelayedDelivery; settings.Set(SettingsKeys.RoutingTopologySupportsDelayedDelivery, routingTopologySupportsDelayedDelivery); bool usePublisherConfirms; if (!settings.TryGet(SettingsKeys.UsePublisherConfirms, out usePublisherConfirms)) { usePublisherConfirms = true; } settings.TryGet(SettingsKeys.DisableTimeoutManager, out disableTimeoutManager); bool allEndpointsSupportDelayedDelivery; settings.TryGet(SettingsKeys.AllEndpointsSupportDelayedDelivery, out allEndpointsSupportDelayedDelivery); channelProvider = new ChannelProvider(connectionFactory, routingTopology, usePublisherConfirms, allEndpointsSupportDelayedDelivery); RequireOutboxConsent = false; }
public ChannelProvider(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, bool usePublisherConfirms) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; this.usePublisherConfirms = usePublisherConfirms; channels = new ConcurrentQueue <ConfirmsAwareChannel>(); }
public ChannelProvider(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, bool usePublisherConfirms) { connection = new Lazy <IConnection>(() => connectionFactory.CreatePublishConnection()); this.routingTopology = routingTopology; this.usePublisherConfirms = usePublisherConfirms; channels = new ConcurrentQueue <ConfirmsAwareChannel>(); }
public ChannelProvider(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, bool usePublisherConfirms, bool allEndpointsSupportDelayedDelivery) { connection = new Lazy <IConnection>(() => connectionFactory.CreatePublishConnection()); this.routingTopology = routingTopology; this.usePublisherConfirms = usePublisherConfirms; this.allEndpointsSupportDelayedDelivery = allEndpointsSupportDelayedDelivery; channels = new ConcurrentQueue <ConfirmsAwareChannel>(); }
public RabbitMQTransportInfrastructure(HostSettings hostSettings, ReceiveSettings[] receiverSettings, ConnectionFactory connectionFactory, IRoutingTopology routingTopology, ChannelProvider channelProvider, MessageConverter messageConverter, TimeSpan timeToWaitBeforeTriggeringCircuitBreaker, PrefetchCountCalculation prefetchCountCalculation) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; this.channelProvider = channelProvider; Dispatcher = new MessageDispatcher(channelProvider); Receivers = receiverSettings.Select(x => CreateMessagePump(hostSettings, x, messageConverter, timeToWaitBeforeTriggeringCircuitBreaker, prefetchCountCalculation)) .ToDictionary(x => x.Id, x => x); }
public ConfirmsAwareChannel(IConnection connection, IRoutingTopology routingTopology) { channel = connection.CreateModel(); channel.BasicAcks += Channel_BasicAcks; channel.BasicNacks += Channel_BasicNacks; channel.BasicReturn += Channel_BasicReturn; channel.ModelShutdown += Channel_ModelShutdown; channel.ConfirmSelect(); this.routingTopology = routingTopology; messages = new ConcurrentDictionary <ulong, TaskCompletionSource <bool> >(); }
public RabbitMQTransportInfrastructure(SettingsHolder settings, string connectionString) { this.settings = settings; var endpointName = settings.EndpointName(); var connectionConfiguration = ConnectionConfiguration.Create(connectionString, endpointName); settings.TryGet(SettingsKeys.ClientCertificateCollection, out X509Certificate2Collection clientCertificateCollection); settings.TryGet(SettingsKeys.DisableRemoteCertificateValidation, out bool disableRemoteCertificateValidation); settings.TryGet(SettingsKeys.UseExternalAuthMechanism, out bool useExternalAuthMechanism); settings.TryGet(SettingsKeys.HeartbeatInterval, out TimeSpan? heartbeatInterval); settings.TryGet(SettingsKeys.NetworkRecoveryInterval, out TimeSpan? networkRecoveryInterval); connectionFactory = new ConnectionFactory(endpointName, connectionConfiguration, clientCertificateCollection, disableRemoteCertificateValidation, useExternalAuthMechanism, heartbeatInterval, networkRecoveryInterval); routingTopology = CreateRoutingTopology(); channelProvider = new ChannelProvider(connectionFactory, connectionConfiguration.RetryDelay, routingTopology); }
/// <summary> /// Creates new instance of the RabbitMQ transport. /// </summary> /// <param name="topology">The custom topology to use.</param> /// <param name="connectionString">Connection string.</param> /// <param name="queueMode">The queue mode for receiving queues.</param> /// <param name="enableTimeouts">Whether to enable timeouts.</param> private protected RabbitMQTransport(IRoutingTopology topology, string connectionString, QueueMode queueMode, bool enableTimeouts) : base(TransportTransactionMode.ReceiveOnly, supportsDelayedDelivery: enableTimeouts, supportsPublishSubscribe: true, supportsTTBR: queueMode == QueueMode.Classic) { Guard.AgainstNull(nameof(topology), topology); Guard.AgainstNull(nameof(connectionString), connectionString); QueueMode = queueMode; RoutingTopology = topology; if (connectionString.StartsWith("amqp", StringComparison.OrdinalIgnoreCase)) { AmqpConnectionString.Parse(connectionString)(this); } else { NServiceBusConnectionString.Parse(connectionString)(this); } }
public RabbitMQTransportInfrastructure(SettingsHolder settings, string connectionString) { this.settings = settings; var connectionConfiguration = ConnectionConfiguration.Create(connectionString, settings.EndpointName()); settings.TryGet(SettingsKeys.ClientCertificates, out X509CertificateCollection clientCertificates); settings.TryGet(SettingsKeys.DisableRemoteCertificateValidation, out bool disableRemoteCertificateValidation); settings.TryGet(SettingsKeys.UseExternalAuthMechanism, out bool useExternalAuthMechanism); connectionFactory = new ConnectionFactory(connectionConfiguration, clientCertificates, disableRemoteCertificateValidation, useExternalAuthMechanism); routingTopology = CreateRoutingTopology(); if (!settings.TryGet(SettingsKeys.UsePublisherConfirms, out bool usePublisherConfirms)) { usePublisherConfirms = true; } channelProvider = new ChannelProvider(connectionFactory, connectionConfiguration.RetryDelay, routingTopology, usePublisherConfirms); }
public MessagePump(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, MessageConverter messageConverter, string consumerTag, ChannelProvider channelProvider, TimeSpan timeToWaitBeforeTriggeringCircuitBreaker, PrefetchCountCalculation prefetchCountCalculation, ReceiveSettings settings, Action <string, Exception, CancellationToken> criticalErrorAction) { this.connectionFactory = connectionFactory; this.messageConverter = messageConverter; this.consumerTag = consumerTag; this.channelProvider = channelProvider; this.timeToWaitBeforeTriggeringCircuitBreaker = timeToWaitBeforeTriggeringCircuitBreaker; this.prefetchCountCalculation = prefetchCountCalculation; this.settings = settings; this.criticalErrorAction = criticalErrorAction; if (settings.UsePublishSubscribe) { Subscriptions = new SubscriptionManager(connectionFactory, routingTopology, settings.ReceiveAddress); } queuePurger = new QueuePurger(connectionFactory); }
public RabbitMQTransportInfrastructure(SettingsHolder settings, string connectionString) { this.settings = settings; var connectionConfiguration = new ConnectionStringParser(settings).Parse(connectionString); connectionFactory = new ConnectionFactory(connectionConfiguration); routingTopology = CreateRoutingTopology(); bool usePublisherConfirms; if (!settings.TryGet(SettingsKeys.UsePublisherConfirms, out usePublisherConfirms)) { usePublisherConfirms = true; } channelProvider = new ChannelProvider(connectionFactory, routingTopology, usePublisherConfirms); RequireOutboxConsent = false; }
public ConfirmsAwareChannel(IConnection connection, IRoutingTopology routingTopology, bool usePublisherConfirms) { channel = connection.CreateModel(); channel.BasicReturn += Channel_BasicReturn; this.routingTopology = routingTopology; delayTopology = routingTopology as ISupportDelayedDelivery; this.usePublisherConfirms = usePublisherConfirms; if (usePublisherConfirms) { channel.ConfirmSelect(); channel.BasicAcks += Channel_BasicAcks; channel.BasicNacks += Channel_BasicNacks; channel.ModelShutdown += Channel_ModelShutdown; messages = new ConcurrentDictionary <ulong, TaskCompletionSource <bool> >(); } }
public RabbitMQTransportInfrastructure(SettingsHolder settings, string connectionString) { this.settings = settings; var connectionConfiguration = ConnectionConfiguration.Create(connectionString, settings.EndpointName()); X509CertificateCollection clientCertificates; settings.TryGet(SettingsKeys.ClientCertificates, out clientCertificates); connectionFactory = new ConnectionFactory(connectionConfiguration, clientCertificates); routingTopology = CreateRoutingTopology(); var routingTopologySupportsDelayedDelivery = routingTopology is ISupportDelayedDelivery; settings.Set(SettingsKeys.RoutingTopologySupportsDelayedDelivery, routingTopologySupportsDelayedDelivery); if (routingTopologySupportsDelayedDelivery) { var timeoutManagerFeatureDisabled = settings.GetOrDefault <FeatureState>(typeof(TimeoutManager).FullName) == FeatureState.Disabled; var sendOnlyEndpoint = settings.GetOrDefault <bool>(coreSendOnlyEndpointKey); if (timeoutManagerFeatureDisabled || sendOnlyEndpoint) { settings.Set(SettingsKeys.DisableTimeoutManager, true); } } bool usePublisherConfirms; if (!settings.TryGet(SettingsKeys.UsePublisherConfirms, out usePublisherConfirms)) { usePublisherConfirms = true; } channelProvider = new ChannelProvider(connectionFactory, routingTopology, usePublisherConfirms); RequireOutboxConsent = false; }
public QueueCreator(ConnectionFactory connectionFactory, IRoutingTopology routingTopology) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; }
public TestRabbitMQTransport(IRoutingTopology topology, string connectionString, QueueMode queueMode, bool enableTimeouts) : base(topology, connectionString, queueMode, enableTimeouts) { }
/// <summary> /// Creates new instance of the RabbitMQ transport. /// </summary> /// <param name="topology">The custom topology to use.</param> /// <param name="connectionString">Connection string.</param> public RabbitMQTransport(IRoutingTopology topology, string connectionString) : this(topology, connectionString, QueueMode.Classic, true) { }
public QueueCreator(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, bool durableMessagesEnabled) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; this.durableMessagesEnabled = durableMessagesEnabled; }
public ChannelProvider(ConnectionFactory connectionFactory, TimeSpan retryDelay, IRoutingTopology routingTopology) { this.connectionFactory = connectionFactory; this.retryDelay = retryDelay; this.routingTopology = routingTopology; channels = new ConcurrentQueue <ConfirmsAwareChannel>(); }
public KafkaMessageSender(IRoutingTopology routingTopology, IChannelProvider channelProvider, BehaviorContext context) { this.routingTopology = routingTopology; this.channelProvider = channelProvider; this.context = context; }
public SubscriptionManager(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, string localQueue) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; this.localQueue = localQueue; }
public static RoutingTopology Custom(IRoutingTopology routingTopology) { return(new RoutingTopology(() => routingTopology)); }
public EndpointCreateCommand(ConnectionFactory connectionFactory, IRoutingTopology routingTopology, IConsole console) { this.connectionFactory = connectionFactory; this.routingTopology = routingTopology; this.console = console; }