public async Task <HostReceiveEndpointHandle> ConnectReceiveEndpoint(string queueName, Action <IReceiveEndpointConfigurator> configure = null) { var handle = _host.ConnectReceiveEndpoint(queueName, configurator => configure?.Invoke(configurator)); ActiveReceiveEndpoints.Add(handle); return(handle); }
HostReceiveEndpointHandle IReceiveConnector <IRabbitMqReceiveEndpointConfigurator> .ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter, Action <IRabbitMqReceiveEndpointConfigurator> configureEndpoint) { if (_host == null) { throw new InvalidOperationException("The host is not ready."); } return(_host.ConnectReceiveEndpoint(definition, endpointNameFormatter, configureEndpoint)); }
static HostReceiveEndpointHandle ConnectResponseEndpoint(IRabbitMqHost host) { return(host.ConnectReceiveEndpoint(host.Topology.CreateTemporaryResponseQueueName(), x => { x.Durable = false; x.AutoDelete = true; })); }
public void AddUpdateConsumer(DocumentInfo i) { host.ConnectReceiveEndpoint(i.Type, e => { e.BindMessageExchanges = false; e.Consumer(() => new UpdateDocument(documentRepository)); //document is queue name e.Bind("updatedoc", s => { s.RoutingKey = i.Type; s.ExchangeType = ExchangeType.Direct; }); e.Durable = true; e.AutoDelete = true; }); }
public override async Task ConnectConsumerAsync(string queueName, ICommandService commandService, CancellationToken cancellationToken) { if (!(commandService is RabbitMqCommandService commandServiceCasted)) { throw new Exception("Unsupported service"); } if (_handles.ContainsKey(queueName)) { throw new Exception("Cant add second consumer with the same queueName"); } var handle = _host.ConnectReceiveEndpoint(queueName, x => { x.Consumer(() => commandServiceCasted); }); await handle.Ready; _handles.Add(queueName, handle); }
/// <summary> /// Creates a request client that uses the bus to publish a request. /// </summary> /// <typeparam name="TRequest">The request type</typeparam> /// <typeparam name="TResponse">The response type</typeparam> /// <param name="timeout">The timeout before the request is cancelled</param> /// <param name="callback">Callback when the request is sent</param> /// <param name="ttl">The time that the request will live for</param> /// <param name="host"></param> /// <param name="publishEndpoint"></param> /// <returns></returns> public static async Task <IRequestClient <TRequest, TResponse> > CreatePublishRequestClient <TRequest, TResponse>(this IRabbitMqHost host, IPublishEndpoint publishEndpoint, TimeSpan timeout, TimeSpan?ttl = default(TimeSpan?), Action <SendContext <TRequest> > callback = null) where TRequest : class where TResponse : class { var endpoint = await host.ConnectReceiveEndpoint(host.GetTemporaryQueueName("response")).ConfigureAwait(false); var ready = await endpoint.Ready.ConfigureAwait(false); return(new PublishRequestClient <TRequest, TResponse>(publishEndpoint, ready.ReceiveEndpoint, ready.InputAddress, timeout, ttl, callback)); }
/// <summary> /// Creates a request client factory which can be used to create a request client per message within a consume context. /// </summary> /// <typeparam name="TRequest"></typeparam> /// <typeparam name="TResponse"></typeparam> /// <param name="host">The host for the response endpoint</param> /// <param name="address">The service address</param> /// <param name="timeout">The request timeout</param> /// <param name="timeToLive">The request time to live</param> /// <param name="callback">Customize the send context</param> /// <returns></returns> public static async Task <IRequestClientFactory <TRequest, TResponse> > CreateRequestClientFactory <TRequest, TResponse>(this IRabbitMqHost host, Uri address, TimeSpan timeout, TimeSpan?timeToLive = default(TimeSpan?), Action <SendContext <TRequest> > callback = null) where TRequest : class where TResponse : class { var endpoint = host.ConnectReceiveEndpoint(host.Topology.CreateTemporaryQueueName("response")); var ready = await endpoint.Ready.ConfigureAwait(false); return(new MessageRequestClientFactory <TRequest, TResponse>(endpoint, ready.ReceiveEndpoint, ready.InputAddress, address, timeout, timeToLive, callback)); }
//public static void AddDocumentEndpoint<TConsumer>(this IRabbitMqHost host, string epName) where TConsumer : ReceiveDocument, IConsumer, new() //{ // host.ConnectReceiveEndpoint(epName, e => // { // e.BindMessageExchanges = false; // e.Consumer<TConsumer>(); // //document is queue name // e.Bind("document", s => // { // s.RoutingKey = epName; // s.ExchangeType = ExchangeType.Direct; // }); // e.Durable = true; // e.AutoDelete = true; // }); //} public static void AddDocumentEndpoint <TConsumer>(this IRabbitMqHost host, string epName, IDocumentRepository repo) where TConsumer : ReceiveDocument, IConsumer, new() { host.ConnectReceiveEndpoint(epName, e => { e.BindMessageExchanges = false; e.Consumer <TConsumer>(() => Activator.CreateInstance(typeof(TConsumer), new object[] { repo }) as TConsumer); //document is queue name e.Bind("document", s => { s.RoutingKey = epName; s.ExchangeType = ExchangeType.Direct; }); e.Durable = true; e.AutoDelete = true; }); }
static void Subscribe(IComponentContext context, string key) { var queuename = $"testcase-R-{key}"; var handle = _host.ConnectReceiveEndpoint(queuename, e => { e.BindMessageExchanges = false; e.Consumer <MyConsumer>(context); //<-- autofac is used to more closely represent the realworld scenario e.Bind(ExchangeName, x => { x.RoutingKey = RoutingKeyConvention(key); x.ExchangeType = ExchangeType.Direct; x.Durable = true; }); //this and SetEntityName are mutually exclusive, causes vague exceptions if you do. //Turn this on, and SetEntityName off. And you do receive messages. But routingkey constraints //are not enforced. So each consumer receives all published messages. Instead of only the ones belonging to its topic //e.Bind<MyMessage>(); }); handle.Ready.ConfigureAwait(false).GetAwaiter().GetResult(); }