public ConsumerStream(
ulong id,
uint messagePrefetchCount,
IDequeue <MessagePackage> dequeue,
Connection connection,
IFaultStrategy faultStrategy,
IConsumerProxy proxy,
BatchHandler batchHandler)
{
_id = id;
_dequeue = dequeue;
_connection = connection;
_faultStrategy = faultStrategy;
_proxy = proxy;
_batchHandler = batchHandler;
_cachedCommandFlow = new CommandFlow {
ConsumerId = id, MessagePermits = messagePrefetchCount
};
_sendWhenZero = 0;
_firstFlow = true;
}
public async Task <IConsumerStream> CreateStream(IConsumerProxy proxy, CancellationToken cancellationToken)
{
while (true)
{
try
{
var connection = await _connectionPool.FindConnectionForTopic(_subscribe.Topic, cancellationToken);
var response = await connection.Send(_subscribe, proxy);
return(new ConsumerStream(response.ConsumerId, _messagePrefetchCount, proxy, connection, _faultStrategy, proxy, _batchHandler));
}
catch (OperationCanceledException)
{
if (cancellationToken.IsCancellationRequested)
{
throw;
}
else
{
await Task.Delay(_faultStrategy.RetryInterval, cancellationToken);
}
}
catch (Exception exception)
{
switch (_faultStrategy.DetermineFaultAction(exception))
{
case FaultAction.Relookup:
case FaultAction.Retry:
await Task.Delay(_faultStrategy.RetryInterval, cancellationToken);
continue;
}
throw;
}
}
}
public async Task <SubscribeResponse> Send(CommandSubscribe command, IConsumerProxy proxy)
{
Task <BaseCommand>?responseTask = null;
using (await _lock.Lock())
{
_consumerManager.Outgoing(command, proxy);
var baseCommand = command.AsBaseCommand();
responseTask = _requestResponseHandler.Outgoing(baseCommand);
var sequence = Serializer.Serialize(baseCommand);
await _stream.Send(sequence);
}
var response = await responseTask;
if (response.CommandType == BaseCommand.Type.Error)
{
_consumerManager.Remove(command.ConsumerId);
response.Error.Throw();
}
return(new SubscribeResponse(command.ConsumerId));
}
