public override async Task OpenAsync(bool explicitOpen, CancellationToken cancellationToken)
{
if (!explicitOpen)
{
return;
}
await this.HandleTimeoutCancellation(async() =>
{
try
{
await Task.WhenAll(
this.faultTolerantEventSendingLink.OpenAsync(this.openTimeout, cancellationToken),
this.faultTolerantDeviceBoundReceivingLink.OpenAsync(this.openTimeout, cancellationToken));
this.linkOpenedListener(this.faultTolerantEventSendingLink, new ConnectionEventArgs {
ConnectionKey = ConnectionKeys.AmqpTelemetry, ConnectionStatus = ConnectionStatus.Connected
});
this.linkOpenedListener(this.faultTolerantDeviceBoundReceivingLink, new ConnectionEventArgs {
ConnectionKey = ConnectionKeys.AmqpMessaging, ConnectionStatus = ConnectionStatus.Connected
});
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
}, 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 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 async Task <Twin> SendTwinGetAsync(CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(SendTwinGetAsync)}");
}
try
{
await EnableTwinPatchAsync(cancellationToken).ConfigureAwait(false);
AmqpMessage amqpMessage = AmqpMessage.Create();
amqpMessage.MessageAnnotations.Map["operation"] = "GET";
var response = await RoundTripTwinMessage(amqpMessage, cancellationToken).ConfigureAwait(false);
return(TwinFromResponse(response));
}
catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException))
{
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(SendTwinGetAsync)}");
}
}
}
public override async Task <Twin> SendTwinGetAsync(CancellationToken cancellationToken)
{
Outcome outcome;
try
{
await EnableTwinAsync(cancellationToken);
SendingAmqpLink eventSendingLink = await this.GetTwinSendingLinkAsync(cancellationToken);
// This is test code and will be re-written in future commits
AmqpMessage getTwinMessage = AmqpMessage.Create();
string getCorrelationId = Guid.NewGuid().ToString();
getTwinMessage.Properties.CorrelationId = getCorrelationId;
getTwinMessage.MessageAnnotations.Map["operation"] = "GET";
outcome = await eventSendingLink.SendMessageAsync(getTwinMessage, new ArraySegment <byte>(Guid.NewGuid().ToByteArray()), AmqpConstants.NullBinary, this.operationTimeout);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
return(null);
}
public override async Task SendTwinPatchAsync(TwinCollection reportedProperties, CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, reportedProperties, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(SendTwinPatchAsync)}");
}
try
{
await EnableTwinPatchAsync(cancellationToken).ConfigureAwait(false);
var body = JsonConvert.SerializeObject(reportedProperties);
var bodyStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(body));
var amqpMessage = AmqpMessage.Create(bodyStream, true);
amqpMessage.MessageAnnotations.Map["operation"] = "PATCH";
amqpMessage.MessageAnnotations.Map["resource"] = "/properties/reported";
amqpMessage.MessageAnnotations.Map["version"] = null;
var response = await RoundTripTwinMessage(amqpMessage, cancellationToken).ConfigureAwait(false);
VerifyResponseMessage(response);
}
catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException))
{
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(this, reportedProperties, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(SendTwinPatchAsync)}");
}
}
}
async Task <Outcome> SendAmqpMethodResponseAsync(AmqpMessage amqpMessage, CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, amqpMessage, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(SendAmqpMethodResponseAsync)}");
}
Outcome outcome;
try
{
SendingAmqpLink methodRespSendingLink = await this.GetMethodSendingLinkAsync(cancellationToken).ConfigureAwait(false);
outcome = await methodRespSendingLink.SendMessageAsync(amqpMessage, new ArraySegment <byte>(Guid.NewGuid().ToByteArray()), AmqpConstants.NullBinary, this.operationTimeout).ConfigureAwait(false);
}
catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException))
{
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(this, amqpMessage, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(SendAmqpMethodResponseAsync)}");
}
}
return(outcome);
}
public override async Task SendTwinPatchAsync(TwinCollection reportedProperties, CancellationToken cancellationToken)
{
try
{
await EnableTwinPatchAsync(cancellationToken);
var body = JsonConvert.SerializeObject(reportedProperties);
var bodyStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(body));
var amqpMessage = AmqpMessage.Create(bodyStream, true);
amqpMessage.MessageAnnotations.Map["operation"] = "PATCH";
amqpMessage.MessageAnnotations.Map["resource"] = "/properties/reported";
amqpMessage.MessageAnnotations.Map["version"] = null;
await RoundTripTwinMessage(amqpMessage, cancellationToken);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
}
public override async Task <Message> ReceiveAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
Message message = null;
AmqpMessage amqpMessage;
try
{
ReceivingAmqpLink deviceBoundReceivingLink = await this.GetDeviceBoundReceivingLinkAsync(cancellationToken).ConfigureAwait(false);
amqpMessage = await deviceBoundReceivingLink.ReceiveMessageAsync(timeout).ConfigureAwait(false);
}
catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException))
{
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
if (amqpMessage != null)
{
message = new Message(amqpMessage)
{
LockToken = new Guid(amqpMessage.DeliveryTag.Array).ToString()
};
}
else
{
message = null;
}
return(message);
}
public override async Task OpenAsync(bool explicitOpen, CancellationToken cancellationToken)
{
if (!explicitOpen)
{
return;
}
await this.HandleTimeoutCancellation(async() =>
{
try
{
await Task.WhenAll(
this.faultTolerantEventSendingLink.OpenAsync(this.openTimeout, cancellationToken),
this.faultTolerantDeviceBoundReceivingLink.OpenAsync(this.openTimeout, cancellationToken));
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
}, cancellationToken);
}
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)}");
}
}
}
async Task DisposeMessageAsync(string lockToken, Outcome outcome, CancellationToken cancellationToken)
{
ArraySegment <byte> deliveryTag = IotHubConnection.ConvertToDeliveryTag(lockToken);
Outcome disposeOutcome;
try
{
// Currently, the same mechanism is used for sending feedback for C2D messages and events received by modules.
// However, devices only support C2D messages (they cannot receive events), and modules only support receiving events
// (they cannot receive C2D messages). So we use this to distinguish whether to dispose the message (i.e. send outcome on)
// the DeviceBoundReceivingLink or the EventsReceivingLink.
// If this changes (i.e. modules are able to receive C2D messages, or devices are able to receive telemetry), this logic
// will have to be updated.
ReceivingAmqpLink deviceBoundReceivingLink = !string.IsNullOrWhiteSpace(this.moduleId)
? await this.GetEventReceivingLinkAsync(cancellationToken).ConfigureAwait(false)
: await this.GetDeviceBoundReceivingLinkAsync(cancellationToken).ConfigureAwait(false);
disposeOutcome = await deviceBoundReceivingLink.DisposeMessageAsync(deliveryTag, outcome, batchable : true, timeout : this.operationTimeout).ConfigureAwait(false);
}
catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException))
{
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
if (disposeOutcome.DescriptorCode != Accepted.Code)
{
if (disposeOutcome.DescriptorCode == Rejected.Code)
{
var rejected = (Rejected)disposeOutcome;
// Special treatment for NotFound amqp rejected error code in case of DisposeMessage
if (rejected.Error != null && rejected.Error.Condition.Equals(AmqpErrorCode.NotFound))
{
throw new DeviceMessageLockLostException(rejected.Error.Description);
}
}
throw AmqpErrorMapper.GetExceptionFromOutcome(disposeOutcome);
}
}
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 OpenAsync(CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(OpenAsync)}");
}
try
{
cancellationToken.ThrowIfCancellationRequested();
await this.faultTolerantEventSendingLink.OpenAsync(this.openTimeout, cancellationToken).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(this.moduleId))
{
await this.faultTolerantDeviceBoundReceivingLink.OpenAsync(this.openTimeout, cancellationToken).ConfigureAwait(false);
}
}
catch (Exception exception) when(!exception.IsFatal() && !(exception is OperationCanceledException))
{
Exception newException = AmqpClientHelper.ToIotHubClientContract(exception);
if (newException != exception)
{
throw newException;
}
else
{
// Maintain the original stack.
throw;
}
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(this, cancellationToken, $"{nameof(AmqpTransportHandler)}.{nameof(OpenAsync)}");
}
}
}
async Task <Outcome> SendAmqpMessageAsync(AmqpMessage amqpMessage)
{
Outcome outcome;
try
{
SendingAmqpLink eventSendingLink = await this.GetEventSendingLinkAsync();
outcome = await eventSendingLink.SendMessageAsync(amqpMessage, IotHubConnection.GetNextDeliveryTag(ref this.eventsDeliveryTag), AmqpConstants.NullBinary, this.OperationTimeout);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
return(outcome);
}
async Task <Outcome> SendAmqpMethodResponseAsync(AmqpMessage amqpMessage, CancellationToken cancellationToken)
{
Outcome outcome;
try
{
SendingAmqpLink methodRespSendingLink = await this.GetMethodSendingLinkAsync(cancellationToken);
outcome = await methodRespSendingLink.SendMessageAsync(amqpMessage, new ArraySegment <byte>(Guid.NewGuid().ToByteArray()), AmqpConstants.NullBinary, this.operationTimeout);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
return(outcome);
}
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);
}
async Task DisposeMessageAsync(string lockToken, Outcome outcome)
{
var deliveryTag = IotHubConnection.ConvertToDeliveryTag(lockToken);
Outcome disposeOutcome;
try
{
ReceivingAmqpLink deviceBoundReceivingLink = await this.GetDeviceBoundReceivingLinkAsync();
disposeOutcome = await deviceBoundReceivingLink.DisposeMessageAsync(deliveryTag, outcome, batchable : true, timeout : this.OperationTimeout);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
if (disposeOutcome.DescriptorCode != Accepted.Code)
{
if (disposeOutcome.DescriptorCode == Rejected.Code)
{
var rejected = (Rejected)disposeOutcome;
// Special treatment for NotFound amqp rejected error code in case of DisposeMessage
if (rejected.Error != null && rejected.Error.Condition.Equals(AmqpErrorCode.NotFound))
{
throw new DeviceMessageLockLostException(rejected.Error.Description);
}
}
throw AmqpErrorMapper.GetExceptionFromOutcome(disposeOutcome);
}
}
protected override async Task OnOpenAsync(bool explicitOpen)
{
if (!explicitOpen)
{
return;
}
try
{
await Task.WhenAll(
this.faultTolerantEventSendingLink.OpenAsync(this.OpenTimeout),
this.faultTolerantDeviceBoundReceivingLink.OpenAsync(this.OpenTimeout));
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
}
public override async Task <Twin> SendTwinGetAsync(CancellationToken cancellationToken)
{
try
{
await EnableTwinPatchAsync(cancellationToken);
AmqpMessage amqpMessage = AmqpMessage.Create();
amqpMessage.MessageAnnotations.Map["operation"] = "GET";
var response = await RoundTripTwinMessage(amqpMessage, cancellationToken);
return(TwinFromResponse(response));
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
}
public override async Task <Message> ReceiveAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
Message message = null;
await this.HandleTimeoutCancellation(async() =>
{
AmqpMessage amqpMessage;
try
{
ReceivingAmqpLink deviceBoundReceivingLink = await this.GetDeviceBoundReceivingLinkAsync(cancellationToken);
amqpMessage = await deviceBoundReceivingLink.ReceiveMessageAsync(timeout);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
if (amqpMessage != null)
{
message = new Message(amqpMessage)
{
LockToken = new Guid(amqpMessage.DeliveryTag.Array).ToString()
};
}
else
{
message = null;
}
}, cancellationToken);
return(message);
}
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
}
protected async override Task <Message> OnReceiveAsync(TimeSpan timeout)
{
AmqpMessage amqpMessage;
try
{
ReceivingAmqpLink deviceBoundReceivingLink = await this.GetDeviceBoundReceivingLinkAsync();
amqpMessage = await deviceBoundReceivingLink.ReceiveMessageAsync(timeout);
}
catch (Exception exception)
{
if (exception.IsFatal())
{
throw;
}
throw AmqpClientHelper.ToIotHubClientContract(exception);
}
Message message;
if (amqpMessage != null)
{
message = new Message(amqpMessage)
{
LockToken = new Guid(amqpMessage.DeliveryTag.Array).ToString()
};
}
else
{
message = null;
}
return(message);
}
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)}");
}
}
}