// -------------------------------- publish --------------------------------------------- public virtual Task PublishAsync( IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(messageProperties, "messageProperties"); Preconditions.CheckNotNull(body, "body"); var task = clientCommandDispatcher.Invoke(x => { var properties = x.CreateBasicProperties(); messageProperties.CopyTo(properties); return(_publisher.Publish(x, m => m.BasicPublish(exchange.Name, routingKey, mandatory, immediate, properties, body))); }).Unwrap(); logger.DebugWrite("Published to exchange: '{0}', routing key: '{1}', correlationId: '{2}'", exchange.Name, routingKey, messageProperties.CorrelationId); return(task); }
public virtual Task PublishAsync( IExchange exchange, string routingKey, bool mandatory, bool immediate, MessageProperties messageProperties, byte[] body) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(messageProperties, "messageProperties"); Preconditions.CheckNotNull(body, "body"); var rawMessage = produceConsumeInterceptor.OnProduce(new RawMessage(messageProperties, body)); return(clientCommandDispatcher.InvokeAsync(x => { var properties = x.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); return publisher.PublishAsync(x, m => m.BasicPublish(exchange.Name, routingKey, mandatory, immediate, properties, rawMessage.Body)) .Then(() => { eventBus.Publish(new PublishedMessageEvent(exchange.Name, routingKey, rawMessage.Properties, rawMessage.Body)); logger.DebugWrite("Published to exchange: '{0}', routing key: '{1}', correlationId: '{2}'", exchange.Name, routingKey, messageProperties.CorrelationId); }); }).Unwrap()); }
public async Task <IExchange> ExchangeDeclareAsync( string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool @internal = false, string alternateExchange = null, bool delayed = false) { Preconditions.CheckShortString(name, "name"); Preconditions.CheckShortString(type, "type"); if (passive) { await clientCommandDispatcher.InvokeAsync(x => x.ExchangeDeclarePassive(name)).ConfigureAwait(false); return(new Exchange(name)); } IDictionary <string, object> arguments = new Dictionary <string, object>(); if (alternateExchange != null) { arguments.Add("alternate-exchange", alternateExchange); } if (delayed) { arguments.Add("x-delayed-type", type); type = "x-delayed-message"; } await clientCommandDispatcher.InvokeAsync(x => x.ExchangeDeclare(name, type, durable, autoDelete, arguments)).ConfigureAwait(false); logger.DebugWrite("Declared Exchange: {0} type:{1}, durable:{2}, autoDelete:{3}, delayed:{4}", name, type, durable, autoDelete, delayed); return(new Exchange(name)); }
public virtual IExchange ExchangeDeclare( string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool @internal = false, string alternateExchange = null) { Preconditions.CheckNotNull(name, "name"); Preconditions.CheckShortString(type, "type"); if (passive) { clientCommandDispatcher.Invoke(x => x.ExchangeDeclarePassive(name)).Wait(); } else { IDictionary arguments = null; if (alternateExchange != null) { arguments = new Hashtable { { "alternate-exchange", alternateExchange } }; } clientCommandDispatcher.Invoke(x => x.ExchangeDeclare(name, type, durable, autoDelete, arguments)).Wait(); logger.DebugWrite("Declared Exchange: {0} type:{1}, durable:{2}, autoDelete:{3}", name, type, durable, autoDelete); } return(new Exchange(name)); }
public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckShortString(routingKey, "routingKey"); clientCommandDispatcher.Invoke(x => x.QueueBind(queue.Name, exchange.Name, routingKey)); logger.DebugWrite("Bound queue {0} to exchange {1} with routing key {2}", queue.Name, exchange.Name, routingKey); return(new Binding(queue, exchange, routingKey)); }
public virtual IBinding Bind(IExchange source, IExchange destination, string routingKey) { Preconditions.CheckNotNull(source, "source"); Preconditions.CheckNotNull(destination, "destination"); Preconditions.CheckShortString(routingKey, "routingKey"); clientCommandDispatcher.Invoke(x => x.ExchangeBind(destination.Name, source.Name, routingKey)); logger.DebugWrite("Bound destination exchange {0} to source exchange {1} with routing key {2}", destination.Name, source.Name, routingKey); return(new Binding(destination, source, routingKey)); }
public async Task <IBinding> BindAsync(IExchange source, IExchange destination, string routingKey) { Preconditions.CheckNotNull(source, "source"); Preconditions.CheckNotNull(destination, "destination"); Preconditions.CheckShortString(routingKey, "routingKey"); await clientCommandDispatcher.InvokeAsync(x => x.ExchangeBind(destination.Name, source.Name, routingKey)).ConfigureAwait(false); logger.DebugWrite("Bound destination exchange {0} to source exchange {1} with routing key {2}", destination.Name, source.Name, routingKey); return((IBinding) new Binding(destination, source, routingKey)); }
public async Task <IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckShortString(routingKey, "routingKey"); await clientCommandDispatcher.InvokeAsync(x => x.QueueBind(queue.Name, exchange.Name, routingKey)).ConfigureAwait(false); logger.DebugWrite("Bound queue {0} to exchange {1} with routing key {2}", queue.Name, exchange.Name, routingKey); return((IBinding) new Binding(queue, exchange, routingKey)); }
public virtual IBinding Bind(IExchange exchange, IQueue queue, string routingKey, IDictionary <string, object> headers) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(queue, "headers"); var arguments = headers ?? new Dictionary <string, object>(); clientCommandDispatcher.Invoke(x => x.QueueBind(queue.Name, exchange.Name, routingKey, arguments)); logger.DebugWrite("Bound queue {0} to exchange {1} with routing key {2} and {3} arguments", queue.Name, exchange.Name, routingKey, arguments.Count); return(new Binding(queue, exchange, routingKey, arguments)); }
public async Task <IExchange> ExchangeDeclareAsync( string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool @internal = false, string alternateExchange = null, bool delayed = false, IDictionary <string, object> arguments = null) { Preconditions.CheckShortString(name, "name"); Preconditions.CheckShortString(type, "type"); if (passive) { await clientCommandDispatcher.InvokeAsync(x => x.ExchangeDeclarePassive(name)).ConfigureAwait(false); return(new Exchange(name)); } if (arguments == null) { arguments = new Dictionary <string, object>(); } if (alternateExchange != null) { arguments["alternate-exchange"] = alternateExchange; } if (delayed) { arguments["x-delayed-type"] = type; type = "x-delayed-message"; } await clientCommandDispatcher.InvokeAsync(x => x.ExchangeDeclare(name, type, durable, autoDelete, arguments)).ConfigureAwait(false); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Declared exchange {exchange}: type={type}, durable={durable}, autoDelete={autoDelete}, arguments={arguments}", name, type, durable, autoDelete, arguments.Stringify() ); } return(new Exchange(name)); }
public async Task <IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, IDictionary <string, object> headers) { Preconditions.CheckNotNull(source, "source"); Preconditions.CheckNotNull(destination, "destination"); Preconditions.CheckShortString(routingKey, "routingKey"); var arguments = headers ?? new Dictionary <string, object>(); await clientCommandDispatcher.InvokeAsync(x => x.ExchangeBind(destination.Name, source.Name, routingKey, arguments)).ConfigureAwait(false); logger.DebugWrite("Bound destination exchange {0} to source exchange {1} with routing key {2} and {3} arguments", destination.Name, source.Name, routingKey, arguments.Count); return(new Binding(destination, source, routingKey, arguments)); }
public async Task <IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, IDictionary <string, object> headers) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckShortString(routingKey, "routingKey"); var arguments = headers ?? new Dictionary <string, object>(); await clientCommandDispatcher.InvokeAsync(x => x.QueueBind(queue.Name, exchange.Name, routingKey, arguments)).ConfigureAwait(false); logger.DebugWrite("Bound queue {0} to exchange {1} with routing key {2} and {3} arguments", queue.Name, exchange.Name, routingKey, arguments.Count); return(new Binding(queue, exchange, routingKey, arguments)); }
/// <inheritdoc /> public virtual AwaitableDisposable <IDisposable> RespondAsync <TRequest, TResponse>( Func <TRequest, CancellationToken, Task <TResponse> > responder, Action <IResponderConfiguration> configure, CancellationToken cancellationToken = default ) { Preconditions.CheckNotNull(responder, "responder"); Preconditions.CheckNotNull(configure, "configure"); // We're explicitly validating TResponse here because the type won't be used directly. // It'll only be used when executing a successful responder, which will silently fail if TResponse serialized length exceeds the limit. Preconditions.CheckShortString(typeNameSerializer.Serialize(typeof(TResponse)), "TResponse"); return(RespondAsyncInternal(responder, configure, cancellationToken).ToAwaitableDisposable()); }
public virtual Task PublishAsync <T>( IExchange exchange, string routingKey, bool mandatory, IMessage <T> message) where T : class { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(message, "message"); var serializedMessage = messageSerializationStrategy.SerializeMessage(message); return(PublishAsync(exchange, routingKey, mandatory, serializedMessage.Properties, serializedMessage.Body)); }
/// <inheritdoc /> public async Task ExchangeDeclarePassiveAsync(string name, CancellationToken cancellationToken = default) { Preconditions.CheckShortString(name, "name"); using var cts = cancellationToken.WithTimeout(configuration.Timeout); await clientCommandDispatcher.InvokeAsync( x => x.ExchangeDeclarePassive(name), cts.Token ).ConfigureAwait(false); if (logger.IsDebugEnabled()) { logger.DebugFormat("Passive declared exchange {exchange}", name); } }
public virtual IExchange ExchangeDeclare( string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool @internal = false, string alternateExchange = null, bool delayed = false) { Preconditions.CheckShortString(name, "name"); Preconditions.CheckShortString(type, "type"); if (passive) { clientCommandDispatcher.Invoke(x => x.ExchangeDeclarePassive(name)); return(new Exchange(name)); } IDictionary <string, object> arguments = new Dictionary <string, object>(); if (alternateExchange != null) { arguments.Add("alternate-exchange", alternateExchange); } if (delayed) { arguments.Add("x-delayed-type", type); type = "x-delayed-message"; } clientCommandDispatcher.Invoke(x => x.ExchangeDeclare(name, type, durable, autoDelete, arguments)); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Declared exchange {exchange}: type={type}, durable={durable}, autoDelete={autoDelete}, arguments={arguments}", name, type, durable, autoDelete, arguments.Stringify() ); } return(new Exchange(name)); }
public async Task <IBinding> BindAsync(IExchange source, IExchange destination, string routingKey, IDictionary <string, object> headers) { Preconditions.CheckNotNull(source, "source"); Preconditions.CheckNotNull(destination, "destination"); Preconditions.CheckShortString(routingKey, "routingKey"); var arguments = headers ?? new Dictionary <string, object>(); await clientCommandDispatcher.InvokeAsync(x => x.ExchangeBind(destination.Name, source.Name, routingKey, arguments)).ConfigureAwait(false); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Bound destination exchange {destinationExchange} to source exchange {sourceExchange} with routingKey={routingKey} and arguments={arguments}", destination.Name, source.Name, routingKey, arguments.Stringify() ); } return(new Binding(destination, source, routingKey, arguments)); }
public async Task <IBinding> BindAsync(IExchange exchange, IQueue queue, string routingKey, IDictionary <string, object> headers) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckNotNull(queue, "queue"); Preconditions.CheckShortString(routingKey, "routingKey"); var arguments = headers ?? new Dictionary <string, object>(); await clientCommandDispatcher.InvokeAsync(x => x.QueueBind(queue.Name, exchange.Name, routingKey, arguments)).ConfigureAwait(false); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Bound queue {queue} to exchange {exchange} with routingKey={routingKey} and arguments={arguments}", queue.Name, exchange.Name, routingKey, arguments.Stringify() ); } return(new Binding(queue, exchange, routingKey, arguments)); }
public virtual Task PublishAsync <T>( IExchange exchange, string routingKey, bool mandatory, bool immediate, IMessage <T> message) where T : class { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(message, "message"); var typeName = typeNameSerializer.Serialize(message.Body.GetType()); var messageBody = serializer.MessageToBytes(message.Body); message.Properties.Type = typeName; message.Properties.CorrelationId = string.IsNullOrEmpty(message.Properties.CorrelationId) ? getCorrelationId() : message.Properties.CorrelationId; return(PublishAsync(exchange, routingKey, mandatory, immediate, message.Properties, messageBody)); }
public virtual IExchange ExchangeDeclare( string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool @internal = false) { Preconditions.CheckNotNull(name, "name"); Preconditions.CheckShortString(type, "type"); if (passive) { clientCommandDispatcher.Invoke(x => x.ExchangeDeclarePassive(name)).Wait(); } else { clientCommandDispatcher.Invoke(x => x.ExchangeDeclare(name, type, durable, autoDelete, null)).Wait(); logger.DebugWrite("Declared Exchange: {0} type:{1}, durable:{2}, autoDelete:{3}", name, type, durable, autoDelete); } return(new Exchange(name)); }
/// <inheritdoc /> public async Task <IExchange> ExchangeDeclareAsync( string name, Action <IExchangeDeclareConfiguration> configure, CancellationToken cancellationToken = default ) { Preconditions.CheckShortString(name, "name"); using var cts = cancellationToken.WithTimeout(configuration.Timeout); var exchangeDeclareConfiguration = new ExchangeDeclareConfiguration(); configure(exchangeDeclareConfiguration); var type = exchangeDeclareConfiguration.Type; var isDurable = exchangeDeclareConfiguration.IsDurable; var isAutoDelete = exchangeDeclareConfiguration.IsAutoDelete; var arguments = exchangeDeclareConfiguration.Arguments; await clientCommandDispatcher.InvokeAsync( x => x.ExchangeDeclare(name, type, isDurable, isAutoDelete, arguments), cts.Token ).ConfigureAwait(false); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Declared exchange {exchange}: type={type}, durable={durable}, autoDelete={autoDelete}, arguments={arguments}", name, type, isDurable, isAutoDelete, arguments.Stringify() ); } return(new Exchange(name, type, isDurable, isAutoDelete, arguments)); }
public Task <IExchange> ExchangeDeclareAsync( string name, string type, bool passive = false, bool durable = true, bool autoDelete = false, bool @internal = false, string alternateExchange = null) { Preconditions.CheckShortString(name, "name"); Preconditions.CheckShortString(type, "type"); if (passive) { return(clientCommandDispatcher.Invoke(x => x.ExchangeDeclarePassive(name)) .Then(() => (IExchange) new Exchange(name))); } IDictionary <string, object> arguments = null; if (alternateExchange != null) { arguments = new Dictionary <string, object> { { "alternate-exchange", alternateExchange } }; } return(clientCommandDispatcher.Invoke(x => x.ExchangeDeclare(name, type, durable, autoDelete, arguments)) .Then(() => { logger.DebugWrite("Declared Exchange: {0} type:{1}, durable:{2}, autoDelete:{3}", name, type, durable, autoDelete); return (IExchange) new Exchange(name); })); }
public virtual async Task PublishAsync( IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(messageProperties, "messageProperties"); Preconditions.CheckNotNull(body, "body"); // Fix me: It's very hard now to move publish logic to separate abstraction, just leave it here. var rawMessage = produceConsumeInterceptor.OnProduce(new RawMessage(messageProperties, body)); if (connectionConfiguration.PublisherConfirms) { var timeout = TimeBudget.Start(connectionConfiguration.GetTimeout()); while (true) { if (timeout.IsExpired()) { throw new TimeoutException($"Publish timed out after {connectionConfiguration.Timeout} seconds"); } var confirmsWaiter = await clientCommandDispatcher.InvokeAsync(model => { var properties = model.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); var waiter = confirmationListener.GetWaiter(model); try { model.BasicPublish(exchange.Name, routingKey, mandatory, properties, rawMessage.Body); } catch (Exception) { waiter.Cancel(); throw; } return(waiter); }).ConfigureAwait(false); try { await confirmsWaiter.WaitAsync(timeout).ConfigureAwait(false); break; } catch (PublishInterruptedException) { } } } else { await clientCommandDispatcher.InvokeAsync(model => { var properties = model.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); model.BasicPublish(exchange.Name, routingKey, mandatory, properties, rawMessage.Body); }).ConfigureAwait(false); } eventBus.Publish(new PublishedMessageEvent(exchange.Name, routingKey, rawMessage.Properties, rawMessage.Body)); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Published to exchange {exchange} with routingKey={routingKey} and correlationId={correlationId}", exchange.Name, routingKey, messageProperties.CorrelationId ); } }
public virtual async Task PublishAsync( IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(messageProperties, "messageProperties"); Preconditions.CheckNotNull(body, "body"); // Fix me: It's very hard now to move publish logic to separate abstraction, just leave it here. var rawMessage = produceConsumeInterceptor.OnProduce(new RawMessage(messageProperties, body)); if (connectionConfiguration.PublisherConfirms) { var timeBudget = new TimeBudget(TimeSpan.FromSeconds(connectionConfiguration.Timeout)).Start(); while (!timeBudget.IsExpired()) { var confirmsWaiter = await clientCommandDispatcher.InvokeAsync(model => { var properties = model.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); var waiter = confirmationListener.GetWaiter(model); try { model.BasicPublish(exchange.Name, routingKey, mandatory, properties, rawMessage.Body); } catch (Exception) { waiter.Cancel(); throw; } return(waiter); }).ConfigureAwait(false); try { await confirmsWaiter.WaitAsync(timeBudget.GetRemainingTime()).ConfigureAwait(false); break; } catch (PublishInterruptedException) { } } } else { await clientCommandDispatcher.InvokeAsync(model => { var properties = model.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); model.BasicPublish(exchange.Name, routingKey, mandatory, properties, rawMessage.Body); }).ConfigureAwait(false); } eventBus.Publish(new PublishedMessageEvent(exchange.Name, routingKey, rawMessage.Properties, rawMessage.Body)); logger.DebugWrite("Published to exchange: '{0}', routing key: '{1}', correlationId: '{2}'", exchange.Name, routingKey, messageProperties.CorrelationId); }
/// <inheritdoc /> public virtual async Task PublishAsync( IExchange exchange, string routingKey, bool mandatory, MessageProperties messageProperties, byte[] body, CancellationToken cancellationToken ) { Preconditions.CheckNotNull(exchange, "exchange"); Preconditions.CheckShortString(routingKey, "routingKey"); Preconditions.CheckNotNull(messageProperties, "messageProperties"); Preconditions.CheckNotNull(body, "body"); using var cts = cancellationToken.WithTimeout(configuration.Timeout); var rawMessage = produceConsumeInterceptor.OnProduce(new ProducedMessage(messageProperties, body)); if (configuration.PublisherConfirms) { while (true) { var pendingConfirmation = await clientCommandDispatcher.InvokeAsync(model => { var confirmation = confirmationListener.CreatePendingConfirmation(model); rawMessage.Properties.SetConfirmationId(confirmation.Id); var properties = model.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); try { model.BasicPublish(exchange.Name, routingKey, mandatory, properties, rawMessage.Body); } catch (Exception) { confirmation.Cancel(); throw; } return(confirmation); }, ChannelDispatchOptions.PublishWithConfirms, cts.Token).ConfigureAwait(false); try { await pendingConfirmation.WaitAsync(cts.Token).ConfigureAwait(false); break; } catch (PublishInterruptedException) { } } } else { await clientCommandDispatcher.InvokeAsync(model => { var properties = model.CreateBasicProperties(); rawMessage.Properties.CopyTo(properties); model.BasicPublish(exchange.Name, routingKey, mandatory, properties, rawMessage.Body); }, ChannelDispatchOptions.Publish, cts.Token).ConfigureAwait(false); } eventBus.Publish(new PublishedMessageEvent(exchange.Name, routingKey, rawMessage.Properties, rawMessage.Body)); if (logger.IsDebugEnabled()) { logger.DebugFormat( "Published to exchange {exchange} with routingKey={routingKey} and correlationId={correlationId}", exchange.Name, routingKey, messageProperties.CorrelationId ); } }