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 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 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 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 MessageSessionAsyncHandlerFactory(ConnectionContext context, ITaskSupervisor supervisor, ISessionReceiver receiver) { _context = context; _supervisor = supervisor; _receiver = receiver; }