public MessageSessionAsyncHandlerFactory(ClientContext context, IReceiver receiver, IDeliveryTracker tracker, IBrokeredMessageReceiver messageReceiver) { _context = context; _receiver = receiver; _tracker = tracker; _messageReceiver = messageReceiver; }
/// <summary> /// The basic consumer receives messages pushed from the broker. /// </summary> /// <param name="session">The model context for the consumer</param> /// <param name="messageConsumer"></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="context">The topology</param> /// <param name="deadLetterTransport"></param> /// <param name="errorTransport"></param> public ActiveMqBasicConsumer(SessionContext session, IMessageConsumer messageConsumer, Uri inputAddress, IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, ActiveMqReceiveEndpointContext context, IDeadLetterTransport deadLetterTransport, IErrorTransport errorTransport) { _session = session; _messageConsumer = messageConsumer; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveObserver = receiveObserver; _context = context; _deadLetterTransport = deadLetterTransport; _errorTransport = errorTransport; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = session.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <string, ActiveMqReceiveContext>(); _deliveryComplete = new TaskCompletionSource <bool>(); messageConsumer.Listener += HandleMessage; SetReady(); }
public InMemoryReceiveTransport(Uri inputAddress, IInMemoryQueue queue, ReceiveEndpointContext context) { _inputAddress = inputAddress; _queue = queue; _context = context; _tracker = new DeliveryTracker(HandleDeliveryComplete); }
public Receiver(ClientContext context, IBrokeredMessageReceiver messageReceiver) { _context = context; _messageReceiver = messageReceiver; _tracker = new DeliveryTracker(HandleDeliveryComplete); _deliveryComplete = new TaskCompletionSource <bool>(); }
public MessageSessionAsyncHandlerFactory(NamespaceContext context, ITaskSupervisor supervisor, ISessionReceiver receiver, IDeliveryTracker tracker, IReceiveEndpointTopology topology) { _context = context; _supervisor = supervisor; _receiver = receiver; _tracker = tracker; _topology = topology; }
public Receiver(ClientContext context, IBrokeredMessageReceiver messageReceiver) { _context = context; _messageReceiver = messageReceiver; Tracker = new DeliveryTracker(HandleDeliveryComplete); _deliveryComplete = TaskUtil.GetTask <bool>(); }
public HttpConsumer(HttpReceiveEndpointContext context) { _context = context; _tracker = new DeliveryTracker(OnDeliveryComplete); _deliveryComplete = TaskUtil.GetTask <bool>(); SetReady(); }
public HttpConsumer(HttpHostSettings settings, HttpReceiveEndpointContext context) { _context = context; _tracker = new DeliveryTracker(OnDeliveryComplete); _inputAddress = context.InputAddress; _deliveryComplete = new TaskCompletionSource <bool>(); SetReady(); }
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 Receiver(ClientContext context, IBrokeredMessageReceiver messageReceiver, IDeadLetterTransport deadLetterTransport, IErrorTransport errorTransport) { _context = context; _messageReceiver = messageReceiver; _deadLetterTransport = deadLetterTransport; _errorTransport = errorTransport; _tracker = new DeliveryTracker(HandleDeliveryComplete); _deliveryComplete = new TaskCompletionSource <bool>(); }
public HttpConsumer(IReceiveObserver receiveObserver, HttpHostSettings settings, IPipe <ReceiveContext> receivePipe, HttpReceiveEndpointContext context) { _receiveObserver = receiveObserver; _receivePipe = receivePipe; _context = context; _tracker = new DeliveryTracker(OnDeliveryComplete); _inputAddress = settings.GetInputAddress(); _deliveryComplete = new TaskCompletionSource <bool>(); SetReady(); }
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); }
/// <summary> /// The basic consumer receives messages pushed from the broker. /// </summary> /// <param name="model">The model context for the consumer</param> /// <param name="context">The topology</param> public RabbitMqBasicConsumer(ModelContext model, RabbitMqReceiveEndpointContext context) { _model = model; _context = context; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = model.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <ulong, RabbitMqReceiveContext>(); _deliveryComplete = TaskUtil.GetTask <bool>(); }
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); }
/// <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="receiveEndpointContext">The topology</param> public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, RabbitMqReceiveEndpointContext receiveEndpointContext) { _model = model; _inputAddress = inputAddress; _receiveEndpointContext = receiveEndpointContext; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = model.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <ulong, RabbitMqReceiveContext>(); _deliveryComplete = new TaskCompletionSource <bool>(); }
public HttpConsumerAction(IReceiveObserver receiveObserver, HttpHostSettings settings, IPipe <ReceiveContext> receivePipe, ITaskScope taskSupervisor, IHttpReceiveEndpointTopology topology) { _receiveObserver = receiveObserver; _receivePipe = receivePipe; _topology = topology; _tracker = new DeliveryTracker(OnDeliveryComplete); _inputAddress = settings.GetInputAddress(); _participant = taskSupervisor.CreateParticipant($"{TypeMetadataCache<HttpConsumerAction>.ShortName} - {_inputAddress}", Stop); _deliveryComplete = new TaskCompletionSource <bool>(); _participant.SetReady(); }
public InMemoryReceiveTransport(Uri inputAddress, IInMemoryQueue queue, IReceiveEndpointTopology topology) { _inputAddress = inputAddress; _queue = queue; _topology = topology; _receiveObservable = new ReceiveObservable(); _transportObservable = new ReceiveTransportObservable(); _tracker = new DeliveryTracker(HandleDeliveryComplete); _supervisor = new TaskSupervisor($"{TypeMetadataCache<InMemoryReceiveTransport>.ShortName} - {_inputAddress}"); _participant = _supervisor.CreateParticipant($"{TypeMetadataCache<InMemoryReceiveTransport>.ShortName} - {_inputAddress}"); }
public InMemoryReceiveTransport(Uri inputAddress, IInMemoryQueue queue, IPipe <ReceiveContext> receivePipe, IInMemoryExchange errorExchange, IInMemoryExchange deadLetterExchange, ReceiveEndpointContext topology) { _inputAddress = inputAddress; _queue = queue; _topology = topology; _receivePipe = receivePipe; _errorTransport = new InMemoryMessageErrorTransport(errorExchange); _deadLetterTransport = new InMemoryMessageDeadLetterTransport(deadLetterExchange); _receiveObservable = new ReceiveObservable(); _transportObservable = new ReceiveTransportObservable(); _tracker = new DeliveryTracker(HandleDeliveryComplete); }
/// <summary> /// The basic consumer receives messages pushed from the broker. /// </summary> /// <param name="client">The model context for the consumer</param> /// <param name="inputAddress">The input address for messages received by the consumer</param> /// <param name="context">The topology</param> public AmazonSqsBasicConsumer(ClientContext client, Uri inputAddress, SqsReceiveEndpointContext context) { _client = client; _inputAddress = inputAddress; _context = context; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = client.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <string, AmazonSqsReceiveContext>(); _deliveryComplete = TaskUtil.GetTask <bool>(); 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(); }
/// <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> /// <param name="topology">The topology</param> public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, ITaskScope taskSupervisor, IReceiveEndpointTopology topology) { _model = model; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveObserver = receiveObserver; _topology = topology; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = model.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <ulong, RabbitMqReceiveContext>(); _participant = taskSupervisor.CreateParticipant($"{TypeMetadataCache<RabbitMqBasicConsumer>.ShortName} - {inputAddress}", Stop); _deliveryComplete = new TaskCompletionSource <bool>(); }
/// <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> /// <param name="sendEndpointProvider"></param> /// <param name="publishEndpointProvider"></param> public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe<ReceiveContext> receivePipe, IReceiveObserver receiveObserver, ITaskScope taskSupervisor, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider) { _model = model; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveObserver = receiveObserver; _sendEndpointProvider = sendEndpointProvider; _publishEndpointProvider = publishEndpointProvider; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = model.GetPayload<ReceiveSettings>(); _pending = new ConcurrentDictionary<ulong, RabbitMqReceiveContext>(); _participant = taskSupervisor.CreateParticipant($"{TypeMetadataCache<RabbitMqBasicConsumer>.ShortName} - {inputAddress}", Stop); _deliveryComplete = new TaskCompletionSource<bool>(); }
public InMemoryTransport(Uri inputAddress, int concurrencyLimit, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider) { _inputAddress = inputAddress; _sendEndpointProvider = sendEndpointProvider; _publishEndpointProvider = publishEndpointProvider; _sendObservable = new SendObservable(); _receiveObservable = new ReceiveObservable(); _transportObservable = new ReceiveTransportObservable(); _tracker = new DeliveryTracker(HandleDeliveryComplete); _supervisor = new TaskSupervisor($"{TypeMetadataCache<InMemoryTransport>.ShortName} - {_inputAddress}"); _participant = _supervisor.CreateParticipant($"{TypeMetadataCache<InMemoryTransport>.ShortName} - {_inputAddress}"); _scheduler = new LimitedConcurrencyLevelTaskScheduler(concurrencyLimit); }
/// <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="receiveEndpointContext">The topology</param> /// <param name="deadLetterTransport"></param> /// <param name="errorTransport"></param> public RabbitMqBasicConsumer(ModelContext model, Uri inputAddress, IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, RabbitMqReceiveEndpointContext receiveEndpointContext, IDeadLetterTransport deadLetterTransport, IErrorTransport errorTransport) { _model = model; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveObserver = receiveObserver; _receiveEndpointContext = receiveEndpointContext; _deadLetterTransport = deadLetterTransport; _errorTransport = errorTransport; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = model.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <ulong, RabbitMqReceiveContext>(); _deliveryComplete = new TaskCompletionSource <bool>(); }
/// <summary> /// The basic consumer receives messages pushed from the broker. /// </summary> /// <param name="session">The model context for the consumer</param> /// <param name="messageConsumer"></param> /// <param name="inputAddress">The input address for messages received by the consumer</param> /// <param name="context">The topology</param> public ActiveMqBasicConsumer(SessionContext session, IMessageConsumer messageConsumer, Uri inputAddress, ActiveMqReceiveEndpointContext context) { _session = session; _messageConsumer = messageConsumer; _inputAddress = inputAddress; _context = context; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = session.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <string, ActiveMqReceiveContext>(); _deliveryComplete = TaskUtil.GetTask <bool>(); messageConsumer.Listener += HandleMessage; SetReady(); }
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(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(); }
/// <summary> /// The basic consumer receives messages pushed from the broker. /// </summary> /// <param name="model">The model context for the consumer</param> /// <param name="queueUrl"></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="context">The topology</param> /// <param name="deadLetterTransport"></param> /// <param name="errorTransport"></param> public AmazonSqsBasicConsumer(ModelContext model, string queueUrl, Uri inputAddress, IPipe <ReceiveContext> receivePipe, IReceiveObserver receiveObserver, AmazonSqsReceiveEndpointContext context, IDeadLetterTransport deadLetterTransport, IErrorTransport errorTransport) { _model = model; _queueUrl = queueUrl; _inputAddress = inputAddress; _receivePipe = receivePipe; _receiveObserver = receiveObserver; _context = context; _deadLetterTransport = deadLetterTransport; _errorTransport = errorTransport; _tracker = new DeliveryTracker(HandleDeliveryComplete); _receiveSettings = model.GetPayload <ReceiveSettings>(); _pending = new ConcurrentDictionary <string, AmazonSqsReceiveContext>(); _deliveryComplete = new TaskCompletionSource <bool>(); SetReady(); }