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)}");
}
}
}
