public LinkConsumerBuilder(
Link link,
TimeSpan recoveryInterval,
ILinkSerializer serializer,
ushort?prefetchCount = null,
bool?autoAck = null,
int?priority = null,
bool?cancelOnHaFailover = null,
bool?exclusive = null,
ILinkConsumerErrorStrategy errorStrategy = null,
LinkConsumerMessageHandlerBuilder messageHandlerBuilder = null,
ILinkConsumerTopologyHandler topologyHandler = null,
LinkStateHandler <LinkConsumerState> stateHandler = null,
LinkStateHandler <LinkChannelState> channelStateHandler = null,
LinkTypeNameMapping typeNameMapping = null
)
{
_link = link ?? throw new ArgumentNullException(nameof(link));
_reconveryInterval = recoveryInterval;
_prefetchCount = prefetchCount ?? 1;
_autoAck = autoAck ?? false;
_priority = priority ?? 0;
_cancelOnHaFailover = cancelOnHaFailover ?? false;
_exclusive = exclusive ?? false;
_errorStrategy = errorStrategy ?? new LinkConsumerDefaultErrorStrategy();
_messageHandlerBuilder = messageHandlerBuilder;
_topologyHandler = topologyHandler;
_stateHandler = stateHandler ?? ((old, @new) => { });
_channelStateHandler = channelStateHandler ?? ((old, @new) => { });
_serializer = serializer;
_typeNameMapping = typeNameMapping ?? new LinkTypeNameMapping();
}
private LinkConsumerBuilder(
LinkConsumerBuilder prev,
TimeSpan?recoveryInterval = null,
ushort?prefetchCount = null,
bool?autoAck = null,
int?priority = null,
bool?cancelOnHaFailover = null,
bool?exclusive = null,
ILinkConsumerErrorStrategy errorStrategy = null,
LinkConsumerMessageHandlerBuilder messageHandlerBuilder = null,
ILinkConsumerTopologyHandler topologyHandler = null,
LinkStateHandler <LinkConsumerState> stateHandler = null,
LinkStateHandler <LinkChannelState> channelStateHandler = null,
ILinkSerializer serializer = null,
LinkTypeNameMapping typeNameMapping = null
) : this
(
prev._link,
recoveryInterval ?? prev._reconveryInterval,
serializer ?? prev._serializer,
prefetchCount ?? prev._prefetchCount,
autoAck ?? prev._autoAck,
priority ?? prev._priority,
cancelOnHaFailover ?? prev._cancelOnHaFailover,
exclusive ?? prev._exclusive,
errorStrategy ?? prev._errorStrategy,
messageHandlerBuilder ?? prev._messageHandlerBuilder,
topologyHandler ?? prev._topologyHandler,
stateHandler ?? prev._stateHandler,
channelStateHandler ?? prev._channelStateHandler,
typeNameMapping ?? prev._typeNameMapping
)
{
}
public LinkConsumerConfiguration(
TimeSpan recoveryInterval,
ushort prefetchCount,
bool autoAck,
int priority,
bool cancelOnHaFailover,
bool exclusive,
ILinkConsumerTopologyHandler topologyHandler,
LinkStateHandler<LinkConsumerState> stateHandler,
ILinkConsumerErrorStrategy errorStrategy,
LinkConsumerMessageHandlerDelegate<byte[]> messageHandler,
ILinkSerializer serializer
)
{
if (recoveryInterval < TimeSpan.Zero)
throw new ArgumentOutOfRangeException(nameof(recoveryInterval), "Must be greater than TimeSpan.Zero");
if(prefetchCount == 0)
throw new ArgumentOutOfRangeException(nameof(prefetchCount), "Must be greater than 0");
RecoveryInterval = recoveryInterval;
PrefetchCount = prefetchCount;
AutoAck = autoAck;
Priority = priority;
CancelOnHaFailover = cancelOnHaFailover;
Exclusive = exclusive;
MessageHandler = messageHandler ?? throw new ArgumentNullException(nameof(messageHandler));
ErrorStrategy = errorStrategy ?? throw new ArgumentNullException(nameof(errorStrategy));
TopologyHandler = topologyHandler ?? throw new ArgumentNullException(nameof(topologyHandler));
StateHandler = stateHandler ?? throw new ArgumentNullException(nameof(stateHandler));
Serializer = serializer;
}
public ILinkConsumerBuilder ErrorStrategy(ILinkConsumerErrorStrategy value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return(new LinkConsumerBuilder(this, errorStrategy: value));
}
public IRequestEndpoint <TService, TRequest, TResponse> ErrorStrategy(ILinkConsumerErrorStrategy value) => new RequestEndpoint <TService, TRequest, TResponse>(Link, Schema, SetParameter(nameof(ErrorStrategy), value));
public static ILinkConsumerBuilder CreateConsumerBuilder(ServiceLink link, IExchangeSchema exchange,
bool exchangePassive, bool queuePassive,
string queueName, bool autoAck, bool?cancelOnHaFailover, ILinkConsumerErrorStrategy errorStrategy,
bool exclusive, ushort prefetchCount, QueueParameters queueParameters, ICollection <string> routingKeys,
bool bind)
{
var builder = link
.Consumer
.AutoAck(autoAck);
if (cancelOnHaFailover != null)
{
builder = builder.CancelOnHaFailover(cancelOnHaFailover.Value);
}
if (errorStrategy != null)
{
builder = builder.ErrorStrategy(errorStrategy);
}
builder = builder.Exclusive(exclusive)
.PrefetchCount(prefetchCount);
if (!string.IsNullOrWhiteSpace(exchange.Name) &&
exchange.Type.ToLinkExchangeType() != LinkExchangeType.Fanout &&
(routingKeys == null || routingKeys.Count == 0))
{
throw new InvalidConfigurationException($"No routing key for bind specified!");
}
builder = builder.Queue(async cfg =>
{
var exch =
string.IsNullOrWhiteSpace(exchange.Name)
? await cfg.ExchangeDeclareDefault()
:
exchangePassive
? await cfg.ExchangeDeclarePassive(exchange.Name)
: await cfg.ExchangeDeclare(exchange.Name, exchange.Type.ToLinkExchangeType(),
exchange.Durable,
exchange.AutoDelete, exchange.Alternate, exchange.Delayed);
var queue = queuePassive
? await cfg.QueueDeclarePassive(queueName)
: await cfg.QueueDeclare(queueName, queueParameters.Durable(), queueParameters.Exclusive(), queueParameters.AutoDelete(),
queueParameters.MessageTtl(), queueParameters.Expires(), queueParameters.MaxPriority(), queueParameters.MaxLength(),
queueParameters.MaxLengthBytes(), queueParameters.DeadLetterExchange(), queueParameters.DeadLetterRoutingKey());
if (!string.IsNullOrWhiteSpace(exchange.Name) && bind)
{
if (exchange.Type.ToLinkExchangeType() == LinkExchangeType.Fanout)
{
await cfg.Bind(queue, exch);
}
else
{
foreach (var key in routingKeys)
{
await cfg.Bind(queue, exch, key);
}
}
}
return(queue);
});
return(builder);
}
public IEventEndpoint <TService, TEvent> ErrorStrategy(ILinkConsumerErrorStrategy value) => new EventEndpoint <TService, TEvent>(Link, Schema, SetParameter(nameof(ErrorStrategy), value));
