public async Task EnableEventReceiveAsync(TimeSpan timeout) { if (Logging.IsEnabled) { Logging.Enter(this, timeout, $"{nameof(EnableEventReceiveAsync)}"); } try { Debug.Assert(_eventReceivingLink == null); _eventReceivingLink = await _amqpIoTSession.OpenEventsReceiverLinkAsync( _deviceIdentity, timeout ).ConfigureAwait(false); _eventReceivingLink.RegisterEventListener(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 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 <AmqpIoTReceivingLink> receiveLinkCreator = _amqpIoTSession.OpenMethodsReceiverLinkAsync(_deviceIdentity, correlationIdSuffix, timeout); Task <AmqpIoTSendingLink> sendingLinkCreator = _amqpIoTSession.OpenMethodsSenderLinkAsync(_deviceIdentity, correlationIdSuffix, timeout); await Task.WhenAll(receiveLinkCreator, sendingLinkCreator).ConfigureAwait(false); _methodReceivingLink = receiveLinkCreator.Result; _methodSendingLink = sendingLinkCreator.Result; _methodReceivingLink.RegisterMethodListener(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 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 OpenTwinReceiverLinkAsync(AmqpIoTSession amqpIoTSession, string correlationIdSuffix, TimeSpan timeout) { if (_twinReceivingLink == null || _twinReceivingLink.IsClosing()) { _twinReceivingLink = await amqpIoTSession.OpenTwinReceiverLinkAsync(_deviceIdentity, correlationIdSuffix, timeout).ConfigureAwait(false); _twinReceivingLink.Closed += (obj, arg) => { amqpIoTSession.SafeClose(); }; _twinReceivingLink.RegisterTwinListener(OnDesiredPropertyReceived); if (Logging.IsEnabled) { Logging.Associate(this, _twinReceivingLink, $"{nameof(_twinReceivingLink)}"); } } }
private async Task OpenMethodsReceiverLinkAsync(AmqpIoTSession amqpIoTSession, string correlationIdSuffix, TimeSpan timeout) { if (_methodReceivingLink == null || _methodReceivingLink.IsClosing()) { _methodReceivingLink?.SafeClose(); _methodReceivingLink = await amqpIoTSession.OpenMethodsReceiverLinkAsync(_deviceIdentity, correlationIdSuffix, timeout).ConfigureAwait(false); _methodReceivingLink.Closed += (obj, arg) => { amqpIoTSession.SafeClose(); }; _methodReceivingLink.RegisterMethodListener(OnMethodReceived); Logging.Associate(this, _methodReceivingLink, nameof(_methodReceivingLink)); } }
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)); } }
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 _amqpIoTSession.OpenTelemetryReceiverLinkAsync( _deviceIdentity, 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 DisableTwinLinksAsync(TimeSpan timeout) { Logging.Enter(this, timeout, nameof(DisableTwinLinksAsync)); Debug.Assert(_twinSendingLink != null); Debug.Assert(_twinReceivingLink != null); 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 closed."); } try { ICollection <Task> tasks = new List <Task>(); if (_twinReceivingLink != null) { tasks.Add(_twinReceivingLink.CloseAsync(timeout)); } if (_twinSendingLink != null) { tasks.Add(_twinSendingLink.CloseAsync(timeout)); } if (tasks.Count > 0) { await Task.WhenAll(tasks).ConfigureAwait(false); _twinReceivingLink = null; _twinSendingLink = null; } } finally { Logging.Exit(this, timeout, nameof(DisableTwinLinksAsync)); _twinLinksSemaphore.Release(); } }
public async Task DisableMethodsAsync(TimeSpan timeout) { if (Logging.IsEnabled) { Logging.Enter(this, timeout, $"{nameof(DisableMethodsAsync)}"); } Debug.Assert(_methodSendingLink != null); Debug.Assert(_methodReceivingLink != null); try { ICollection <Task> tasks = new List <Task>(); if (_methodReceivingLink != null) { tasks.Add(_methodReceivingLink.CloseAsync(timeout)); } if (_methodSendingLink != null) { tasks.Add(_methodSendingLink.CloseAsync(timeout)); } if (tasks.Count > 0) { await Task.WhenAll(tasks).ConfigureAwait(false); _methodReceivingLink = null; _methodSendingLink = null; } } finally { if (Logging.IsEnabled) { Logging.Exit(this, timeout, $"{nameof(DisableMethodsAsync)}"); } } }
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 <AmqpIoTReceivingLink> receiveLinkCreator = _amqpIoTSession.OpenTwinReceiverLinkAsync(_deviceIdentity, correlationIdSuffix, timeout); Task <AmqpIoTSendingLink> sendingLinkCreator = _amqpIoTSession.OpenTwinSenderLinkAsync(_deviceIdentity, correlationIdSuffix, timeout); await Task.WhenAll(receiveLinkCreator, sendingLinkCreator).ConfigureAwait(false); _twinSendingLink = sendingLinkCreator.Result; _twinSendingLink.Closed += OnLinkDisconnected; _twinReceivingLink = receiveLinkCreator.Result; _twinReceivingLink.RegisterTwinListener(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)}"); } } }