public override async Task DisableMethodsAsync(CancellationToken cancellationToken) { #if WIP_C2D_METHODS_AMQP Task receivingLinkCloseTask; this.SafeAddClosedSendingLinkHandler = (o, ea) => {}; this.SafeAddClosedReceivingLinkHandler = (o, ea) => {}; if (this.faultTolerantMethodReceivingLink != null) { receivingLinkCloseTask = this.faultTolerantMethodReceivingLink.CloseAsync(); this.faultTolerantMethodReceivingLink = null; } else { receivingLinkCloseTask = TaskHelpers.CompletedTask; } Task sendingLinkCloseTask; if (this.faultTolerantMethodSendingLink != null) { sendingLinkCloseTask = this.faultTolerantMethodSendingLink.CloseAsync(); this.faultTolerantMethodSendingLink = null; } else { sendingLinkCloseTask = TaskHelpers.CompletedTask; } await Task.WhenAll(receivingLinkCloseTask, sendingLinkCloseTask); #else throw new NotImplementedException(); #endif }
public override Task RecoverConnections(object link, ConnectionType connectionType, CancellationToken cancellationToken) { Func <Task> enableLinkAsyncFunc = null; object newlink = null; switch (connectionType) { case ConnectionType.AmqpMethodReceiving: this.faultTolerantMethodReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateMethodReceivingLinkAsync, this.IotHubConnection.CloseLink); enableLinkAsyncFunc = async() => await EnableMethodReceivingLinkAsync(cancellationToken); newlink = this.faultTolerantMethodReceivingLink; break; case ConnectionType.AmqpTwinReceiving: this.faultTolerantTwinReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateTwinReceivingLinkAsync, this.IotHubConnection.CloseLink); enableLinkAsyncFunc = async() => await EnableTwinReceivingLinkAsync(cancellationToken); newlink = this.faultTolerantTwinReceivingLink; break; case ConnectionType.AmqpMethodSending: this.faultTolerantMethodSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateMethodSendingLinkAsync, this.IotHubConnection.CloseLink); enableLinkAsyncFunc = async() => await EnableMethodSendingLinkAsync(cancellationToken); newlink = this.faultTolerantMethodSendingLink; break; case ConnectionType.AmqpTwinSending: this.faultTolerantTwinSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateTwinSendingLinkAsync, this.IotHubConnection.CloseLink); enableLinkAsyncFunc = async() => await EnableTwinSendingLinkAsync(cancellationToken); newlink = this.faultTolerantTwinSendingLink; break; default: return(Common.TaskConstants.Completed); } return(this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await enableLinkAsyncFunc(); this.linkOpenedListener( newlink, new ConnectionEventArgs { ConnectionType = connectionType, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken)); }
public override Task EnableMethodsAsync(CancellationToken cancellationToken) { #if WIP_C2D_METHODS_AMQP if (this.faultTolerantMethodSendingLink == null) { this.faultTolerantMethodSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateMethodSendingLinkAsync, this.IotHubConnection.CloseLink); } if (this.faultTolerantMethodReceivingLink == null) { this.faultTolerantMethodReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateMethodReceivingLinkAsync, this.IotHubConnection.CloseLink); } return(this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await Task.WhenAll(EnableSendingLinkAsync(cancellationToken), EnableReceivingLinkAsync(cancellationToken)); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken)); #else throw new NotImplementedException(); #endif }
public AmqpTransportHandler(IotHubConnectionString connectionString, AmqpTransportSettings transportSettings) { this.transportType = transportSettings.GetTransportType(); switch (this.transportType) { case TransportType.Amqp_Tcp_Only: this.IotHubConnection = tcpConnectionCache.GetConnection(connectionString, transportSettings); break; case TransportType.Amqp_WebSocket_Only: this.IotHubConnection = wsConnectionCache.GetConnection(connectionString, transportSettings); break; default: throw new InvalidOperationException("Invalid Transport Type {0}".FormatInvariant(this.transportType)); } this.deviceId = connectionString.DeviceId; this.openTimeout = IotHubConnection.DefaultOpenTimeout; this.operationTimeout = IotHubConnection.DefaultOperationTimeout; this.DefaultReceiveTimeout = IotHubConnection.DefaultOperationTimeout; this.faultTolerantEventSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateEventSendingLinkAsync, this.IotHubConnection.CloseLink); this.faultTolerantDeviceBoundReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateDeviceBoundReceivingLinkAsync, this.IotHubConnection.CloseLink); this.prefetchCount = transportSettings.PrefetchCount; }
internal AmqpTransportHandler( IPipelineContext context, IotHubConnectionString connectionString, AmqpTransportSettings transportSettings, Action <object, EventArgs> onLinkClosedCallback, Func <MethodRequestInternal, Task> onMethodCallback = null) : base(context, transportSettings) { this.linkClosedListener = onLinkClosedCallback; TransportType transportType = transportSettings.GetTransportType(); this.deviceId = connectionString.DeviceId; switch (transportType) { case TransportType.Amqp_Tcp_Only: this.IotHubConnection = TcpConnectionCache.GetConnection(connectionString, transportSettings); break; case TransportType.Amqp_WebSocket_Only: this.IotHubConnection = WsConnectionCache.GetConnection(connectionString, transportSettings); break; default: throw new InvalidOperationException("Invalid Transport Type {0}".FormatInvariant(transportType)); } this.openTimeout = transportSettings.OpenTimeout; this.operationTimeout = transportSettings.OperationTimeout; this.prefetchCount = transportSettings.PrefetchCount; this.faultTolerantEventSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateEventSendingLinkAsync, this.IotHubConnection.CloseLink); this.faultTolerantDeviceBoundReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateDeviceBoundReceivingLinkAsync, this.IotHubConnection.CloseLink); this.iotHubConnectionString = connectionString; this.messageListener = onMethodCallback; }
public AmqpTransportHandler(IotHubConnectionString connectionString, AmqpTransportSettings transportSettings) { this.IotHubConnection = connectionCache.GetConnection(connectionString, transportSettings); this.deviceId = connectionString.DeviceId; this.openTimeout = IotHubConnection.DefaultOpenTimeout; this.operationTimeout = IotHubConnection.DefaultOperationTimeout; this.DefaultReceiveTimeout = IotHubConnection.DefaultOperationTimeout; this.faultTolerantEventSendingLink = new Client.FaultTolerantAmqpObject<SendingAmqpLink>(this.CreateEventSendingLinkAsync, this.IotHubConnection.CloseLink); this.faultTolerantDeviceBoundReceivingLink = new Client.FaultTolerantAmqpObject<ReceivingAmqpLink>(this.CreateDeviceBoundReceivingLinkAsync, this.IotHubConnection.CloseLink); this.prefetchCount = transportSettings.PrefetchCount; }
public AmqpTransportHandler(IotHubConnectionString connectionString, AmqpTransportSettings transportSettings) { this.IotHubConnection = connectionCache.GetConnection(connectionString, transportSettings); this.deviceId = connectionString.DeviceId; this.openTimeout = IotHubConnection.DefaultOpenTimeout; this.operationTimeout = IotHubConnection.DefaultOperationTimeout; this.DefaultReceiveTimeout = IotHubConnection.DefaultOperationTimeout; this.faultTolerantEventSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateEventSendingLinkAsync, this.IotHubConnection.CloseLink); this.faultTolerantDeviceBoundReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateDeviceBoundReceivingLinkAsync, this.IotHubConnection.CloseLink); this.prefetchCount = transportSettings.PrefetchCount; }
internal AmqpTransportHandler( IPipelineContext context, IotHubConnectionString connectionString, AmqpTransportSettings transportSettings, Func <MethodRequestInternal, Task> onMethodCallback = null, Action <TwinCollection> onDesiredStatePatchReceived = null, Func <string, Message, Task> onEventReceivedCallback = null) : base(context, transportSettings) { this.productInfo = context.Get <ProductInfo>(); TransportType transportType = transportSettings.GetTransportType(); this.deviceId = connectionString.DeviceId; this.moduleId = connectionString.ModuleId; if (!transportSettings.AmqpConnectionPoolSettings.Pooling) { this.IotHubConnection = new IotHubSingleTokenConnection(null, connectionString, transportSettings); } else { switch (transportType) { case TransportType.Amqp_Tcp_Only: this.IotHubConnection = TcpConnectionCache.GetConnection(connectionString, transportSettings); break; case TransportType.Amqp_WebSocket_Only: this.IotHubConnection = WsConnectionCache.GetConnection(connectionString, transportSettings); break; default: throw new InvalidOperationException("Invalid Transport Type {0}".FormatInvariant(transportType)); } } this.IotHubConnection.OnConnectionClose += OnAmqpConnectionClose; this.openTimeout = transportSettings.OpenTimeout; this.operationTimeout = transportSettings.OperationTimeout; this.prefetchCount = transportSettings.PrefetchCount; this.faultTolerantEventSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateEventSendingLinkAsync, OnAmqpLinkClose); this.faultTolerantDeviceBoundReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateDeviceBoundReceivingLinkAsync, OnAmqpLinkClose); this.iotHubConnectionString = connectionString; this.methodReceivedListener = onMethodCallback; this.onDesiredStatePatchListener = onDesiredStatePatchReceived; this.eventReceivedListener = onEventReceivedCallback; }
public override Task RecoverConnections(object link, CancellationToken cancellationToken) { Func <Task> enableMethodLinkAsyncFunc = null; var amqpLink = link as AmqpLink; if (amqpLink == null) { return(Common.TaskConstants.Completed); } if (amqpLink.IsReceiver) { this.faultTolerantMethodReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateMethodReceivingLinkAsync, this.IotHubConnection.CloseLink); enableMethodLinkAsyncFunc = async() => await EnableMethodReceivingLinkAsync(cancellationToken); } else { this.faultTolerantMethodSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateMethodSendingLinkAsync, this.IotHubConnection.CloseLink); enableMethodLinkAsyncFunc = async() => await EnableMethodSendingLinkAsync(cancellationToken); } return(this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await enableMethodLinkAsyncFunc(); this.linkOpenedListener( this.faultTolerantMethodSendingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpMethodSending, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); this.linkOpenedListener( this.faultTolerantMethodReceivingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpMethodReceiving, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken)); }
public override async Task EnableTwinPatchAsync(CancellationToken cancellationToken) { try { if (Logging.IsEnabled) { Logging.Enter(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(EnableTwinPatchAsync)}"); } cancellationToken.ThrowIfCancellationRequested(); if (this.faultTolerantTwinSendingLink == null) { this.faultTolerantTwinSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateTwinSendingLinkAsync, OnAmqpLinkClose); } if (this.faultTolerantTwinReceivingLink == null) { this.faultTolerantTwinReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateTwinReceivingLinkAsync, OnAmqpLinkClose); } try { if (this.onDesiredStatePatchListener != null) { await Task.WhenAll(EnableTwinSendingLinkAsync(cancellationToken), EnableTwinReceivingLinkAsync(cancellationToken)).ConfigureAwait(false); // generate new guid for reconnection twinConnectionCorrelationId = Guid.NewGuid().ToString("N"); } } catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException)) { throw AmqpClientHelper.ToIotHubClientContract(exception); } } finally { if (Logging.IsEnabled) { Logging.Exit(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(EnableTwinPatchAsync)}"); } } }
public override async Task RecoverConnections(object link, ConnectionType connectionType, CancellationToken cancellationToken) { bool needMethodRecovery = false; bool needTwinRecovery = false; await recoverySemaphore.WaitAsync(); // disconnected link belongs to the current sets if (((connectionType == ConnectionType.AmqpMethodSending) && ((link as SendingAmqpLink).Name == methodSendingLinkName)) || ((connectionType == ConnectionType.AmqpMethodReceiving) && ((link as ReceivingAmqpLink).Name == methodReceivingLinkName))) { methodSendingLinkName = null; methodReceivingLinkName = null; needMethodRecovery = true; } if (((connectionType == ConnectionType.AmqpTwinSending) && ((link as SendingAmqpLink).Name == twinSendingLinkName)) || ((connectionType == ConnectionType.AmqpTwinReceiving) && ((link as ReceivingAmqpLink).Name == twinReceivingLinkName))) { twinSendingLinkName = null; twinReceivingLinkName = null; needTwinRecovery = true; } recoverySemaphore.Release(1); if (needMethodRecovery) { this.faultTolerantMethodSendingLink = null; this.faultTolerantMethodReceivingLink = null; await this.EnableMethodsAsync(cancellationToken); } if (needTwinRecovery) { this.faultTolerantTwinSendingLink = null; this.faultTolerantTwinReceivingLink = null; await this.EnableTwinPatchAsync(cancellationToken); } }
public async Task DisableTwinAsync(CancellationToken cancellationToken) { try { if (Logging.IsEnabled) { Logging.Enter(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(DisableTwinAsync)}"); } cancellationToken.ThrowIfCancellationRequested(); Task receivingLinkCloseTask; if (this.faultTolerantTwinReceivingLink != null) { receivingLinkCloseTask = this.faultTolerantTwinReceivingLink.CloseAsync(cancellationToken); this.faultTolerantTwinReceivingLink = null; } else { receivingLinkCloseTask = TaskHelpers.CompletedTask; } Task sendingLinkCloseTask; if (this.faultTolerantTwinSendingLink != null) { sendingLinkCloseTask = this.faultTolerantTwinSendingLink.CloseAsync(cancellationToken); this.faultTolerantTwinSendingLink = null; } else { sendingLinkCloseTask = TaskHelpers.CompletedTask; } await Task.WhenAll(receivingLinkCloseTask, sendingLinkCloseTask).ConfigureAwait(false); } finally { if (Logging.IsEnabled) { Logging.Exit(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(DisableTwinAsync)}"); } } }
public async Task DisableTwinAsync(CancellationToken cancellationToken) { Task receivingLinkCloseTask; this.SafeAddClosedTwinSendingLinkHandler = (o, ea) => {}; this.SafeAddClosedTwinReceivingLinkHandler = (o, ea) => {}; if (this.faultTolerantTwinReceivingLink != null) { receivingLinkCloseTask = this.faultTolerantTwinReceivingLink.CloseAsync(); this.faultTolerantTwinReceivingLink = null; } else { receivingLinkCloseTask = TaskHelpers.CompletedTask; } Task sendingLinkCloseTask; if (this.faultTolerantTwinSendingLink != null) { sendingLinkCloseTask = this.faultTolerantTwinSendingLink.CloseAsync(); this.faultTolerantTwinSendingLink = null; } else { sendingLinkCloseTask = TaskHelpers.CompletedTask; } await Task.WhenAll(receivingLinkCloseTask, sendingLinkCloseTask); this.linkClosedListener( this.faultTolerantTwinSendingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpTwinSending, ConnectionStatus = ConnectionStatus.Disabled, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Client_Close }); this.linkClosedListener( this.faultTolerantTwinReceivingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpTwinReceiving, ConnectionStatus = ConnectionStatus.Disabled, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Client_Close }); }
public async Task DisableTwinAsync(CancellationToken cancellationToken) { #if WIP_C2D_METHODS_AMQP Task receivingLinkCloseTask; this.SafeAddClosedTwinSendingLinkHandler = (o, ea) => {}; this.SafeAddClosedTwinReceivingLinkHandler = (o, ea) => {}; if (this.faultTolerantTwinReceivingLink != null) { receivingLinkCloseTask = this.faultTolerantTwinReceivingLink.CloseAsync(); this.faultTolerantTwinReceivingLink = null; } else { receivingLinkCloseTask = TaskHelpers.CompletedTask; } Task sendingLinkCloseTask; if (this.faultTolerantTwinSendingLink != null) { sendingLinkCloseTask = this.faultTolerantTwinSendingLink.CloseAsync(); this.faultTolerantTwinSendingLink = null; } else { sendingLinkCloseTask = TaskHelpers.CompletedTask; } await Task.WhenAll(receivingLinkCloseTask, sendingLinkCloseTask); this.linkClosedListener(this.faultTolerantTwinSendingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpTwinSending, ConnectionStatus = ConnectionStatus.Disabled }); this.linkClosedListener(this.faultTolerantTwinReceivingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpTwinReceiving, ConnectionStatus = ConnectionStatus.Disabled }); #else throw new NotImplementedException(); #endif }
public override Task RecoverConnections(object link, CancellationToken cancellationToken) { #if WIP_C2D_METHODS_AMQP Func <Task> enableMethodLinkAsyncFunc = null; var amqpLink = link as AmqpLink; if (amqpLink == null) { return(Common.TaskConstants.Completed); } if (amqpLink.IsReceiver) { this.faultTolerantMethodReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateMethodReceivingLinkAsync, this.IotHubConnection.CloseLink); enableMethodLinkAsyncFunc = async() => await EnableReceivingLinkAsync(cancellationToken); } else { this.faultTolerantMethodSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateMethodSendingLinkAsync, this.IotHubConnection.CloseLink); enableMethodLinkAsyncFunc = async() => await EnableSendingLinkAsync(cancellationToken); } return(this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await enableMethodLinkAsyncFunc(); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken)); #else throw new NotImplementedException(); #endif }
public override async Task DisableMethodsAsync(CancellationToken cancellationToken) { Task receivingLinkCloseTask; this.SafeAddClosedMethodSendingLinkHandler = (o, ea) => { return(TaskHelpers.CompletedTask); }; this.SafeAddClosedMethodReceivingLinkHandler = (o, ea) => { return(TaskHelpers.CompletedTask); }; if (this.faultTolerantMethodReceivingLink != null) { receivingLinkCloseTask = this.faultTolerantMethodReceivingLink.CloseAsync(); this.faultTolerantMethodReceivingLink = null; } else { receivingLinkCloseTask = TaskHelpers.CompletedTask; } Task sendingLinkCloseTask; if (this.faultTolerantMethodSendingLink != null) { sendingLinkCloseTask = this.faultTolerantMethodSendingLink.CloseAsync(); this.faultTolerantMethodSendingLink = null; } else { sendingLinkCloseTask = TaskHelpers.CompletedTask; } await Task.WhenAll(receivingLinkCloseTask, sendingLinkCloseTask); await this.linkClosedListener( this.faultTolerantMethodSendingLink, new ConnectionEventArgs { ConnectionType = ConnectionType.AmqpMethodSending, ConnectionStatus = ConnectionStatus.Disabled, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Client_Close }); await this.linkClosedListener( this.faultTolerantMethodReceivingLink, new ConnectionEventArgs { ConnectionType = ConnectionType.AmqpMethodReceiving, ConnectionStatus = ConnectionStatus.Disabled, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Client_Close }); }
public override async Task EnableTwinPatchAsync(CancellationToken cancellationToken) { if (this.faultTolerantTwinSendingLink == null) { this.faultTolerantTwinSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateTwinSendingLinkAsync, this.IotHubConnection.CloseLink); } if (this.faultTolerantTwinReceivingLink == null) { this.faultTolerantTwinReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateTwinReceivingLinkAsync, this.IotHubConnection.CloseLink); } await this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await Task.WhenAll(EnableTwinSendingLinkAsync(cancellationToken), EnableTwinReceivingLinkAsync(cancellationToken)); this.linkOpenedListener( this.faultTolerantTwinSendingLink, new ConnectionEventArgs { ConnectionType = ConnectionType.AmqpTwinSending, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); this.linkOpenedListener( this.faultTolerantTwinReceivingLink, new ConnectionEventArgs { ConnectionType = ConnectionType.AmqpTwinReceiving, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); // generate new guid for reconnection twinConnectionCorrelationId = Guid.NewGuid().ToString("N"); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken); }
public AmqpTransportHandler(IotHubConnectionString connectionString, AmqpTransportSettings transportSettings) { this.transportType = transportSettings.GetTransportType(); switch (this.transportType) { case TransportType.Amqp_Tcp_Only: this.IotHubConnection = tcpConnectionCache.GetConnection(connectionString, transportSettings); break; case TransportType.Amqp_WebSocket_Only: this.IotHubConnection = wsConnectionCache.GetConnection(connectionString, transportSettings); break; default: throw new InvalidOperationException("Invalid Transport Type {0}".FormatInvariant(this.transportType)); } this.deviceId = connectionString.DeviceId; this.openTimeout = IotHubConnection.DefaultOpenTimeout; this.operationTimeout = IotHubConnection.DefaultOperationTimeout; this.DefaultReceiveTimeout = IotHubConnection.DefaultOperationTimeout; this.faultTolerantEventSendingLink = new Client.FaultTolerantAmqpObject<SendingAmqpLink>(this.CreateEventSendingLinkAsync, this.IotHubConnection.CloseLink); this.faultTolerantDeviceBoundReceivingLink = new Client.FaultTolerantAmqpObject<ReceivingAmqpLink>(this.CreateDeviceBoundReceivingLinkAsync, this.IotHubConnection.CloseLink); this.prefetchCount = transportSettings.PrefetchCount; }
public override async Task EnableMethodsAsync(CancellationToken cancellationToken) { if (this.faultTolerantMethodSendingLink == null) { this.faultTolerantMethodSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateMethodSendingLinkAsync, this.IotHubConnection.CloseLink); } if (this.faultTolerantMethodReceivingLink == null) { this.faultTolerantMethodReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateMethodReceivingLinkAsync, this.IotHubConnection.CloseLink); } await this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await Task.WhenAll(EnableMethodSendingLinkAsync(cancellationToken), EnableMethodReceivingLinkAsync(cancellationToken)); this.linkOpenedListener( this.faultTolerantMethodSendingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpMethodSending, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); this.linkOpenedListener( this.faultTolerantMethodReceivingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpMethodReceiving, ConnectionStatus = ConnectionStatus.Connected, ConnectionStatusChangeReason = ConnectionStatusChangeReason.Connection_Ok }); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken); }
public override async Task EnableTwinPatchAsync(CancellationToken cancellationToken) { #if WIP_C2D_METHODS_AMQP if (this.faultTolerantTwinSendingLink == null) { this.faultTolerantTwinSendingLink = new Client.FaultTolerantAmqpObject <SendingAmqpLink>(this.CreateTwinSendingLinkAsync, this.IotHubConnection.CloseLink); } if (this.faultTolerantTwinReceivingLink == null) { this.faultTolerantTwinReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateTwinReceivingLinkAsync, this.IotHubConnection.CloseLink); } await this.HandleTimeoutCancellation(async() => { try { if (this.messageListener != null) { await Task.WhenAll(EnableTwinSendingLinkAsync(cancellationToken), EnableTwinReceivingLinkAsync(cancellationToken)); this.linkOpenedListener(this.faultTolerantTwinSendingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpTwinSending, ConnectionStatus = ConnectionStatus.Connected }); this.linkOpenedListener(this.faultTolerantTwinReceivingLink, new ConnectionEventArgs { ConnectionKey = ConnectionKeys.AmqpTwinReceiving, ConnectionStatus = ConnectionStatus.Connected }); } } catch (Exception ex) when(!ex.IsFatal()) { throw AmqpClientHelper.ToIotHubClientContract(ex); } }, cancellationToken); #else throw new NotImplementedException(); #endif }
public override async Task EnableEventReceiveAsync(CancellationToken cancellationToken) { try { if (Logging.IsEnabled) { Logging.Enter(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(EnableEventReceiveAsync)}"); } cancellationToken.ThrowIfCancellationRequested(); if (this.faultTolerantEventReceivingLink == null) { this.faultTolerantEventReceivingLink = new Client.FaultTolerantAmqpObject <ReceivingAmqpLink>(this.CreateEventReceivingLinkAsync, OnAmqpLinkClose); } try { if (this.eventReceivedListener != null) { await this.faultTolerantEventReceivingLink.OpenAsync(this.openTimeout, cancellationToken).ConfigureAwait(false); } } catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException)) { throw AmqpClientHelper.ToIotHubClientContract(exception); } } finally { if (Logging.IsEnabled) { Logging.Exit(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(EnableEventReceiveAsync)}"); } } }