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();
}
public RabbitMqConnectionCache(RabbitMqHostSettings settings, ITaskSupervisor supervisor)
{
_settings = settings;
_connectionFactory = settings.GetConnectionFactory();
_cacheTaskScope = supervisor.CreateScope($"{TypeMetadataCache<RabbitMqConnectionCache>.ShortName} - {settings.ToDebugString()}", CloseScope);
}
public RabbitMqModelCache(IConnectionCache connectionCache, ITaskSupervisor supervisor, ModelSettings modelSettings)
{
_connectionCache = connectionCache;
_modelSettings = modelSettings;
_cacheTaskScope = supervisor.CreateScope($"{TypeMetadataCache<RabbitMqModelCache>.ShortName}", CloseScope);
}
public ServiceBusSendTransport(MessageSender sender, ITaskSupervisor supervisor)
{
_observers = new SendObservable();
_sender = sender;
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<ServiceBusSendTransport>.ShortName} - {sender.Path}", StopSender);
}
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();
}
public ServiceBusSendTransport(ISendClient client, ITaskSupervisor supervisor)
{
_client = client;
_observers = new SendObservable();
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<ServiceBusSendTransport>.ShortName} - {client.Path}", StopSender);
}
public MessageReceiverFilter(IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver, ITaskSupervisor supervisor)
{
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_endpointObserver = endpointObserver;
_supervisor = supervisor;
}
public RabbitMqConnectionCache(RabbitMqHostSettings settings, ITaskSupervisor supervisor)
{
_settings = settings;
_connectionFactory = settings.GetConnectionFactory();
_cacheTaskScope = supervisor.CreateScope($"{TypeMetadataCache<RabbitMqConnectionCache>.ShortName} - {settings.ToDebugString()}", CloseScope);
}
public MessageSessionAsyncHandler(ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
{
_supervisor = supervisor;
_receiver = receiver;
_session = session;
_message = message;
}
public RabbitMqModelCache(IConnectionCache connectionCache, ITaskSupervisor supervisor, ModelSettings modelSettings)
{
_connectionCache = connectionCache;
_modelSettings = modelSettings;
_cacheTaskScope = supervisor.CreateScope($"{TypeMetadataCache<RabbitMqModelCache>.ShortName}", CloseScope);
}
public MessageSessionAsyncHandler(ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
{
_supervisor = supervisor;
_receiver = receiver;
_session = session;
_message = message;
}
public MessageSessionAsyncHandlerFactory(NamespaceContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, IDeliveryTracker tracker, IReceiveEndpointTopology topology)
{
_context = context;
_supervisor = supervisor;
_receiver = receiver;
_tracker = tracker;
_topology = topology;
}
public RabbitMqConsumerFilter(IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver,
ITaskSupervisor taskSupervisor)
{
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_endpointObserver = endpointObserver;
_taskSupervisor = taskSupervisor;
}
public MessageSessionAsyncHandler(ConnectionContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
{
_context = context;
_supervisor = supervisor;
_receiver = receiver;
_session = session;
_message = message;
}
public RabbitMqConsumerFilter(IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, IReceiveTransportObserver transportObserver, ITaskSupervisor supervisor, IReceiveEndpointTopology topology)
{
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_topology = topology;
}
public MessageSessionAsyncHandler(ConnectionContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, MessageSession session, BrokeredMessage message)
{
_context = context;
_supervisor = supervisor;
_receiver = receiver;
_session = session;
_message = message;
}
public ServiceBusNamespaceContext(IServiceBusHost host, IReceiveObserver receiveObserver, IReceiveTransportObserver receiveTransportObserver,
TaskSupervisor supervisor)
: base(new PayloadCache(), supervisor.StoppingToken)
{
_host = host;
_receiveObserver = receiveObserver;
_receiveTransportObserver = receiveTransportObserver;
_supervisor = supervisor;
}
public RabbitMqConsumerPipeSpecification(IPipe <ReceiveContext> receivePipe, ReceiveSettings settings, IReceiveObserver receiveObserver, IReceiveEndpointObserver endpointObserver, IEnumerable <ExchangeBindingSettings> exchangeBindings, ITaskSupervisor taskSupervisor)
{
_settings = settings;
_receiveObserver = receiveObserver;
_endpointObserver = endpointObserver;
_taskSupervisor = taskSupervisor;
_exchangeBindings = exchangeBindings.ToArray();
_receivePipe = receivePipe;
}
/// <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 RabbitMqConsumerFilter(IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, IReceiveTransportObserver transportObserver, ITaskSupervisor supervisor, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
}
public MessageSessionAsyncHandlerFactory(NamespaceContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, IDeliveryTracker tracker,
ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_context = context;
_supervisor = supervisor;
_receiver = receiver;
_tracker = tracker;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
}
/// <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 MessageSessionAsyncHandlerFactory(NamespaceContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, IDeliveryTracker tracker,
ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_context = context;
_supervisor = supervisor;
_receiver = receiver;
_tracker = tracker;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
}
public SessionReceiver(ClientContext clientContext, IPipe <ReceiveContext> receivePipe, ClientSettings clientSettings, ITaskSupervisor supervisor, IReceiveEndpointTopology topology)
{
_clientContext = clientContext;
_receivePipe = receivePipe;
_clientSettings = clientSettings;
_supervisor = supervisor;
_topology = topology;
_tracker = new DeliveryTracker(HandleDeliveryComplete);
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {clientContext.InputAddress}", Stop);
}
public RabbitMqConsumerPipeSpecification(IPipe <ReceiveContext> receivePipe, ReceiveSettings settings, IReceiveObserver receiveObserver,
IReceiveTransportObserver transportObserver, ITaskSupervisor supervisor, IConsumePipeConnector managementPipe, IRabbitMqHost host,
IRabbitMqReceiveEndpointTopology topology)
{
_settings = settings;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_receivePipe = receivePipe;
_managementPipe = managementPipe;
_host = host;
_topology = topology;
}
public static ITaskScope CreateScope(this ITaskSupervisor supervisor, string tag, Func <Task> afterStopped)
{
var scope = supervisor.CreateScope(tag);
scope.StopRequested.ContinueWith(async stopTask =>
{
var stopEvent = await stopTask.ConfigureAwait(false);
await scope.Stop(stopEvent.Reason, afterStopped).ConfigureAwait(false);
}, TaskScheduler.Default);
return(scope);
}
public SessionReceiver(ClientContext clientContext, IPipe<ReceiveContext> receivePipe, ClientSettings clientSettings, ITaskSupervisor supervisor, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_clientContext = clientContext;
_receivePipe = receivePipe;
_clientSettings = clientSettings;
_supervisor = supervisor;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_tracker = new DeliveryTracker(HandleDeliveryComplete);
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {clientContext.InputAddress}", Stop);
}
public RabbitMqConsumerPipeSpecification(IPipe <ReceiveContext> receivePipe, ReceiveSettings settings, IReceiveObserver receiveObserver,
IReceiveEndpointObserver endpointObserver, IEnumerable <ExchangeBindingSettings> exchangeBindings, ITaskSupervisor supervisor,
IManagementPipe managementPipe)
{
_settings = settings;
_receiveObserver = receiveObserver;
_endpointObserver = endpointObserver;
_supervisor = supervisor;
_exchangeBindings = exchangeBindings.ToArray();
_receivePipe = receivePipe;
_managementPipe = managementPipe;
_modelSettings = new RabbitMqModelSettings();
}
public RabbitMqConsumerPipeSpecification(IPipe <ReceiveContext> receivePipe, ReceiveSettings settings, IReceiveObserver receiveObserver,
IReceiveEndpointObserver endpointObserver, IEnumerable <ExchangeBindingSettings> exchangeBindings, ITaskSupervisor supervisor,
Mediator <ISetPrefetchCount> mediator)
{
_settings = settings;
_receiveObserver = receiveObserver;
_endpointObserver = endpointObserver;
_supervisor = supervisor;
_exchangeBindings = exchangeBindings.ToArray();
_receivePipe = receivePipe;
_mediator = mediator;
_modelSettings = new RabbitMqModelSettings();
}
/// <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);
}
/// <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();
}
/// <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="supervisor"></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 supervisor, Mediator <ISetPrefetchCount> mediator)
{
if (configurator == null)
{
throw new ArgumentNullException(nameof(configurator));
}
var pipeBuilderConfigurator = new RabbitMqConsumerPipeSpecification(pipe, settings, receiveObserver, endpointObserver, exchangeBindings,
supervisor, mediator);
configurator.AddPipeSpecification(pipeBuilderConfigurator);
}
/// <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 HttpConsumerPipeSpecification(HttpHostSettings hostSettings,
ReceiveSettings receiveSettings,
IPipe <ReceiveContext> receivePipe,
IReceiveObserver receiveObserver,
IReceiveTransportObserver transportObserver,
ITaskSupervisor supervisor, IHttpReceiveEndpointTopology topology)
{
_hostSettings = hostSettings;
_receiveSettings = receiveSettings;
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_topology = topology;
}
public RabbitMqConsumerPipeSpecification(IPipe <ReceiveContext> receivePipe, ReceiveSettings settings, IReceiveObserver receiveObserver,
IReceiveTransportObserver transportObserver, IEnumerable <ExchangeBindingSettings> exchangeBindings, ITaskSupervisor supervisor,
IManagementPipe managementPipe, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider, IRabbitMqHost host)
{
_settings = settings;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_exchangeBindings = exchangeBindings.Distinct().ToArray();
_receivePipe = receivePipe;
_managementPipe = managementPipe;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_host = host;
}
public HttpConsumerFilter(IPipe <ReceiveContext> receivePipe,
IReceiveObserver receiveObserver,
IReceiveTransportObserver transportObserver,
ITaskSupervisor supervisor,
HttpHostSettings hostSettings,
ReceiveSettings receiveSettings,
ISendPipe sendPipe)
{
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_hostSettings = hostSettings;
_receiveSettings = receiveSettings;
_sendPipe = sendPipe;
}
public Receiver(NamespaceContext context, ClientContext clientContext, IPipe <ReceiveContext> receivePipe, ClientSettings clientSettings,
ITaskSupervisor supervisor, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_context = context;
_clientContext = clientContext;
_receivePipe = receivePipe;
_clientSettings = clientSettings;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_tracker = new DeliveryTracker(DeliveryComplete);
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {clientContext.InputAddress}", Stop);
var options = new OnMessageOptions
{
AutoComplete = false,
AutoRenewTimeout = clientSettings.AutoRenewTimeout,
MaxConcurrentCalls = clientSettings.MaxConcurrentCalls
};
options.ExceptionReceived += (sender, x) =>
{
if (!(x.Exception is OperationCanceledException))
{
if (_log.IsErrorEnabled)
{
_log.Error($"Exception received on receiver: {clientContext.InputAddress} during {x.Action}", x.Exception);
}
}
if (_tracker.ActiveDeliveryCount == 0)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receiver shutdown completed: {0}", clientContext.InputAddress);
}
_participant.SetComplete();
}
};
clientContext.OnMessageAsync(OnMessage, options);
_participant.SetReady();
}
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();
}
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 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(NamespaceContext context, ClientContext clientContext, IPipe<ReceiveContext> receivePipe, ClientSettings clientSettings,
ITaskSupervisor supervisor, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_context = context;
_clientContext = clientContext;
_receivePipe = receivePipe;
_clientSettings = clientSettings;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_tracker = new DeliveryTracker(DeliveryComplete);
_participant = supervisor.CreateParticipant($"{TypeMetadataCache<Receiver>.ShortName} - {clientContext.InputAddress}", Stop);
var options = new OnMessageOptions
{
AutoComplete = false,
AutoRenewTimeout = clientSettings.AutoRenewTimeout,
MaxConcurrentCalls = clientSettings.MaxConcurrentCalls
};
options.ExceptionReceived += (sender, x) =>
{
if (!(x.Exception is OperationCanceledException))
{
if (_log.IsErrorEnabled)
_log.Error($"Exception received on receiver: {clientContext.InputAddress} during {x.Action}", x.Exception);
}
if (_tracker.ActiveDeliveryCount == 0)
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Receiver shutdown completed: {0}", clientContext.InputAddress);
_participant.SetComplete();
}
};
clientContext.OnMessageAsync(OnMessage, options);
_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 static ITaskParticipant CreateParticipant(this ITaskSupervisor supervisor, string tag, Func <Task> onStopMethod)
{
var participant = supervisor.CreateParticipant(tag);
participant.StopRequested.ContinueWith(async stopTask =>
{
try
{
await onStopMethod().ConfigureAwait(false);
}
catch (Exception ex)
{
_log.Error($"Failed to close scope {tag}", ex);
}
finally
{
participant.SetComplete();
}
}, TaskScheduler.Default);
return(participant);
}
public HttpOwinHostContext(HttpHostSettings settings, ITaskSupervisor supervisor)
: this(settings, supervisor.CreateParticipant($"{TypeMetadataCache<HttpOwinHostContext>.ShortName} - {settings.ToDebugString()}"))
{
}
public MessageSessionAsyncHandlerFactory(ITaskSupervisor supervisor, ISessionReceiver receiver)
{
_supervisor = supervisor;
_receiver = receiver;
}
public RabbitMqConnectionContext(IConnection connection, RabbitMqHostSettings hostSettings, ITaskSupervisor supervisor)
: this(connection, hostSettings,
supervisor.CreateParticipant($"{TypeMetadataCache<RabbitMqConnectionContext>.ShortName} - {hostSettings.ToDebugString()}"))
{
}
public OwinHostCache(HttpHostSettings settings, ITaskSupervisor supervisor)
{
_settings = settings;
_cacheTaskScope = supervisor.CreateScope($"{TypeMetadataCache<OwinHostCache>.ShortName} - {settings.ToDebugString()}", CloseScope);
}
public HttpClientCache(ITaskSupervisor supervisor, IReceivePipe receivePipe)
{
_receivePipe = receivePipe;
_cacheTaskScope = supervisor.CreateScope($"{TypeMetadataCache<HttpClientCache>.ShortName}", CloseScope);
}
public RabbitMqConnectionContext(IConnection connection, RabbitMqHostSettings hostSettings, ITaskSupervisor supervisor)
: this(connection, hostSettings,
supervisor.CreateParticipant($"{TypeMetadataCache<RabbitMqConnectionContext>.ShortName} - {hostSettings.ToDebugString()}"))
{
}
public MessageSessionAsyncHandlerFactory(ConnectionContext context, ITaskSupervisor supervisor, ISessionReceiver receiver)
{
_context = context;
_supervisor = supervisor;
_receiver = receiver;
}
