public BinaryMessageDeserializer(JsonSerializer deserializer, ISendEndpointProvider sendEndpointProvider,
IPublishEndpointProvider publishEndpoint)
{
_deserializer = deserializer;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpoint = publishEndpoint;
}
public InMemoryPublishEndpointProvider(ISendEndpointProvider sendEndpointProvider, ISendTransportProvider transportProvider, IPublishPipe publishPipe)
{
_sendEndpointProvider = sendEndpointProvider;
_publishPipe = publishPipe;
_transportCache = transportProvider as InMemoryTransportCache;
_publishObservable = new PublishObservable();
}
public ServiceBusPublishEndpointProvider(IServiceBusHost host, ISendEndpointProvider sendEndpointProvider)
{
_host = host;
_sendEndpointProvider = sendEndpointProvider;
_nameFormatter = host.MessageNameFormatter;
_publishObservable = new PublishObservable();
}
public ServiceBusReceiveContext(Uri inputAddress, BrokeredMessage message, IReceiveObserver observer, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: base(inputAddress, message.DeliveryCount > 1, observer, sendEndpointProvider, publishEndpointProvider)
{
_message = message;
GetOrAddPayload<BrokeredMessageContext>(() => this);
}
public JsonMessageDeserializer(JsonSerializer deserializer, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_deserializer = deserializer;
_objectTypeDeserializer = new ObjectTypeDeserializer(_deserializer);
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
}
public EncryptedMessageDeserializer(JsonSerializer deserializer, ISendEndpointProvider sendEndpointProvider,
IPublishEndpointProvider publishEndpoint, ICryptoStreamProvider provider)
{
_deserializer = deserializer;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpoint = publishEndpoint;
_provider = provider;
}
public HttpReceiveContext(IOwinContext requestContext, bool redelivered, IReceiveObserver receiveObserver,
ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: base(requestContext.Request.Uri, redelivered, receiveObserver, sendEndpointProvider, publishEndpointProvider)
{
_requestContext = requestContext;
HeaderProvider = new HttpHeaderProvider(requestContext.Request.Headers);
}
public InMemoryReceiveContext(Uri inputAddress, InMemoryTransportMessage message, IReceiveObserver observer, ISendEndpointProvider sendEndpointProvider,
IPublishEndpointProvider publishEndpointProvider)
: base(inputAddress, message.DeliveryCount > 0, observer, sendEndpointProvider, publishEndpointProvider)
{
_body = message.Body;
_message = message;
GetOrAddPayload(() => this);
}
public HttpClientReceiveContext(HttpResponseMessage responseMessage, Stream responseStream, bool redelivered, IReceiveObserver receiveObserver,
ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: base(responseMessage.RequestMessage.RequestUri, redelivered, receiveObserver, sendEndpointProvider, publishEndpointProvider)
{
_responseMessage = responseMessage;
_responseStream = responseStream;
HeaderProvider = new HttpClientHeaderProvider(responseMessage.Headers);
}
/// <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 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 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 RabbitMqReceiveContext(Uri inputAddress, string exchange, string routingKey, string consumerTag, ulong deliveryTag, byte[] body, bool redelivered,
IBasicProperties properties, IReceiveObserver observer, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: base(inputAddress, redelivered, observer, sendEndpointProvider, publishEndpointProvider)
{
Exchange = exchange;
RoutingKey = routingKey;
ConsumerTag = consumerTag;
DeliveryTag = deliveryTag;
_body = body;
Properties = properties;
((ReceiveContext)this).GetOrAddPayload<RabbitMqBasicConsumeContext>(() => this);
}
public RabbitMqReceiveTransport(IRabbitMqHost host, ReceiveSettings settings, IManagementPipe managementPipe, ExchangeBindingSettings[] bindings, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_host = host;
_settings = settings;
_bindings = bindings;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_managementPipe = managementPipe;
_receiveObservable = new ReceiveObservable();
_receiveTransportObservable = new ReceiveTransportObservable();
_inputAddress = _settings.GetInputAddress(_host.Settings.HostAddress);
}
/// <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 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 void Apply(IBusBuilder builder)
{
var receiveEndpointBuilder = new HttpReceiveEndpointBuilder(_host, CreateConsumePipe(builder), builder);
var receivePipe = CreateReceivePipe(receiveEndpointBuilder);
_sendEndpointProvider = CreateSendEndpointProvider(receiveEndpointBuilder);
_publishEndpointProvider = CreatePublishEndpointProvider(receiveEndpointBuilder);
var sendPipe = builder.CreateSendPipe();
var receiveSettings = new Settings(_pathMatch, receiveEndpointBuilder.MessageSerializer, _sendEndpointProvider, _publishEndpointProvider);
var transport = new HttpReceiveTransport(_host, receiveSettings, sendPipe);
var httpHost = _host as HttpHost;
if (httpHost == null)
throw new ConfigurationException("Must be a HttpHost");
httpHost.ReceiveEndpoints.Add(NewId.Next().ToString(), new ReceiveEndpoint(transport, receivePipe));
}
public void Apply(IInMemoryBusBuilder builder)
{
var receiveEndpointBuilder = new InMemoryReceiveEndpointBuilder(CreateConsumePipe(builder), builder);
var receivePipe = CreateReceivePipe(receiveEndpointBuilder);
_sendEndpointProvider = CreateSendEndpointProvider(receiveEndpointBuilder);
_publishEndpointProvider = CreatePublishEndpointProvider(receiveEndpointBuilder);
var inMemoryBusBuilder = builder as InMemoryBusBuilder;
if (inMemoryBusBuilder == null)
throw new ArgumentException("The bus builder is expected to by an InMemoryBusBuilder", nameof(inMemoryBusBuilder));
var transport = inMemoryBusBuilder.InMemoryHost.GetReceiveTransport(_queueName, _transportConcurrencyLimit, _sendEndpointProvider,
_publishEndpointProvider);
var inMemoryHost = inMemoryBusBuilder.InMemoryHost as InMemoryHost;
if (inMemoryHost == null)
throw new ConfigurationException("Must be an InMemoryHost");
inMemoryHost.ReceiveEndpoints.Add(_queueName, new ReceiveEndpoint(transport, receivePipe));
}
/// <summary>
/// Creates a request client that uses the bus to retrieve the endpoint and send the request.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="host"></param>
/// <param name="sendEndpointProvider"></param>
/// <param name="address">The service address that handles the request</param>
/// <param name="timeout">The timeout before the request is cancelled</param>
/// <param name="ttl">THe time to live for the request message</param>
/// <param name="callback">Callback when the request is sent</param>
/// <returns></returns>
public static async Task <IRequestClient <TRequest, TResponse> > CreateRequestClient <TRequest, TResponse>(this IInMemoryHost host,
ISendEndpointProvider sendEndpointProvider, Uri address, TimeSpan timeout, TimeSpan?ttl = default(TimeSpan?),
Action <SendContext <TRequest> > callback = null)
where TRequest : class
where TResponse : class
{
var endpoint = host.ConnectReceiveEndpoint(NewId.NextGuid().ToString("N"));
var ready = await endpoint.Ready.ConfigureAwait(false);
return(new MessageRequestClient <TRequest, TResponse>(sendEndpointProvider, ready.ReceiveEndpoint, ready.InputAddress, address, timeout, ttl,
callback));
}
public SendEndpointCache(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
_cache = new LazyConcurrentDictionary<Uri, ISendEndpoint>(GetSendEndpointFromProvider, AddressEqualityComparer.Comparer);
}
public PaymentController(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
}
public JsonConsumeContext(JsonSerializer deserializer, IObjectTypeDeserializer objectTypeDeserializer, ISendEndpointProvider sendEndpointProvider,
IPublishEndpointProvider publishEndpointProvider, ReceiveContext receiveContext, MessageEnvelope envelope)
{
_receiveContext = receiveContext;
_envelope = envelope;
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
_deserializer = deserializer;
_objectTypeDeserializer = objectTypeDeserializer;
_messageToken = GetMessageToken(envelope.Message);
_supportedTypes = envelope.MessageType.ToArray();
_messageTypes = new Dictionary <Type, object>();
_publishEndpoint =
new Lazy <IPublishEndpoint>(() => _publishEndpointProvider.CreatePublishEndpoint(_receiveContext.InputAddress, CorrelationId, ConversationId));
}
public OrderController(IPublishEndpoint publishEndpoint, ISendEndpointProvider sendEndpointProvider, ILogger <OrderController> logger)
{
_publishEndpoint = publishEndpoint;
_sendEndpointProvider = sendEndpointProvider;
_logger = logger;
}
public RabbiqMqService(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
}
public ServiceClientRequestSendEndpoint(Task <IMessageClient <TMessage> > messageClient, ConsumeContext consumeContext)
{
_messageClient = messageClient;
_sendEndpointProvider = consumeContext;
_consumeContext = consumeContext;
}
private async Task <ISendEndpoint> GetSendEndpoint(ISendEndpointProvider sendEndpointProvider, string endpointName)
{
return(await sendEndpointProvider.GetSendEndpoint(new Uri($"queue:{endpointName}")));
}
public HomeController(MainDbContext dbContext, IPublishEndpoint publishEndpoint, ISendEndpointProvider sendEndpointProvider)
{
this.dbContext = dbContext;
this.publishEndpoint = publishEndpoint;
this.sendEndpointProvider = sendEndpointProvider;
}
public SmogInformationController(ILogger <SmogInformationController> logger, ISendEndpointProvider sendEndpointProvider, IMapper mapper)
{
_logger = logger;
_sendEndpointProvider = sendEndpointProvider;
_mapper = mapper;
}
public RabbitMqReceiveContext(Uri inputAddress, string exchange, string routingKey, string consumerTag, ulong deliveryTag, byte[] body, bool redelivered,
IBasicProperties properties, IReceiveObserver observer, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: base(inputAddress, redelivered, observer, sendEndpointProvider, publishEndpointProvider)
{
Exchange = exchange;
RoutingKey = routingKey;
ConsumerTag = consumerTag;
DeliveryTag = deliveryTag;
_body = body;
Properties = properties;
((ReceiveContext)this).GetOrAddPayload <RabbitMqBasicConsumeContext>(() => this);
}
public TicketsController(IPublishEndpoint publishEndpoint, ISendEndpointProvider sendEndpointProvider, IConfiguration configuration)
{
_publishEndpoint = publishEndpoint;
_sendEndpointProvider = sendEndpointProvider;
_configuration = configuration;
}
public OrderController(
ISendEndpointProvider sendEndpointProvider, IOrderDataAccess orderDataAccess)
{
_sendEndpointProvider = sendEndpointProvider;
_orderDataAccess = orderDataAccess;
}
public BooksRequestProducer(ISendEndpointProvider sendEndpointProvider, IConfiguration configuration)
{
_sendEndpointProvider = sendEndpointProvider;
_configuration = configuration;
}
public ProtocolBuffersMessageDeserializer(ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
_publishEndpointProvider = publishEndpointProvider;
}
protected BaseReceiveContext(Uri inputAddress, bool redelivered, IReceiveObserver receiveObserver, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: this(inputAddress, redelivered, receiveObserver, new CancellationTokenSource(), sendEndpointProvider, publishEndpointProvider)
{
}
public SendMassTransitMessage(ISendEndpointProvider sender, IWorkflowExpressionEvaluator evaluator)
{
this.sender = sender;
this.evaluator = evaluator;
}
public EndpointRecurringMessageScheduler(ISendEndpointProvider sendEndpointProvider, Uri schedulerAddress)
{
_schedulerEndpoint = new Lazy <Task <ISendEndpoint> >(() => sendEndpointProvider.GetSendEndpoint(schedulerAddress));
}
public ServiceClientRequestSendEndpoint(Task <IMessageClient <TMessage> > messageClient, ISendEndpointProvider sendEndpointProvider)
{
_messageClient = messageClient;
_sendEndpointProvider = sendEndpointProvider;
}
public PayloadSendEndpointProvider(ISendEndpointProvider provider, PayloadFactory <TPayload> payloadFactory)
{
_provider = provider;
_payloadFactory = payloadFactory;
}
public IMessageDeserializer GetMessageDeserializer(ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
{
IMessageDeserializer[] deserializers =
_deserializerFactories.Values.Select(x => x(sendEndpointProvider, publishEndpointProvider)).ToArray();
return new SupportedMessageDeserializers(deserializers);
}
public MassTransitCommandBus(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
}
public CommandBus(ISendEndpointProvider endpoint)
{
this.endpoint = endpoint;
}
IMessageDeserializer CreateDeserializer(ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpoint)
{
return new EncryptedMessageDeserializer(BsonMessageSerializer.Deserializer, sendEndpointProvider, publishEndpoint,
_streamProvider);
}
public DelayedMessageScheduleMessageProvider(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
}
public ServiceBusMessageScheduler(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
}
public SendRequestSendEndpoint(ISendEndpointProvider provider, Uri destinationAddress, ConsumeContext consumeContext)
{
_provider = provider;
_destinationAddress = destinationAddress;
_consumeContext = consumeContext;
}
public InMemoryPublishEndpointProvider(ISendEndpointProvider sendEndpointProvider, ISendTransportProvider transportProvider)
{
_sendEndpointProvider = sendEndpointProvider;
_transportCache = transportProvider as InMemoryTransportCache;
_publishObservable = new PublishObservable();
}
/// <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>();
}
/// <summary>
/// Creates a request client that uses the bus to retrieve the endpoint and send the request.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="connector"></param>
/// <param name="sendEndpointProvider"></param>
/// <param name="responseAddress"></param>
/// <param name="address">The service address that handles the request</param>
/// <param name="timeout">The timeout before the request is cancelled</param>
/// <param name="ttl">THe time to live for the request message</param>
/// <param name="callback">Callback when the request is sent</param>
/// <returns></returns>
public static IRequestClient <TRequest, TResponse> CreateRequestClient <TRequest, TResponse>(this IRequestPipeConnector connector,
ISendEndpointProvider sendEndpointProvider, Uri responseAddress, Uri address, TimeSpan timeout,
TimeSpan?ttl = default(TimeSpan?), Action <SendContext <TRequest> > callback = null)
where TRequest : class
where TResponse : class
{
return(new MessageRequestClient <TRequest, TResponse>(sendEndpointProvider, connector, responseAddress, address, timeout, ttl, callback));
}
public Settings(string pathMatch, IMessageSerializer messageSerializer, ISendEndpointProvider sendEndpointProvider,
IPublishEndpointProvider publishEndpointProvider)
{
PathMatch = pathMatch;
MessageSerializer = messageSerializer;
SendEndpointProvider = sendEndpointProvider;
PublishEndpointProvider = publishEndpointProvider;
}
protected BaseReceiveContext(Uri inputAddress, bool redelivered, IReceiveObserver receiveObserver, CancellationTokenSource source, ISendEndpointProvider sendEndpointProvider, IPublishEndpointProvider publishEndpointProvider)
: base(new PayloadCache(), source.Token)
{
_receiveTimer = Stopwatch.StartNew();
_cancellationTokenSource = source;
SendEndpointProvider = sendEndpointProvider;
PublishEndpointProvider = publishEndpointProvider;
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);
}
public SearchRequestEventPublisher(ISendEndpointProvider sendEndpointProvider, IOptions <RabbitMqConfiguration> rabbitMqOptions, ILogger <SearchRequestEventPublisher> logger)
{
_logger = logger;
_sendEndpointProvider = sendEndpointProvider;
_rabbitMqConfiguration = rabbitMqOptions.Value;
}
public BookResponseProducer(ISendEndpointProvider sendEndpointProvider, IConfiguration configuration)
{
_sendEndpointProvider = sendEndpointProvider;
_configuration = configuration;
}
public Test(IRequestClient <CreateEntityRequest> createClient, IRequestClient <GetEntityMetadataRequest> getMetadataClient, IEntityMetadataSerializer serializer, ISendEndpointProvider sendEndpointProvider, ILogger <Test> logger, IRequestClient <GetEntityTransformRequest> getTransformClient)
{
_createClient = createClient;
_getMetadataClient = getMetadataClient;
_serializer = serializer;
_sendEndpointProvider = sendEndpointProvider;
_logger = logger;
_getTransformClient = getTransformClient;
}
public SendEndpointCache(ISendEndpointProvider sendEndpointProvider)
{
_sendEndpointProvider = sendEndpointProvider;
_cache = new ConcurrentDictionary<Uri, Lazy<Task<ISendEndpoint>>>(AddressEqualityComparer.Comparer);
}
