public Receiver(MessageReceiver messageReceiver, Uri inputAddress, IPipe<ReceiveContext> receivePipe, ReceiveSettings receiveSettings,
IReceiveObserver receiveObserver, ITaskSupervisor supervisor)
{
_messageReceiver = messageReceiver;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveSettings = receiveSettings;
_receiveObserver = receiveObserver;
_supervisor = supervisor;
_participant = supervisor.CreateParticipant();
var options = new OnMessageOptions
{
AutoComplete = false,
AutoRenewTimeout = receiveSettings.AutoRenewTimeout,
MaxConcurrentCalls = receiveSettings.MaxConcurrentCalls
};
options.ExceptionReceived += (sender, x) =>
{
if (_log.IsErrorEnabled)
_log.Error($"Exception received on receiver: {_inputAddress} during {x.Action}", x.Exception);
_participant.SetComplete();
};
messageReceiver.OnMessageAsync(OnMessage, options);
_participant.SetReady();
SetupStopTask();
}
/// <summary>
/// Adds a RabbitMQ Basic Consumer to the pipeline
/// </summary>
/// <param name="configurator"></param>
/// <param name="pipe"></param>
/// <param name="settings"></param>
/// <param name="receiveObserver"></param>
/// <param name="endpointObserver"></param>
/// <param name="exchangeBindings"></param>
/// <param name="taskSupervisor"></param>
/// <param name="mediator"></param>
public static void RabbitMqConsumer(this IPipeConfigurator<ConnectionContext> configurator, IPipe<ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver, IEnumerable<ExchangeBindingSettings> exchangeBindings, ITaskSupervisor taskSupervisor, Mediator<ISetPrefetchCount> mediator)
{
if (configurator == null)
throw new ArgumentNullException(nameof(configurator));
var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, endpointObserver, exchangeBindings, taskSupervisor, mediator);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
public HttpReceiveTransport(IHttpHost host, ReceiveSettings receiveSettings, ISendPipe sendPipe)
{
_host = host;
_receiveSettings = receiveSettings;
_sendPipe = sendPipe;
_receiveObservable = new ReceiveObservable();
_receiveTransportObservable = new ReceiveTransportObservable();
}
public ServiceBusReceiveTransport(IServiceBusHost host, ReceiveSettings settings,
params TopicSubscriptionSettings[] subscriptionSettings)
{
_host = host;
_settings = settings;
_subscriptionSettings = subscriptionSettings;
_receiveObservers = new ReceiveObservable();
_endpointObservers = new ReceiveEndpointObservable();
}
public RabbitMqReceiveTransport(IConnectionCache connectionCache, ReceiveSettings settings,
params ExchangeBindingSettings[] exchangeBindings)
{
_connectionCache = connectionCache;
_settings = settings;
_exchangeBindings = exchangeBindings;
_receiveObservers = new ReceiveObservable();
_endpointObservers = new ReceiveEndpointObservable();
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings,
params ExchangeBindingSettings[] exchangeBindings)
{
_host = host;
_settings = settings;
_exchangeBindings = exchangeBindings;
_receiveObservers = new ReceiveObservable();
_endpointObservers = new ReceiveEndpointObservable();
}
public ServiceBusReceiveTransport(IServiceBusHost host, ReceiveSettings settings, params TopicSubscriptionSettings[] subscriptionSettings)
{
_host = host;
_settings = settings;
_subscriptionSettings = subscriptionSettings;
_receiveObservers = new ReceiveObservable();
_endpointObservers = new ReceiveEndpointObservable();
_connectionRetryPolicy = Retry.Exponential(1000, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(1));
}
/// <summary>
/// Adds a RabbitMQ Basic Consumer to the pipeline
/// </summary>
/// <param name="configurator"></param>
/// <param name="pipe"></param>
/// <param name="settings"></param>
/// <param name="receiveObserver"></param>
/// <param name="transportObserver"></param>
/// <param name="exchangeBindings"></param>
/// <param name="supervisor"></param>
/// <param name="managementPipe"></param>
/// <param name="sendEndpointProvider"></param>
/// <param name="publishEndpointProvider"></param>
/// <param name="host"></param>
public static void RabbitMqConsumer(this IPipeConfigurator<ConnectionContext> configurator, IPipe<ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveTransportObserver transportObserver, IEnumerable<ExchangeBindingSettings> exchangeBindings, ITaskSupervisor supervisor, IManagementPipe managementPipe, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider, IRabbitMqHost host)
{
if (configurator == null)
throw new ArgumentNullException(nameof(configurator));
var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, transportObserver, exchangeBindings,
supervisor, managementPipe, sendEndpointProvider, publishEndpointProvider, host);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, IManagementPipe managementPipe,
params ExchangeBindingSettings[] bindings)
{
_host = host;
_settings = settings;
_bindings = bindings;
_managementPipe = managementPipe;
_receiveObservable = new ReceiveObservable();
_receiveEndpointObservable = new ReceiveEndpointObservable();
}
public HttpResponseSendEndpointProvider(ReceiveSettings receiveSettings,
IOwinContext owinContext,
Uri inputAddress,
ISendPipe sendPipe)
{
_receiveSettings = receiveSettings;
_owinContext = owinContext;
_inputAddress = inputAddress;
_sendPipe = sendPipe;
_observers = new SendObservable();
}
/// <summary>
/// Adds a RabbitMQ Basic Consumer to the pipeline
/// </summary>
/// <param name="configurator"></param>
/// <param name="receivePipe"></param>
/// <param name="settings"></param>
/// <param name="receiveSettings"></param>
/// <param name="receiveObserver"></param>
/// <param name="receiveTransportObserver"></param>
/// <param name="supervisor"></param>
/// <param name="sendPipe"></param>
public static void HttpConsumer(this IPipeConfigurator<OwinHostContext> configurator, IPipe<ReceiveContext> receivePipe, HttpHostSettings settings,
ReceiveSettings receiveSettings,
IReceiveObserver receiveObserver, IReceiveTransportObserver receiveTransportObserver, ITaskSupervisor supervisor,
ISendPipe sendPipe)
{
if (configurator == null)
throw new ArgumentNullException(nameof(configurator));
var pipeBuilderConfigurator = new HttpConsumerPipeSpecification(settings, receiveSettings, receivePipe, receiveObserver, receiveTransportObserver,
supervisor, sendPipe);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
public RabbitMqReceiveSettings(ReceiveSettings settings)
: base(settings)
{
QueueName = settings.QueueName;
ExchangeName = settings.ExchangeName;
PrefetchCount = settings.PrefetchCount;
Durable = settings.Durable;
Exclusive = settings.Exclusive;
AutoDelete = settings.AutoDelete;
PurgeOnStartup = settings.PurgeOnStartup;
ExchangeType = settings.ExchangeType;
QueueArguments = new Dictionary<string, object>(settings.QueueArguments);
}
/// <summary>
/// The basic consumer receives messages pushed from the broker.
/// </summary>
/// <param name="model">The model context for the consumer</param>
/// <param name="inputAddress">The input address for messages received by the consumer</param>
/// <param name="receivePipe">The receive pipe to dispatch messages</param>
/// <param name="receiveObserver">The observer for receive events</param>
/// <param name="taskSupervisor">The token used to cancel/stop the consumer at shutdown</param>
public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe<ReceiveContext> receivePipe, IReceiveObserver receiveObserver,
ITaskSupervisor taskSupervisor)
{
_model = model;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_receiveSettings = model.GetPayload<ReceiveSettings>();
_pending = new ConcurrentDictionary<ulong, RabbitMqReceiveContext>();
_participant = taskSupervisor.CreateParticipant();
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, IManagementPipe managementPipe, ExchangeBindingSettings[] bindings, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_host = host;
_settings = settings;
_bindings = bindings;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_managementPipe = managementPipe;
_receiveObservable = new ReceiveObservable();
_receiveTransportObservable = new ReceiveTransportObservable();
_inputAddress = _settings.GetInputAddress(_host.Settings.HostAddress);
}
/// <summary>
/// The basic consumer receives messages pushed from the broker.
/// </summary>
/// <param name="model">The model context for the consumer</param>
/// <param name="inputAddress">The input address for messages received by the consumer</param>
/// <param name="receivePipe">The receive pipe to dispatch messages</param>
/// <param name="receiveObserver">The observer for receive events</param>
/// <param name="taskSupervisor">The token used to cancel/stop the consumer at shutdown</param>
public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe<ReceiveContext> receivePipe, IReceiveObserver receiveObserver,
ITaskScope taskSupervisor)
{
_model = model;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_receiveSettings = model.GetPayload<ReceiveSettings>();
_pending = new ConcurrentDictionary<ulong, RabbitMqReceiveContext>();
_participant = taskSupervisor.CreateParticipant($"{TypeMetadataCache<RabbitMqBasicConsumer>.ShortName} - {inputAddress}", Stop);
_deliveryComplete = new TaskCompletionSource<bool>();
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, Mediator<ISetPrefetchCount> mediator,
params ExchangeBindingSettings[] bindings)
{
_host = host;
_settings = settings;
_bindings = bindings;
_mediator = mediator;
_receiveObservable = new ReceiveObservable();
_receiveEndpointObservable = new ReceiveEndpointObservable();
var exceptionFilter = Retry.Selected<RabbitMqConnectionException>();
_connectionRetryPolicy = exceptionFilter.Exponential(1000, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(1));
}
public static Uri GetInputAddress(this RabbitMqHostSettings hostSettings, ReceiveSettings receiveSettings)
{
var builder = new UriBuilder
{
Scheme = "rabbitmq",
Host = hostSettings.Host,
Port = hostSettings.Port,
Path = (string.IsNullOrWhiteSpace(hostSettings.VirtualHost) || hostSettings.VirtualHost == "/")
? receiveSettings.QueueName
: string.Join("/", hostSettings.VirtualHost, receiveSettings.QueueName)
};
builder.Query += string.Join("&", GetQueryStringOptions(receiveSettings));
return builder.Uri;
}
public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe<ReceiveContext> receivePipe, IReceiveObserver receiveObserver,
CancellationToken cancellationToken)
{
_model = model;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_receiveSettings = model.GetPayload<ReceiveSettings>();
_pending = new ConcurrentDictionary<ulong, RabbitMqReceiveContext>();
_consumerComplete = new TaskCompletionSource<RabbitMqConsumerMetrics>();
_registration = cancellationToken.Register(Complete);
}
public SessionReceiver(QueueClient queueClient, Uri inputAddress, IPipe<ReceiveContext> receivePipe, ReceiveSettings receiveSettings,
IReceiveObserver receiveObserver, ITaskSupervisor supervisor)
{
_queueClient = queueClient;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveSettings = receiveSettings;
_receiveObserver = receiveObserver;
_supervisor = supervisor;
_participant = supervisor.CreateParticipant();
var options = new SessionHandlerOptions
{
AutoComplete = false,
AutoRenewTimeout = receiveSettings.AutoRenewTimeout,
MaxConcurrentSessions = receiveSettings.MaxConcurrentCalls,
MessageWaitTimeout = receiveSettings.MessageWaitTimeout
};
options.ExceptionReceived += (sender, x) =>
{
if (!(x.Exception is OperationCanceledException))
{
if (_log.IsErrorEnabled)
_log.Error($"Exception received on session receiver: {_inputAddress} during {x.Action}", x.Exception);
}
if (_currentPendingDeliveryCount == 0)
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Session receiver shutdown completed: {0}", _inputAddress);
_participant.SetComplete();
}
};
IMessageSessionAsyncHandlerFactory handlerFactory = new MessageSessionAsyncHandlerFactory(supervisor, this);
queueClient.RegisterSessionHandlerFactoryAsync(handlerFactory, options);
_participant.SetReady();
SetupStopTask();
}
public HttpConsumerAction(IReceiveObserver receiveObserver,
HttpHostSettings settings,
ReceiveSettings receiveSettings,
IPipe<ReceiveContext> receivePipe,
ITaskScope taskSupervisor,
ISendPipe sendPipe)
{
_receiveObserver = receiveObserver;
_receiveSettings = receiveSettings;
_receivePipe = receivePipe;
_sendPipe = sendPipe;
_tracker = new DeliveryTracker(OnDeliveryComplete);
_inputAddress = settings.GetInputAddress();
_participant = taskSupervisor.CreateParticipant($"{TypeMetadataCache<HttpConsumerAction>.ShortName} - {_inputAddress}", Stop);
_deliveryComplete = new TaskCompletionSource<bool>();
_participant.SetReady();
}
public Receiver(ConnectionContext context, MessageReceiver messageReceiver, Uri inputAddress, IPipe<ReceiveContext> receivePipe, ReceiveSettings receiveSettings,
IReceiveObserver receiveObserver, ITaskSupervisor supervisor)
{
_context = context;
_messageReceiver = messageReceiver;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveSettings = receiveSettings;
_receiveObserver = receiveObserver;
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {inputAddress}", Stop);
var options = new OnMessageOptions
{
AutoComplete = false,
AutoRenewTimeout = receiveSettings.AutoRenewTimeout,
MaxConcurrentCalls = receiveSettings.MaxConcurrentCalls
};
options.ExceptionReceived += (sender, x) =>
{
if (!(x.Exception is OperationCanceledException))
{
if (_log.IsErrorEnabled)
_log.Error($"Exception received on receiver: {_inputAddress} during {x.Action}", x.Exception);
}
if (_currentPendingDeliveryCount == 0)
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Receiver shutdown completed: {0}", _inputAddress);
_participant.SetComplete();
}
};
messageReceiver.OnMessageAsync(OnMessage, options);
_participant.SetReady();
}
public Receiver(MessageReceiver messageReceiver, Uri inputAddress, IPipe<ReceiveContext> receivePipe,
ReceiveSettings receiveSettings, IReceiveObserver receiveObserver, CancellationToken cancellationToken)
{
_messageReceiver = messageReceiver;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveSettings = receiveSettings;
_receiveObserver = receiveObserver;
_completeTask = new TaskCompletionSource<ReceiverMetrics>();
_registration = cancellationToken.Register(Shutdown);
var options = new OnMessageOptions
{
AutoComplete = false,
AutoRenewTimeout = receiveSettings.AutoRenewTimeout,
MaxConcurrentCalls = receiveSettings.MaxConcurrentCalls,
};
options.ExceptionReceived += (sender, x) => _completeTask.TrySetException(x.Exception);
messageReceiver.OnMessageAsync(OnMessage, options);
}
public QueueClientContextFactory(IMessagingFactoryCache messagingFactoryCache, INamespaceCache namespaceCache, IPipe <MessagingFactoryContext> messagingFactoryPipe,
IPipe <NamespaceContext> namespacePipe, ReceiveSettings settings)
: base(messagingFactoryCache, namespaceCache, messagingFactoryPipe, namespacePipe, settings)
{
_settings = settings;
}
public PrepareReceiveQueueFilter(ReceiveSettings settings, params TopicSubscriptionSettings[] subscriptionSettings)
{
_settings = settings;
_subscriptionSettings = subscriptionSettings;
}
public void WhenParsed()
{
_hostSettings = _hostUri.GetHostSettings();
_receiveSettings = _uri.GetReceiveSettings();
}
public PrepareReceiveQueueFilter(ReceiveSettings settings, params ExchangeBindingSettings[] exchangeBindings)
{
_settings = settings;
_exchangeBindings = exchangeBindings;
}
public void WhenParsed()
{
_receiveSettings = _uri.GetReceiveSettings();
}
/// <summary>
/// Adds a RabbitMQ Basic Consumer to the pipeline
/// </summary>
/// <param name="configurator"></param>
/// <param name="pipe"></param>
/// <param name="settings"></param>
/// <param name="receiveObserver"></param>
/// <param name="endpointObserver"></param>
/// <param name="exchangeBindings"></param>
/// <param name="taskSupervisor"></param>
/// <param name="mediator"></param>
public static void RabbitMqConsumer(this IPipeConfigurator <ConnectionContext> configurator, IPipe <ReceiveContext> pipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver, IEnumerable <ExchangeBindingSettings> exchangeBindings, ITaskSupervisor taskSupervisor, Mediator <ISetPrefetchCount> mediator)
{
if (configurator == null)
{
throw new ArgumentNullException(nameof(configurator));
}
var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, endpointObserver, exchangeBindings, taskSupervisor, mediator);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
public ConsumerContextFactory(IClientContextSupervisor clientContextSupervisor, ReceiveSettings receiveSettings,
IHostConfiguration hostConfiguration, IHeadersDeserializer headersDeserializer, Func <ConsumerBuilder <TKey, TValue> > consumerBuilderFactory)
{
_clientContextSupervisor = clientContextSupervisor;
_receiveSettings = receiveSettings;
_headersDeserializer = headersDeserializer;
_hostConfiguration = hostConfiguration;
_consumerBuilderFactory = consumerBuilderFactory;
}
public PrepareQueueClientFilter(ReceiveSettings settings)
{
_settings = settings;
}
public ProcessorLockContext(IHostConfiguration hostConfiguration, ReceiveSettings receiveSettings)
{
_hostConfiguration = hostConfiguration;
_timeout = receiveSettings.CheckpointInterval;
_maxCount = receiveSettings.CheckpointMessageCount;
}
static IEnumerable<string> GetQueryStringOptions(ReceiveSettings settings)
{
if (!settings.Durable)
yield return "durable=false";
if (settings.AutoDelete)
yield return "autodelete=true";
if (settings.Exclusive)
yield return "exclusive=true";
if (settings.PrefetchCount != 0)
yield return "prefetch=" + settings.PrefetchCount;
}
public void WhenParsed()
{
_receiveSettings = _uri.GetReceiveSettings();
}
public PrepareReceiveEndpointFilter(ReceiveSettings settings, params TopicSubscriptionSettings[] subscriptions)
{
_settings = settings;
_subscriptions = subscriptions;
}
public SessionReceiver(QueueClient queueClient, Uri inputAddress, IPipe <ReceiveContext> receivePipe, ReceiveSettings receiveSettings,
IReceiveObserver receiveObserver, ITaskSupervisor supervisor)
{
_queueClient = queueClient;
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveSettings = receiveSettings;
_receiveObserver = receiveObserver;
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {inputAddress}", Stop);
var options = new SessionHandlerOptions
{
AutoComplete = false,
AutoRenewTimeout = receiveSettings.AutoRenewTimeout,
MaxConcurrentSessions = receiveSettings.MaxConcurrentCalls,
MessageWaitTimeout = receiveSettings.MessageWaitTimeout
};
options.ExceptionReceived += (sender, x) =>
{
if (!(x.Exception is OperationCanceledException))
{
if (_log.IsErrorEnabled)
{
_log.Error($"Exception received on session receiver: {_inputAddress} during {x.Action}", x.Exception);
}
}
if (_currentPendingDeliveryCount == 0)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Session receiver shutdown completed: {0}", _inputAddress);
}
_participant.SetComplete();
}
};
IMessageSessionAsyncHandlerFactory handlerFactory = new MessageSessionAsyncHandlerFactory(supervisor, this);
queueClient.RegisterSessionHandlerFactoryAsync(handlerFactory, options);
_participant.SetReady();
}
