public HttpSendTransportProvider(BusHostCollection <HttpHost> hosts, IReceivePipe receivePipe, IReceiveObserver receiveObserver, IReceiveEndpointTopology topology)
{
_hosts = hosts;
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_topology = topology;
}
public HttpSendTransport(ClientCache clientCache, HttpSendSettings sendSettings, IReceiveObserver receiveObserver, IReceiveEndpointTopology topology)
{
_clientCache = clientCache;
_sendSettings = sendSettings;
_receiveObserver = receiveObserver;
_topology = topology;
_observers = new SendObservable();
}
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, IReceiveTransportObserver transportObserver, ITaskSupervisor supervisor, IReceiveEndpointTopology topology)
{
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_transportObserver = transportObserver;
_supervisor = supervisor;
_topology = topology;
}
public HttpClientReceiveContext(HttpResponseMessage responseMessage, Stream responseStream, bool redelivered, IReceiveObserver receiveObserver,
IReceiveEndpointTopology topology)
: base(responseMessage.RequestMessage.RequestUri, redelivered, receiveObserver, topology)
{
_responseMessage = responseMessage;
_responseStream = responseStream;
HeaderProvider = new HttpClientHeaderProvider(responseMessage.Headers);
}
public HttpResponseReceiveEndpointTopology(IReceiveEndpointTopology topology, IOwinContext owinContext, ISendPipe sendPipe,
IMessageSerializer serializer)
{
_topology = topology;
_owinContext = owinContext;
_sendPipe = sendPipe;
_serializer = serializer;
_sendEndpointProvider = new Lazy <ISendEndpointProvider>(CreateSendEndpointProvider);
}
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 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}");
}
protected BaseReceiveContext(Uri inputAddress, bool redelivered, IReceiveObserver receiveObserver, CancellationTokenSource source, IReceiveEndpointTopology topology)
: base(new PayloadCache(), source.Token)
{
_receiveTimer = Stopwatch.StartNew();
_cancellationTokenSource = source;
Topology = topology;
InputAddress = inputAddress;
Redelivered = redelivered;
_receiveObserver = receiveObserver;
_headers = new Lazy <Headers>(() => new JsonHeaders(ObjectTypeDeserializer.Instance, HeaderProvider));
_contentType = new Lazy <ContentType>(GetContentType);
_pendingTasks = new List <Task>(4);
}
/// <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>();
}
public Receiver(NamespaceContext context, ClientContext clientContext, IPipe <ReceiveContext> receivePipe, ClientSettings clientSettings,
ITaskSupervisor supervisor, IReceiveEndpointTopology topology)
{
_context = context;
_clientContext = clientContext;
_receivePipe = receivePipe;
_clientSettings = clientSettings;
_topology = topology;
_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 IReceiveTransport GetReceiveTransport(string queueName, IReceiveEndpointTopology topology)
{
if (_sendEndpointProvider == null)
{
_sendEndpointProvider = topology.SendEndpointProvider;
}
if (_publishEndpointProvider == null)
{
_publishEndpointProvider = topology.PublishEndpointProvider;
}
if (_topology == null)
{
_topology = topology;
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Creating receive transport for queue: {0}", queueName);
}
var queue = _messageFabric.GetQueue(queueName);
return(new InMemoryReceiveTransport(new Uri(_baseUri, queueName), queue, topology));
}
public RabbitMqReceiveContext(Uri inputAddress, string exchange, string routingKey, string consumerTag, ulong deliveryTag, byte[] body, bool redelivered,
IBasicProperties properties, IReceiveObserver observer, IReceiveEndpointTopology topology)
: base(inputAddress, redelivered, observer, topology)
{
Exchange = exchange;
RoutingKey = routingKey;
ConsumerTag = consumerTag;
DeliveryTag = deliveryTag;
_body = body;
Properties = properties;
((ReceiveContext)this).GetOrAddPayload <RabbitMqBasicConsumeContext>(() => this);
}
public InMemoryReceiveContext(Uri inputAddress, InMemoryTransportMessage message, IReceiveObserver observer, IReceiveEndpointTopology topology)
: base(inputAddress, message.DeliveryCount > 0, observer, topology)
{
_body = message.Body;
_message = message;
GetOrAddPayload(() => this);
}
public ServiceBusReceiveContext(Uri inputAddress, BrokeredMessage message, IReceiveObserver observer, IReceiveEndpointTopology topology)
: base(inputAddress, message.DeliveryCount > 1, observer, topology)
{
_message = message;
GetOrAddPayload <BrokeredMessageContext>(() => this);
}
protected BaseReceiveContext(Uri inputAddress, bool redelivered, IReceiveObserver receiveObserver, IReceiveEndpointTopology topology)
: this(inputAddress, redelivered, receiveObserver, new CancellationTokenSource(), topology)
{
}
public HttpReceiveContext(IOwinContext requestContext, bool redelivered, IReceiveObserver receiveObserver, IReceiveEndpointTopology topology)
: base(requestContext.Request.Uri, redelivered, receiveObserver, topology)
{
_requestContext = requestContext;
HeaderProvider = new HttpHeaderProvider(requestContext.Request.Headers);
}
public MessageSessionReceiverFilter(IPipe <ReceiveContext> receivePipe, IReceiveEndpointTopology topology)
{
_receivePipe = receivePipe;
_topology = topology;
}