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 KafkaMessageSender(IRoutingTopology routingTopology, IChannelProvider channelProvider, BehaviorContext context)
{
this.routingTopology = routingTopology;
this.channelProvider = channelProvider;
this.context = context;
}
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;
}
