public async ValueTask <bool> HasChannels()
{
using (await _lock.Lock())
{
return(_channelManager.HasChannels());
}
}
private async ValueTask <Connection> GetConnection(Uri serviceUrl, CancellationToken cancellationToken)
{
using (await _lock.Lock(cancellationToken).ConfigureAwait(false))
{
if (_connections.TryGetValue(serviceUrl, out Connection connection))
{
return(connection);
}
return(await EstablishNewConnection(serviceUrl, cancellationToken).ConfigureAwait(false));
}
}
public async ValueTask <bool> HasChannels(CancellationToken cancellationToken)
{
ThrowIfDisposed();
using (await _lock.Lock(cancellationToken).ConfigureAwait(false))
{
return(_channelManager.HasChannels());
}
}
public async Task Execute(Action action, CancellationToken cancellationToken)
{
using (await _lock.Lock(cancellationToken))
{
while (true)
{
try
{
action();
return;
}
catch (Exception exception)
{
await _onException(exception, cancellationToken);
}
cancellationToken.ThrowIfCancellationRequested();
}
}
}
private async Task <Connection> CreateConnection(Uri serviceUrl, CancellationToken cancellationToken)
{
using (await _lock.Lock(cancellationToken))
{
if (_connections.TryGetValue(serviceUrl, out Connection connection))
{
return(connection);
}
var stream = await _connector.Connect(serviceUrl);
connection = new Connection(stream);
Register(serviceUrl, connection);
var response = await connection.Send(_commandConnect);
response.Expect(BaseCommand.Type.Connected);
return(connection);
}
}
public async ValueTask Execute(Action action, CancellationToken cancellationToken)
{
using (await _lock.Lock(cancellationToken).ConfigureAwait(false))
{
await _executor.Execute(action, cancellationToken).ConfigureAwait(false);
}
}
public async Task <bool> IsActive()
{
using (await _lock.Lock())
{
return(_producerManager.HasProducers || _consumerManager.HasConsumers);
}
}
public async ValueTask <Message> Receive(CancellationToken cancellationToken)
{
using (await _lock.Lock(cancellationToken).ConfigureAwait(false))
{
while (true)
{
if (_sendWhenZero == 0)
{
await SendFlow(cancellationToken).ConfigureAwait(false);
}
_sendWhenZero--;
var message = _batchHandler.GetNext();
if (message is not null)
{
return(message);
}
var messagePackage = await _queue.Dequeue(cancellationToken).ConfigureAwait(false);
if (!messagePackage.IsValid())
{
await RejectPackage(messagePackage, cancellationToken).ConfigureAwait(false);
continue;
}
var metadataSize = messagePackage.GetMetadataSize();
var redeliveryCount = messagePackage.RedeliveryCount;
var data = messagePackage.ExtractData(metadataSize);
var metadata = messagePackage.ExtractMetadata(metadataSize);
var messageId = messagePackage.MessageId;
return(metadata.ShouldSerializeNumMessagesInBatch()
? _batchHandler.Add(messageId, redeliveryCount, metadata, data)
: MessageFactory.Create(new MessageId(messageId), redeliveryCount, metadata, data));
}
}
}
public async ValueTask <Message> Receive(CancellationToken cancellationToken)
{
using (await _lock.Lock(cancellationToken).ConfigureAwait(false))
{
while (true)
{
if (_sendWhenZero == 0)
{
await SendFlow(cancellationToken).ConfigureAwait(false);
}
_sendWhenZero--;
var message = _batchHandler.GetNext();
if (message is not null)
{
return(message);
}
var messagePackage = await _queue.Dequeue(cancellationToken).ConfigureAwait(false);
if (!messagePackage.ValidateMagicNumberAndChecksum())
{
await RejectPackage(messagePackage, CommandAck.ValidationErrorType.ChecksumMismatch, cancellationToken).ConfigureAwait(false);
continue;
}
var metadataSize = messagePackage.GetMetadataSize();
var metadata = messagePackage.ExtractMetadata(metadataSize);
var data = messagePackage.ExtractData(metadataSize);
if (metadata.Compression != CompressionType.None)
{
var decompressor = _decompressors[(int)metadata.Compression];
if (decompressor is null)
{
throw new CompressionException($"Support for {metadata.Compression} compression was not found");
}
try
{
data = decompressor.Decompress(data, (int)metadata.UncompressedSize);
}
catch
{
await RejectPackage(messagePackage, CommandAck.ValidationErrorType.DecompressionError, cancellationToken).ConfigureAwait(false);
continue;
}
}
var messageId = messagePackage.MessageId;
var redeliveryCount = messagePackage.RedeliveryCount;
return(metadata.ShouldSerializeNumMessagesInBatch()
? _batchHandler.Add(messageId, redeliveryCount, metadata, data)
: MessageFactory.Create(messageId.ToMessageId(), redeliveryCount, metadata, data));
}
}
}
