public EventDataReceiveContext(Uri inputAddress, EventData eventData, ReceiveEndpointContext receiveEndpointContext)
: base(inputAddress, false, receiveEndpointContext)
{
_eventData = eventData;
GetOrAddPayload <EventDataContext>(() => this);
}
public KafkaMessageReceiver(ReceiveEndpointContext context, IConsumerLockContext <TKey, TValue> lockContext, IHeadersDeserializer headersDeserializer)
{
_context = context;
_lockContext = lockContext;
_headersDeserializer = headersDeserializer;
_dispatcher = context.CreateReceivePipeDispatcher();
}
public HttpSendTransport(IClientContextSupervisor clientContextSupervisor, HttpSendSettings sendSettings, ReceiveEndpointContext topology)
{
_clientContextSupervisor = clientContextSupervisor;
_sendSettings = sendSettings;
_topology = topology;
_observers = new SendObservable();
}
public EventDataReceiver(Uri inputAddress, IReceivePipe receivePipe, ILog log, ReceiveEndpointContext receiveTopology)
{
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_receiveTopology = receiveTopology;
_receiveObservers = new ReceiveObservable();
}
public HttpReceiveContext(HttpContext httpContext, bool redelivered, ReceiveEndpointContext topology)
: base(new Uri(httpContext.Request.GetDisplayUrl()), redelivered, topology)
{
_httpContext = httpContext;
HeaderProvider = new HttpHeaderProvider(httpContext.Request.Headers);
}
public ReceiveEndpoint(IReceiveTransport receiveTransport, ReceiveEndpointContext context)
{
_context = context;
_receiveTransport = receiveTransport;
_handle = receiveTransport.ConnectReceiveTransportObserver(new Observer(this, context.EndpointObservers));
}
public EventDataReceiveContext(ProcessEventArgs eventArgs, ReceiveEndpointContext receiveEndpointContext, IProcessorLockContext lockContext)
: base(false, receiveEndpointContext)
{
_eventArgs = eventArgs;
_eventData = eventArgs.Data;
_lockContext = lockContext;
}
public HttpResponseReceiveEndpointContext(ReceiveEndpointContext receiveEndpointContext, HttpContext httpContext)
{
_receiveEndpointContext = receiveEndpointContext;
_httpContext = httpContext;
_sendEndpointProvider = new Lazy <ISendEndpointProvider>(CreateSendEndpointProvider);
}
public HttpResponseSendEndpointProvider(HttpContext httpContext, ReceiveEndpointContext receiveEndpointContext)
{
_receiveEndpointContext = receiveEndpointContext;
_httpContext = httpContext;
_observers = new SendObservable();
}
public ServiceBusReceiveContext(Uri inputAddress, Message message, ReceiveEndpointContext receiveEndpointContext)
: base(inputAddress, message.SystemProperties.DeliveryCount > 1, receiveEndpointContext)
{
_message = message;
GetOrAddPayload <BrokeredMessageContext>(() => this);
}
public BrokeredMessageReceiver(Uri inputAddress, IReceivePipe receivePipe, ILog log, ReceiveEndpointContext receiveTopology)
{
_inputAddress = inputAddress;
_receivePipe = receivePipe;
_log = log;
_receiveTopology = receiveTopology;
_receiveObservers = new ReceiveObservable();
}
public ReceiveTransport(IHostConfiguration hostConfiguration, ReceiveEndpointContext context, Func <ISupervisor <TContext> > supervisorFactory,
IPipe <TContext> transportPipe)
{
_hostConfiguration = hostConfiguration;
_context = context;
_supervisorFactory = supervisorFactory;
_transportPipe = transportPipe;
}
public ReceiveEndpointDispatcherReceiveContext(ReceiveEndpointContext receiveEndpointContext, byte[] body, IReadOnlyDictionary <string, object> headers,
params object[] payloads)
: base(IsRedelivered(headers), receiveEndpointContext, payloads)
{
_body = body;
HeaderProvider = new ReadOnlyDictionaryHeaderProvider(headers);
}
public InMemoryReceiveTransport(Uri inputAddress, IInMemoryQueue queue, ReceiveEndpointContext context)
{
_inputAddress = inputAddress;
_queue = queue;
_context = context;
_tracker = new DeliveryTracker(HandleDeliveryComplete);
}
public HttpSendTransport(IClientCache clientCache, HttpSendSettings sendSettings, IReceiveObserver receiveObserver, ReceiveEndpointContext topology)
{
_clientCache = clientCache;
_sendSettings = sendSettings;
_receiveObserver = receiveObserver;
_topology = topology;
_observers = new SendObservable();
}
public InMemoryReceiveTransport(Uri inputAddress, IInMemoryQueue queue, ReceiveEndpointContext context)
{
_inputAddress = inputAddress;
_queue = queue;
_context = context;
_dispatcher = context.CreateReceivePipeDispatcher();
}
public HttpSendTransportProvider(IHttpBusConfiguration busConfiguration, IReceivePipe receivePipe, IReceiveObserver receiveObserver,
ReceiveEndpointContext topology)
{
_busConfiguration = busConfiguration;
_receivePipe = receivePipe;
_receiveObserver = receiveObserver;
_topology = topology;
}
public ReceiveEndpoint(IReceiveTransport receiveTransport, ReceiveEndpointContext context)
{
_context = context;
_receiveTransport = receiveTransport;
_started = TaskUtil.GetTask <ReceiveEndpointReady>();
_handle = receiveTransport.ConnectReceiveTransportObserver(new Observer(this, context.EndpointObservers));
}
public override IReceiveEndpoint CreateReceiveEndpoint(string endpointName, IReceiveTransport receiveTransport, IReceivePipe receivePipe,
ReceiveEndpointContext topology)
{
var receiveEndpoint = new ReceiveEndpoint(receiveTransport, receivePipe, topology);
_hostConfiguration.Host.AddReceiveEndpoint(endpointName, receiveEndpoint);
return(receiveEndpoint);
}
public HttpClientReceiveContext(HttpResponseMessage responseMessage, Stream responseStream, bool redelivered, IReceiveObserver receiveObserver,
ReceiveEndpointContext topology)
: base(responseMessage.RequestMessage.RequestUri, redelivered, receiveObserver, topology)
{
_responseMessage = responseMessage;
_responseStream = responseStream;
HeaderProvider = new HttpClientHeaderProvider(responseMessage.Headers);
}
protected virtual IReceiveEndpoint CreateReceiveEndpoint(string endpointName, IReceiveTransport receiveTransport,
ReceiveEndpointContext receiveEndpointContext)
{
var receiveEndpoint = new ReceiveEndpoint(receiveTransport, receiveEndpointContext);
_hostConfiguration.Host.AddReceiveEndpoint(endpointName, receiveEndpoint);
return(receiveEndpoint);
}
public HttpResponseReceiveEndpointContext(ReceiveEndpointContext receiveEndpointContext, HttpContext httpContext, ISendPipe sendPipe,
IMessageSerializer serializer)
{
_receiveEndpointContext = receiveEndpointContext;
_httpContext = httpContext;
_sendPipe = sendPipe;
_serializer = serializer;
_sendEndpointProvider = new Lazy <ISendEndpointProvider>(CreateSendEndpointProvider);
}
public KafkaReceiveEndpoint(string topic, int prefetch, int concurrencyLimit, IConsumer <TKey, TValue> consumer,
IKafkaMessageReceiver <TKey, TValue> transport, ReceiveEndpointContext context)
{
_topic = topic;
_consumer = consumer;
_transport = transport;
_context = context;
_started = TaskUtil.GetTask <ReceiveEndpointReady>();
_executor = new ChannelExecutor(prefetch, concurrencyLimit);
}
public EventHubReceiveEndpoint(EventProcessorClient processor, int prefetch, int concurrencyLimit, BlobContainerClient blobContainerClient,
IEventHubDataReceiver transport, ReceiveEndpointContext context)
{
_processor = processor;
_blobContainerClient = blobContainerClient;
_transport = transport;
_context = context;
_started = TaskUtil.GetTask <ReceiveEndpointReady>();
_executor = new ChannelExecutor(prefetch, concurrencyLimit);
}
public KafkaReceiveContext(ConsumeResult <TKey, TValue> result, ReceiveEndpointContext receiveEndpointContext,
IConsumerLockContext <TKey, TValue> lockContext, IHeadersDeserializer headersDeserializer)
: base(false, receiveEndpointContext)
{
_result = result;
_lockContext = lockContext;
_headersDeserializer = headersDeserializer;
var consumeContext = new KafkaConsumeContext <TKey, TValue>(this, _result);
AddOrUpdatePayload <ConsumeContext>(() => consumeContext, existing => consumeContext);
}
public Task <ISendTransport> CreateSendTransport(Uri address, ReceiveEndpointContext receiveEndpointContext)
{
var clientContextSupervisor = new HttpClientContextSupervisor(receiveEndpointContext.ReceivePipe);
var sendSettings = address.GetSendSettings();
var transport = new HttpSendTransport(clientContextSupervisor, sendSettings, receiveEndpointContext);
_host.Add(transport);
return(Task.FromResult <ISendTransport>(transport));
}
public static async Task OnTransportStartup <T>(this ReceiveEndpointContext context, ISupervisor <T> supervisor, CancellationToken cancellationToken)
where T : class, PipeContext
{
// Nothing connected to the pipe, so signal early we are available
if (!context.ReceivePipe.Connected.IsCompleted)
{
var pipe = new WaitForConnectionPipe <T>(context, cancellationToken);
await supervisor.Send(pipe, cancellationToken).ConfigureAwait(false);
}
await context.Dependencies.OrCanceled(cancellationToken).ConfigureAwait(false);
}
public ReceiveEndpoint(IReceiveTransport transport, ReceiveEndpointContext context)
{
_context = context;
_transport = transport;
_started = Util.TaskUtil.GetTask <ReceiveEndpointReady>();
_startObserver = new StartObserver();
ConnectReceiveEndpointObserver(_startObserver);
transport.ConnectReceiveTransportObserver(new Observer(this, context.EndpointObservers));
}
public EventHubDataReceiver(ReceiveEndpointContext context, ProcessorContext processorContext)
{
_context = context;
_processorContext = processorContext;
_deliveryComplete = TaskUtil.GetTask <bool>();
_dispatcher = context.CreateReceivePipeDispatcher();
_dispatcher.ZeroActivity += HandleDeliveryComplete;
var prefetchCount = Math.Max(1000, processorContext.ReceiveSettings.CheckpointMessageCount / 10);
_executor = new ChannelExecutor(prefetchCount, processorContext.ReceiveSettings.ConcurrencyLimit);
}
public ReceiveTransportAgent(IRetryPolicy retryPolicy, ReceiveEndpointContext context, Func <ISupervisor <TContext> > supervisorFactory,
IPipe <TContext> transportPipe)
{
_retryPolicy = retryPolicy;
_context = context;
_supervisorFactory = supervisorFactory;
_transportPipe = transportPipe;
var receiver = Task.Run(Run);
SetReady(receiver);
SetCompleted(receiver);
}