internal async Task EnableTwinLinksAsync(TimeSpan timeout)
{
if (_closed)
{
throw new IotHubException("Device is now offline.", false);
}
Logging.Enter(this, timeout, nameof(EnableTwinLinksAsync));
AmqpIoTSession amqpIoTSession = await EnsureSessionIsOpenAsync(timeout).ConfigureAwait(false);
bool enteredSemaphore = await _twinLinksSemaphore.WaitAsync(timeout).ConfigureAwait(false);
if (!enteredSemaphore)
{
throw new TimeoutException("Failed to enter the semaphore required for ensuring that AMQP twin sender and receiver links are open.");
}
try
{
string correlationIdSuffix = Guid.NewGuid().ToString();
await Task.WhenAll(
OpenTwinReceiverLinkAsync(amqpIoTSession, correlationIdSuffix, timeout),
OpenTwinSenderLinkAsync(amqpIoTSession, correlationIdSuffix, timeout)
).ConfigureAwait(false);
}
finally
{
_twinLinksSemaphore.Release();
Logging.Exit(this, timeout, nameof(EnableTwinLinksAsync));
}
}
public async Task EnableEventReceiveAsync(TimeSpan timeout)
{
if (_closed)
{
throw new IotHubException("Device is now offline.", false);
}
if (Logging.IsEnabled)
{
Logging.Enter(this, timeout, $"{nameof(EnableEventReceiveAsync)}");
}
AmqpIoTSession amqpIoTSession = await EnsureSessionAsync(timeout).ConfigureAwait(false);
bool gain = await _eventReceivingLinkLock.WaitAsync(timeout).ConfigureAwait(false);
if (!gain)
{
throw new TimeoutException();
}
try
{
if (_eventReceivingLink == null || _eventReceivingLink.IsClosing())
{
_eventReceivingLink?.SafeClose();
_eventReceivingLink = await amqpIoTSession.OpenEventsReceiverLinkAsync(_deviceIdentity, timeout).ConfigureAwait(false);
_eventReceivingLink.Closed += (obj, arg) =>
{
amqpIoTSession.SafeClose();
};
_eventReceivingLink.RegisterEventListener(OnEventsReceived);
if (Logging.IsEnabled)
{
Logging.Associate(this, this, _eventReceivingLink, $"{nameof(EnableEventReceiveAsync)}");
}
}
}
finally
{
_eventReceivingLinkLock.Release();
if (Logging.IsEnabled)
{
Logging.Exit(this, timeout, $"{nameof(EnableEventReceiveAsync)}");
}
}
}
private async Task OpenTwinSenderLinkAsync(AmqpIoTSession amqpIoTSession, string correlationIdSuffix, TimeSpan timeout)
{
if (_twinSendingLink == null || _twinSendingLink.IsClosing())
{
_twinSendingLink = await amqpIoTSession.OpenTwinSenderLinkAsync(_deviceIdentity, correlationIdSuffix, timeout).ConfigureAwait(false);
_twinSendingLink.Closed += (obj, arg) => {
amqpIoTSession.SafeClose();
};
if (Logging.IsEnabled)
{
Logging.Associate(this, _twinSendingLink, $"{nameof(_twinSendingLink)}");
}
}
}
private async Task OpenMethodsSenderLinkAsync(AmqpIoTSession amqpIoTSession, string correlationIdSuffix, TimeSpan timeout)
{
if (_methodSendingLink == null || _methodSendingLink.IsClosing())
{
_methodSendingLink?.SafeClose();
_methodSendingLink = await amqpIoTSession.OpenMethodsSenderLinkAsync(_deviceIdentity, correlationIdSuffix, timeout).ConfigureAwait(false);
_methodSendingLink.Closed += (obj, arg) =>
{
amqpIoTSession.SafeClose();
};
Logging.Associate(this, _methodSendingLink, nameof(_methodSendingLink));
}
}
private async Task OpenMethodsReceiverLinkAsync(AmqpIoTSession amqpIoTSession, string correlationIdSuffix, TimeSpan timeout)
{
if (_methodReceivingLink == null || _methodReceivingLink.IsClosing())
{
_methodReceivingLink = await amqpIoTSession.OpenMethodsReceiverLinkAsync(_deviceIdentity, correlationIdSuffix, timeout).ConfigureAwait(false);
_methodReceivingLink.Closed += (obj, arg) => {
amqpIoTSession.SafeClose();
};
_methodReceivingLink.RegisterMethodListener(OnMethodReceived);
if (Logging.IsEnabled)
{
Logging.Associate(this, _methodReceivingLink, $"{nameof(_methodReceivingLink)}");
}
}
}
private async Task OpenTwinReceiverLinkAsync(AmqpIoTSession amqpIoTSession, string correlationIdSuffix, TimeSpan timeout)
{
if (_twinReceivingLink == null || _twinReceivingLink.IsClosing())
{
_twinReceivingLink?.SafeClose();
_twinReceivingLink = await amqpIoTSession.OpenTwinReceiverLinkAsync(_deviceIdentity, correlationIdSuffix, timeout).ConfigureAwait(false);
_twinReceivingLink.Closed += (obj, arg) =>
{
amqpIoTSession.SafeClose();
};
_twinReceivingLink.RegisterTwinListener(OnDesiredPropertyReceived);
Logging.Associate(this, _twinReceivingLink, nameof(_twinReceivingLink));
}
}
private async Task EnsureMessageReceivingLinkIsOpenAsync(TimeSpan timeout, bool enableCallback = false)
{
if (_closed)
{
throw new IotHubException("Device is now offline.", false);
}
Logging.Enter(this, timeout, nameof(EnsureMessageReceivingLinkIsOpenAsync));
AmqpIoTSession amqpIoTSession = await EnsureSessionIsOpenAsync(timeout).ConfigureAwait(false);
bool enteredSemaphore = await _messageReceivingLinkSemaphore.WaitAsync(timeout).ConfigureAwait(false);
if (!enteredSemaphore)
{
throw new TimeoutException("Failed to enter the semaphore required for ensuring that AMQP message receiver links are open.");
}
try
{
if (_messageReceivingLink == null || _messageReceivingLink.IsClosing())
{
_messageReceivingLink?.SafeClose();
_messageReceivingLink = await amqpIoTSession.OpenMessageReceiverLinkAsync(_deviceIdentity, timeout).ConfigureAwait(false);
_messageReceivingLink.Closed += (obj, arg) =>
{
amqpIoTSession.SafeClose();
};
Logging.Associate(this, this, _messageReceivingLink, nameof(EnsureMessageReceivingLinkIsOpenAsync));
}
if (enableCallback)
{
_messageReceivingLink.RegisterReceiveMessageListener(OnDeviceMessageReceived);
}
}
finally
{
_messageReceivingLinkSemaphore.Release();
Logging.Exit(this, timeout, nameof(EnsureMessageReceivingLinkIsOpenAsync));
}
}
internal async Task EnableTwinLinksAsync(TimeSpan timeout)
{
if (_closed)
{
throw new IotHubException("Device is now offline.", false);
}
if (Logging.IsEnabled)
{
Logging.Enter(this, timeout, $"{nameof(EnableTwinLinksAsync)}");
}
AmqpIoTSession amqpIoTSession = await EnsureSessionAsync(timeout).ConfigureAwait(false);
bool gain = await _twinLinksLock.WaitAsync(timeout).ConfigureAwait(false);
if (!gain)
{
throw new TimeoutException();
}
try
{
string correlationIdSuffix = Guid.NewGuid().ToString();
await Task.WhenAll(
OpenTwinReceiverLinkAsync(amqpIoTSession, correlationIdSuffix, timeout),
OpenTwinSenderLinkAsync(amqpIoTSession, correlationIdSuffix, timeout)
).ConfigureAwait(false);
}
finally
{
_twinLinksLock.Release();
if (Logging.IsEnabled)
{
Logging.Exit(this, timeout, $"{nameof(EnableTwinLinksAsync)}");
}
}
}
internal async Task <AmqpIoTSession> EnsureSessionAsync(TimeSpan timeout)
{
if (_closed)
{
throw new IotHubException("Device is now offline.", false);
}
if (Logging.IsEnabled)
{
Logging.Enter(this, timeout, $"{nameof(EnsureSessionAsync)}");
}
bool gain = await _sessionLock.WaitAsync(timeout).ConfigureAwait(false);
if (!gain)
{
throw new TimeoutException();
}
try
{
if (_amqpIoTSession == null || _amqpIoTSession.IsClosing())
{
_amqpIoTSession = await _amqpConnectionHolder.OpenSessionAsync(_deviceIdentity, timeout).ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Associate(this, _amqpIoTSession, $"{nameof(_amqpIoTSession)}");
}
if (_deviceIdentity.AuthenticationModel == AuthenticationModel.SasIndividual)
{
_amqpAuthenticationRefresher = await _amqpConnectionHolder.CreateRefresherAsync(_deviceIdentity, timeout).ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Associate(this, _amqpAuthenticationRefresher, $"{nameof(_amqpAuthenticationRefresher)}");
}
}
_amqpIoTSession.Closed += OnSessionDisconnected;
_messageSendingLink = await _amqpIoTSession.OpenTelemetrySenderLinkAsync(_deviceIdentity, timeout).ConfigureAwait(false);
_messageSendingLink.Closed += (obj, arg) => {
_amqpIoTSession.SafeClose();
};
if (Logging.IsEnabled)
{
Logging.Associate(this, _messageSendingLink, $"{nameof(_messageSendingLink)}");
}
}
if (_disposed)
{
_amqpAuthenticationRefresher?.StopLoop();
_amqpIoTSession.SafeClose();
if (!_deviceIdentity.IsPooling())
{
_amqpConnectionHolder.Dispose();
}
throw new IotHubException("Device is now offline.", false);
}
}
finally
{
_sessionLock.Release();
}
if (Logging.IsEnabled)
{
Logging.Exit(this, timeout, $"{nameof(EnsureSessionAsync)}");
}
return(_amqpIoTSession);
}
public async Task OpenAsync(TimeSpan timeout)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, timeout, $"{nameof(OpenAsync)}");
}
try
{
Debug.Assert(_amqpIoTSession == null);
Debug.Assert(IsUsable());
_amqpIoTSession = await _amqpSessionCreator.CreateSession(
_deviceIdentity,
timeout).ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Associate(this, _amqpIoTSession, $"{nameof(_amqpIoTSession)}");
}
await _amqpIoTSession.OpenAsync(timeout).ConfigureAwait(false);
if (_deviceIdentity.AuthenticationModel == AuthenticationModel.SasIndividual)
{
_amqpAuthenticationRefresher = await _amqpAuthenticationRefresherCreator.CreateRefresher(_deviceIdentity, timeout).ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Associate(this, _amqpAuthenticationRefresher, $"{nameof(_amqpAuthenticationRefresher)}");
}
}
_amqpIoTSession.Closed += OnSessionDisconnected;
_messageSendingLink = await _amqpIoTSession.OpenTelemetrySenderLinkAsync(
_deviceIdentity,
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)}");
}
}
}
internal async Task <AmqpIoTSession> EnsureSessionIsOpenAsync(TimeSpan timeout)
{
if (_closed)
{
throw new IotHubException("Device is now offline.", false);
}
Logging.Enter(this, timeout, nameof(EnsureSessionIsOpenAsync));
bool enteredSemaphore = await _sessionSemaphore.WaitAsync(timeout).ConfigureAwait(false);
if (!enteredSemaphore)
{
throw new TimeoutException("Failed to enter the semaphore required for opening an AMQP session.");
}
try
{
if (_amqpIoTSession == null || _amqpIoTSession.IsClosing())
{
_amqpIoTSession?.SafeClose();
_amqpIoTSession = await _amqpConnectionHolder.OpenSessionAsync(_deviceIdentity, timeout).ConfigureAwait(false);
Logging.Associate(this, _amqpIoTSession, nameof(_amqpIoTSession));
if (_deviceIdentity.AuthenticationModel == AuthenticationModel.SasIndividual)
{
_amqpAuthenticationRefresher = await _amqpConnectionHolder.CreateRefresherAsync(_deviceIdentity, timeout).ConfigureAwait(false);
Logging.Associate(this, _amqpAuthenticationRefresher, nameof(_amqpAuthenticationRefresher));
}
_amqpIoTSession.Closed += OnSessionDisconnected;
_messageSendingLink = await _amqpIoTSession.OpenTelemetrySenderLinkAsync(_deviceIdentity, timeout).ConfigureAwait(false);
_messageSendingLink.Closed += (obj, arg) =>
{
_amqpIoTSession.SafeClose();
};
Logging.Associate(this, _messageSendingLink, nameof(_messageSendingLink));
}
if (_disposed)
{
throw new IotHubException("Device is now offline.", false);
}
}
catch (Exception)
{
Cleanup();
throw;
}
finally
{
_sessionSemaphore.Release();
}
Logging.Exit(this, timeout, nameof(EnsureSessionIsOpenAsync));
return(_amqpIoTSession);
}
