private async ValueTask SendSerializedPayloadToNextAvailableClient(SerializedPayload serializedPayload)
{
// keep trying to find an available client
while (true)
{
var client = _dispatcher.NextAvailable();
// if no subscription is found then just wait
if (client is null)
{
await _throttling.WaitAndIncrease();
continue;
}
// reset the _throttling to base value
_throttling.Reset();
// get ticket for payload
try
{
_logger.LogInformation(
$"Adding message with id: {serializedPayload.PayloadId} to subscription with id: {client.Id} in topic: {Name}");
var ticket = client.Enqueue(serializedPayload);
ticket.OnStatusChanged += OnStatusChanged;
break;
}
catch (ChannelClosedException)
{
// no-op since the client might be disposed
}
}
}
public async Task <SendAsyncResult> SendAsync(SerializedPayload serializedPayload,
bool completeOnSeverOkReceived, CancellationToken cancellationToken)
{
if (completeOnSeverOkReceived)
{
var sendPayloadTask =
_taskManager.Setup(serializedPayload.PayloadId, true, cancellationToken);
var sendSuccess = await _connectionManager.SendAsync(serializedPayload, cancellationToken);
if (sendSuccess)
{
_taskManager.OnPayloadSendSuccess(serializedPayload.PayloadId);
}
else
{
_taskManager.OnPayloadSendFailed(serializedPayload.PayloadId);
}
return(await sendPayloadTask);
}
else
{
var sendSuccess = await _connectionManager.SendAsync(serializedPayload, cancellationToken);
return(new SendAsyncResult {
IsSuccess = sendSuccess
});
}
}
/// <inheritdoc />
public async Task <bool> SendAsync(SerializedPayload serializedPayload, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
// wait for connection to be reestablished
if (!(Socket?.Connected ?? false))
{
_logger.LogTrace("Waiting for broker to reconnect");
try
{
await Task.Delay(1000, cancellationToken);
continue;
}
catch (TaskCanceledException)
{
return(false);
}
}
try
{
await _semaphore.WaitAsync(cancellationToken);
var result = await Client.SendAsync(serializedPayload.Data, cancellationToken);
_logger.LogTrace($"Sending payload with id {serializedPayload.PayloadId}");
if (result)
{
return(true);
}
if (!_configuration.AutoReconnect)
{
return(false);
}
}
catch (ObjectDisposedException)
{
return(false);
}
catch (OperationCanceledException)
{
return(false);
}
finally
{
_semaphore.Release();
}
}
// only when cancellation is requested
return(false);
}
public override int GetHashCode()
{
int hash = 1;
if (SerializedPayload.Length != 0)
{
hash ^= SerializedPayload.GetHashCode();
}
hash ^= signatures_.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
/// <inheritdoc />
public AsyncPayloadTicket Enqueue(SerializedPayload serializedPayload)
{
lock (this)
{
var queueWasSuccessful = _queue.Writer.TryWrite(serializedPayload);
if (queueWasSuccessful)
{
_logger.LogTrace($"Enqueue message: {serializedPayload.PayloadId} in client: {Id}");
var ticket = ObjectPool.Shared.Rent <AsyncPayloadTicket>();
ticket.Setup(serializedPayload.PayloadId);
_tickets[ticket.PayloadId] = ticket;
return(ticket);
}
throw new ChannelClosedException();
}
}
/// <inheritdoc />
public void EnqueueFireAndForget(SerializedPayload serializedPayload)
{
_queue.Writer.TryWrite(serializedPayload);
}
