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 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 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();
}
