public async Task<Message> ReceiveMessageAsync(TimeSpan timeout)
{
if (Logging.IsEnabled) Logging.Enter(this, timeout, $"{nameof(ReceiveMessageAsync)}");
try
{
await EnsureReceivingLinkIsOpenedAsync(timeout).ConfigureAwait(false);
Debug.Assert(_messageSendingLink != null);
AmqpMessage amqpMessage = await AmqpLinkHelper.ReceiveAmqpMessageAsync(_messageReceivingLink, timeout).ConfigureAwait(false);
Message message = null;
if (amqpMessage != null)
{
message = new Message(amqpMessage)
{
LockToken = new Guid(amqpMessage.DeliveryTag.Array).ToString()
};
}
return message;
}
finally
{
if (Logging.IsEnabled) Logging.Exit(this, timeout, $"{nameof(ReceiveMessageAsync)}");
}
}
private async Task EnsureReceivingLinkIsOpenedAsync(TimeSpan timeout)
{
if (Volatile.Read(ref _messageReceivingLink) != null) return;
if (Logging.IsEnabled) Logging.Enter(this, timeout, $"{nameof(EnsureReceivingLinkIsOpenedAsync)}");
try
{
await _messageReceivingLinkLock.WaitAsync().ConfigureAwait(false);
if (_messageReceivingLink != null) return;
_messageReceivingLink = await AmqpLinkHelper.OpenTelemetryReceiverLinkAsync(
_deviceIdentity,
_amqpSession,
timeout
).ConfigureAwait(false);
_messageReceivingLink.Closed += OnLinkDisconnected;
if (Logging.IsEnabled) Logging.Associate(this, this, _messageReceivingLink, $"{nameof(EnsureReceivingLinkIsOpenedAsync)}");
}
finally
{
_messageReceivingLinkLock.Release();
if (Logging.IsEnabled) Logging.Exit(this, timeout, $"{nameof(EnsureReceivingLinkIsOpenedAsync)}");
}
}
public async Task EnableEventReceiveAsync(TimeSpan timeout)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, timeout, $"{nameof(EnableEventReceiveAsync)}");
}
try
{
Debug.Assert(_eventReceivingLink == null);
_eventReceivingLink = await AmqpLinkHelper.OpenEventsReceiverLinkAsync(
_deviceIdentity,
_amqpSession,
timeout
).ConfigureAwait(false);
_eventReceivingLink.RegisterMessageListener(OnEventsReceived);
_eventReceivingLink.Closed += OnLinkDisconnected;
if (Logging.IsEnabled)
{
Logging.Associate(this, this, _eventReceivingLink, $"{nameof(EnableEventReceiveAsync)}");
}
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(this, timeout, $"{nameof(EnableEventReceiveAsync)}");
}
}
}
public async Task EnsureTwinLinksAreOpenedAsync(TimeSpan timeout)
{
if (Volatile.Read(ref _twinLinksOpened) == true) return;
if (Logging.IsEnabled) Logging.Enter(this, timeout, $"{nameof(EnsureTwinLinksAreOpenedAsync)}");
try
{
await _twinLinksLock.WaitAsync().ConfigureAwait(false);
if (_twinLinksOpened) return;
Debug.Assert(_twinSendingLink == null);
Debug.Assert(_twinReceivingLink == null);
string correlationIdSuffix = Guid.NewGuid().ToString();
Task<ReceivingAmqpLink> receiveLinkCreator =
AmqpLinkHelper.OpenTwinReceiverLinkAsync(
_deviceIdentity,
_amqpSession,
correlationIdSuffix,
timeout);
Task<SendingAmqpLink> sendingLinkCreator =
AmqpLinkHelper.OpenTwinSenderLinkAsync(
_deviceIdentity,
_amqpSession,
correlationIdSuffix,
timeout);
await Task.WhenAll(receiveLinkCreator, sendingLinkCreator).ConfigureAwait(false);
_twinSendingLink = sendingLinkCreator.Result;
_twinSendingLink.Closed += OnLinkDisconnected;
_twinReceivingLink = receiveLinkCreator.Result;
_twinReceivingLink.RegisterMessageListener(OnDesiredPropertyReceived);
_twinReceivingLink.Closed += OnLinkDisconnected;
_twinLinksOpened = true;
if (Logging.IsEnabled) Logging.Associate(this, this, _twinReceivingLink, $"{nameof(EnsureTwinLinksAreOpenedAsync)}");
if (Logging.IsEnabled) Logging.Associate(this, this, _twinSendingLink, $"{nameof(EnsureTwinLinksAreOpenedAsync)}");
}
catch (Exception ex) when (!ex.IsFatal())
{
_twinReceivingLink?.Abort();
_twinSendingLink?.Abort();
_twinReceivingLink = null;
_twinSendingLink = null;
throw;
}
finally
{
_twinLinksLock.Release();
if (Logging.IsEnabled) Logging.Exit(this, timeout, $"{nameof(EnsureTwinLinksAreOpenedAsync)}");
}
}
public async Task EnableMethodsAsync(TimeSpan timeout)
{
if (Logging.IsEnabled) Logging.Enter(this, timeout, $"{nameof(EnableMethodsAsync)}");
try
{
Debug.Assert(_methodSendingLink == null);
Debug.Assert(_methodReceivingLink == null);
string correlationIdSuffix = Guid.NewGuid().ToString();
Task<ReceivingAmqpLink> receiveLinkCreator =
AmqpLinkHelper.OpenMethodsReceiverLinkAsync(
_deviceIdentity,
_amqpSession,
correlationIdSuffix,
timeout);
Task<SendingAmqpLink> sendingLinkCreator =
AmqpLinkHelper.OpenMethodsSenderLinkAsync(
_deviceIdentity,
_amqpSession,
correlationIdSuffix,
timeout);
await Task.WhenAll(receiveLinkCreator, sendingLinkCreator).ConfigureAwait(false);
_methodReceivingLink = receiveLinkCreator.Result;
_methodSendingLink = sendingLinkCreator.Result;
_methodReceivingLink.RegisterMessageListener(OnMethodReceived);
_methodSendingLink.Closed += OnLinkDisconnected;
_methodReceivingLink.Closed += OnLinkDisconnected;
if (Logging.IsEnabled) Logging.Associate(this, _methodReceivingLink, $"{nameof(_methodReceivingLink)}");
if (Logging.IsEnabled) Logging.Associate(this, _methodSendingLink, $"{nameof(_methodSendingLink)}");
}
catch (Exception)
{
_methodReceivingLink?.Abort();
_methodReceivingLink = null;
_methodSendingLink?.Abort();
_methodSendingLink = null;
throw;
}
finally
{
if (Logging.IsEnabled) Logging.Exit(this, timeout, $"{nameof(EnableMethodsAsync)}");
}
}
public async Task<Outcome> SendMessageAsync(AmqpMessage message, TimeSpan timeout)
{
if (Logging.IsEnabled) Logging.Enter(this, message, timeout, $"{nameof(SendMessageAsync)}");
try
{
Debug.Assert(_messageSendingLink != null);
Outcome outcome = await AmqpLinkHelper.SendAmqpMessageAsync(_messageSendingLink, message, timeout).ConfigureAwait(false);
return outcome;
}
finally
{
if (Logging.IsEnabled) Logging.Exit(this, message, timeout, $"{nameof(SendMessageAsync)}");
}
}
public async Task OpenAsync(TimeSpan timeout)
{
if (Logging.IsEnabled) Logging.Enter(this, timeout, $"{nameof(OpenAsync)}");
try
{
Debug.Assert(_amqpSession == null);
Debug.Assert(IsUsable());
_amqpSession = await _amqpSessionCreator.Invoke(
_deviceIdentity,
AmqpLinkFactory.GetInstance(),
_amqpSessionSettings,
timeout).ConfigureAwait(false);
if (Logging.IsEnabled) Logging.Associate(this, _amqpSession, $"{nameof(_amqpSession)}");
await _amqpSession.OpenAsync(timeout).ConfigureAwait(false);
if (_deviceIdentity.AuthenticationModel == AuthenticationModel.SasIndividual)
{
_amqpAuthenticationRefresher = await _amqpAuthenticationRefresherCreator.Invoke(_deviceIdentity, timeout).ConfigureAwait(false);
if (Logging.IsEnabled) Logging.Associate(this, _amqpAuthenticationRefresher, $"{nameof(_amqpAuthenticationRefresher)}");
}
_amqpSession.Closed += OnSessionDisconnected;
_messageSendingLink = await AmqpLinkHelper.OpenTelemetrySenderLinkAsync(
_deviceIdentity,
_amqpSession,
timeout).ConfigureAwait(false);
_messageSendingLink.Closed += OnLinkDisconnected;
if (Logging.IsEnabled) Logging.Associate(this, _messageSendingLink, $"{nameof(_messageSendingLink)}");
}
catch (Exception ex) when (!ex.IsFatal())
{
if (SetNotUsable() == 0)
{
OnUnitDisconnected?.Invoke(false, EventArgs.Empty);
}
throw;
}
finally
{
if (Logging.IsEnabled) Logging.Exit(this, timeout, $"{nameof(OpenAsync)}");
}
}
public async Task<Outcome> DisposeMessageAsync(string lockToken, Outcome outcome, TimeSpan timeout)
{
if (Logging.IsEnabled) Logging.Enter(this, lockToken, $"{nameof(DisposeMessageAsync)}");
Outcome disposeOutcome;
if (_deviceIdentity.IotHubConnectionString.ModuleId.IsNullOrWhiteSpace())
{
disposeOutcome = await AmqpLinkHelper.DisposeMessageAsync(_messageReceivingLink, lockToken, outcome, timeout).ConfigureAwait(false);
}
else
{
disposeOutcome = await AmqpLinkHelper.DisposeMessageAsync(_eventReceivingLink, lockToken, outcome, timeout).ConfigureAwait(false);
}
if (Logging.IsEnabled) Logging.Exit(this, lockToken, $"{nameof(DisposeMessageAsync)}");
return disposeOutcome;
}
