public async Task <IProducerStream> CreateStream(IProducerProxy proxy, CancellationToken cancellationToken)
{
var commandProducer = new CommandProducer
{
ProducerName = _options.ProducerName,
Topic = _options.Topic
};
while (true)
{
try
{
var connection = await _connectionPool.FindConnectionForTopic(_options.Topic, cancellationToken);
var response = await connection.Send(commandProducer, proxy);
return(new ProducerStream(response.ProducerId, response.ProducerName, _sequenceId, connection, _faultStrategy, proxy));
}
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 ProducerStream(ulong id, string name, SequenceId sequenceId, Connection connection, IFaultStrategy faultStrategy, IProducerProxy proxy)
{
_cachedMetadata = new PulsarApi.MessageMetadata
{
ProducerName = name
};
var commandSend = new CommandSend
{
ProducerId = id,
NumMessages = 1
};
_cachedSendPackage = new SendPackage(commandSend, _cachedMetadata);
_id = id;
_sequenceId = sequenceId;
_connection = connection;
_faultStrategy = faultStrategy;
_proxy = proxy;
}
public async Task <ProducerResponse> Send(CommandProducer command, IProducerProxy proxy)
{
Task <BaseCommand>?responseTask = null;
using (await _lock.Lock())
{
_producerManager.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)
{
_producerManager.Remove(command.ProducerId);
response.Error.Throw();
}
return(new ProducerResponse(command.ProducerId, response.ProducerSuccess.ProducerName));
}
