public AquariumsController(IAccountService accountService, IAquariumService aquariumService, IDeviceClient deviceService, ILogger <DeviceController> logger)
{
_accountService = accountService;
_aquariumService = aquariumService;
_deviceService = deviceService;
_logger = logger;
}
async void CloseIotHubConnection()
{
if (!this.ConnectedToHub)
{
// closure happened before IoT Hub connection was established or it was initiated due to disconnect
return;
}
try
{
this.publishProcessor.Complete();
this.publishPubAckProcessor.Complete();
this.publishPubRecProcessor.Complete();
this.pubRelPubCompProcessor.Complete();
await Task.WhenAll(
this.publishProcessor.Completion,
this.publishPubAckProcessor.Completion,
this.publishPubRecProcessor.Completion,
this.pubRelPubCompProcessor.Completion);
IDeviceClient hub = this.iotHubClient;
this.iotHubClient = null;
await hub.DisposeAsync();
}
catch (Exception ex)
{
MqttIotHubAdapterEventSource.Log.Info("Failed to close IoT Hub Client cleanly.", ex.ToString());
}
}
public BugController(IAquariumService aquariumService, IAccountService accountService, IDeviceClient deviceService, ILogger <DeviceController> logger, IEmailerService emailerService)
{
_accountService = accountService;
_emailerService = emailerService;
_aquariumService = aquariumService;
_deviceService = deviceService;
_logger = logger;
}
public AdministrativeService(IConfiguration config, IAquariumDao aquariumDao, IDeviceClient deviceService, ILogger <AdministrativeService> logger, IPhotoManager photoManager)
{
_config = config;
_aquariumDao = aquariumDao;
_logger = logger;
_deviceService = deviceService;
_photoManager = photoManager;
}
private static async Task SendTelemetrySendDeviceToCloud(IDeviceClient deviceClient, string messagebody)
{
var msg = new Message(Encoding.UTF8.GetBytes(messagebody));
msg.Properties.Add("message-type", "Fleet");
msg.Properties.Add("device-type", "Terminal");
msg.Properties.Add("message-class", "telemetry");
await deviceClient.SendEventAsync(msg);
}
public DeviceInteractionController(IAquariumService aquariumService, IDeviceClient deviceService,
IAccountService accountService,
INotificationService notificationService,
ILogger <DeviceInteractionController> logger)
{
_aquariumService = aquariumService;
_deviceService = deviceService;
_accountService = accountService;
_notificationService = notificationService;
_logger = logger;
}
public KioskDevice(KioskDeviceConfig deviceConfig, IDeviceClient client, IEventScheduler eventScheduler) : base(deviceConfig, client, eventScheduler)
{
this.deviceConfig = deviceConfig;
this.TicketStockCount = deviceConfig.InitialStockCount;
// set up any simulated events for this device
this._EventScheduler.Add(new TimedSimulatedEvent(5000, 2500, this.SendPurchaseTicketMessageToCloud));
// register any direct methods we're to recieve
this._DeviceClient.RegisterDirectMethodAsync(ReceivePurchaseTicketResponse).Wait();
}
public DeviceRegistrator(ILogger log, IDeviceClient deviceClient, Func <string, IFlurlRequest> registerDeviceRequest,
string deviceId, IEnumerable <IDeviceBoundMethodHandler> methodHandlers = null,
IEnumerable <TimeSpan> retryIntervals = null)
{
_deviceClient = deviceClient;
_registerDeviceRequest = registerDeviceRequest;
_log = log.ForContext <DeviceRegistrator>();
_deviceId = deviceId;
_macAddress = MacAddressAccessor.GetMacAddress();
_methodHandlers = methodHandlers;
_retryIntervals = retryIntervals ?? Enumerable.Range(0, 10).Select(i => TimeSpan.FromSeconds(i * 3));
}
public AquariumService(IConfiguration config, ILogger <AquariumService> logger, IAquariumDao aquariumDao, IAccountService accountService,
IActivityService activityService, IDeviceClient deviceClient, IPhotoManager photoManager, INotificationService notificationService)
{
_config = config;
_activityService = activityService;
_accountService = accountService;
_aquariumDao = aquariumDao;
_logger = logger;
_deviceClient = deviceClient;
_photoManager = photoManager;
_notificationService = notificationService;
}
public BaseDevice(IDeviceConfig deviceConfig, IDeviceClient client, IEventScheduler eventScheduler)
{
if (deviceConfig == null || client == null || eventScheduler == null)
{
throw new ArgumentNullException("one or more parameters are null. All parameters must be provided");
}
this._EventScheduler = eventScheduler;
this._DeviceClient = client; // Connect to the IoT hub using the MQTT protocol
this._deviceConfig = deviceConfig; // save for later
this.deviceId = deviceConfig.DeviceId;
this.deviceType = deviceConfig.DeviceType;
// device status is set during initialization
}
static async Task SendAlert(IDeviceClient deviceClient)
{
var messageBody = new
{
value = "ReceiptLowPaper",
time = "9/1/2020 8:30:00 AM +01:00"
};
var messageBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageBody));
var message = new Message(messageBytes);
message.Properties.Add("device-type", "Terminal");
message.Properties.Add("message-type", "ReceiptLowPaper");
message.Properties.Add("message-class", "alert");
await deviceClient.SendEventAsync(message);
}
private static async Task BroadcastDeviceRegistration(IDeviceClient deviceClient, string macAddress, IEnumerable <TimeSpan> retryIntervals, ILogger log)
{
var policy = Policy <bool>
.HandleResult(false)
.WaitAndRetryAsync(
retryIntervals,
(res, time) => log.Warning("BroadcastDeviceRegistration failed on attempt at {Interval} (Success={Result}).", time, res.Result));
var result = await policy.ExecuteAsync(async() =>
{
try
{
log.Information("Sending device-registration message with mac address: {@macAddress}", macAddress);
var message = new Message()
.WithProperties(
("message-type", "device-registration"));
if (!string.IsNullOrWhiteSpace(macAddress))
{
message.Properties.Add("mac-address", macAddress);
message.Properties.Add("device-details", "Fleet Service Engine is the gateway for transferring FSC telematry data to Fleed application.");
await deviceClient.SendEventAsync(message, CancellationToken.None);
log.Information("Device-registration message sent successfully.");
return(true);
}
return(false);
}
catch (Exception ex)
{
log.Error(ex, "Failed to send device-registration message.");
return(false);
}
});
if (result)
{
log.Information("Send device-registration - Success.");
}
else
{
log.Warning("Send device-registration - Fail.");
}
}
private async Task UpdateTwinAsync(Device device, IDeviceClient client, CancellationToken token)
{
// Generate some properties using the device model specs
device.SetReportedProperty("Protocol", this.deviceModel.Protocol.ToString());
device.SetReportedProperty("SupportedMethods", string.Join(",", this.deviceModel.CloudToDeviceMethods.Keys));
device.SetReportedProperty("Telemetry", this.deviceModel.GetTelemetryReportedProperty(this.log));
// Copy all the properties defined in the device model specs
foreach (KeyValuePair <string, object> p in this.deviceModel.Properties)
{
device.SetReportedProperty(p.Key, new JValue(p.Value));
}
await client.UpdateTwinAsync(device);
this.log.Debug("Simulated device properties updated", () => { });
}
public AccountController(IConfiguration config,
IAquariumService aquariumService,
IDeviceClient deviceService,
IAccountService accountService,
INotificationService notificationService,
ILogger <AccountController> logger,
IPhotoManager photoManager
)
{
_config = config;
_aquariumService = aquariumService;
_accountService = accountService;
_notificationService = notificationService;
_logger = logger;
_photoManager = photoManager;
}
static async Task PublishTelemetryManifest(IDeviceClient client, CancellationToken cancel)
{
try
{
logger.LogInformation("Publishing telemetry manifest to IoT Hub.");
var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configuration", "manifest.json");
var content = File.ReadAllText(path);
var minifyContent = Regex.Replace(content, @"\s", "");
await client.SendEventAsync(
new Message(Encoding.UTF8.GetBytes(minifyContent))
.WithProperties(("message-type", "manifest")));
}
catch (Exception ex)
{
logger.LogError(ex.Message, "Failed to publish telemetry manifest.");
}
}
public async Task OpenConnectionAsync(IDeviceClient deviceClient, IClientWebSocket clientWebSocket, ITcpClient tcpClient, CancellationTokenSource cancellationTokenSource)
{
DeviceStreamRequest streamRequest = await deviceClient.WaitForDeviceStreamRequestAsync(cancellationTokenSource.Token).ConfigureAwait(false);
if (streamRequest != null)
{
await deviceClient.AcceptDeviceStreamRequestAsync(streamRequest, cancellationTokenSource.Token).ConfigureAwait(false);
Console.WriteLine($"Device stream accepted from IoT Hub, at {DateTime.UtcNow}");
clientWebSocket.Options.SetRequestHeader("Authorization", $"Bearer {streamRequest.AuthorizationToken}");
await clientWebSocket.ConnectAsync(streamRequest.Url, cancellationTokenSource.Token).ConfigureAwait(false);
Console.WriteLine($"Device stream connected to IoT Hub, at {DateTime.UtcNow}");
await tcpClient.ConnectAsync(this.HostName, this.Port).ConfigureAwait(false);
Console.WriteLine($"Device stream connected to local endpoint, at {DateTime.UtcNow}");
using (var localStream = tcpClient.GetStream())
{
await Task.WhenAny(
this.HandleIncomingDataAsync(clientWebSocket, localStream, cancellationTokenSource.Token),
this.HandleOutgoingDataAsync(clientWebSocket, localStream, cancellationTokenSource.Token)
).ConfigureAwait(false);
localStream.Close();
Console.WriteLine($"Device stream closed to local endpoint, at {DateTime.UtcNow}");
}
await clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationTokenSource.Token).ConfigureAwait(false);
}
else
{
await deviceClient.RejectDeviceStreamRequestAsync(streamRequest, cancellationTokenSource.Token).ConfigureAwait(false);
}
}
async void ShutdownOnReceiveError(IChannelHandlerContext context, string exception)
{
this.publishPubAckProcessor.Abort();
this.publishProcessor.Abort();
this.publishPubRecProcessor.Abort();
this.pubRelPubCompProcessor.Abort();
IDeviceClient hub = this.iotHubClient;
if (hub != null)
{
this.iotHubClient = null;
try
{
await hub.DisposeAsync();
}
catch (Exception ex)
{
MqttIotHubAdapterEventSource.Log.Info("Failed to close IoT Hub Client cleanly.", ex.ToString());
}
}
ShutdownOnError(context, "Receive", exception);
}
/// <summary>
/// Device class constructor, calls base constructor and starts loading device values.
/// Accepts a device config, client, and event scheduler. The later 2 are externalized to make
/// unit testing of the device easier.
/// </summary>
public GateReaderDevice(GateReaderDeviceConfig deviceConfig, IDeviceClient client, IEventScheduler eventScheduler)
: base(deviceConfig, client, eventScheduler)
{
// save device configuration
this.deviceConfig = deviceConfig;
}
public SnapshotController(IConfiguration config, IActivityService activityService, IAquariumService aquariumService, IDeviceClient deviceService, ILogger <SnapshotController> logger, IPhotoManager photoManager)
{
_config = config;
_aquariumService = aquariumService;
_activityService = activityService;
_logger = logger;
_photoManager = photoManager;
}
/// <summary>
/// Performs complete initialization of <see cref="MqttIotHubAdapter" /> based on received CONNECT packet.
/// </summary>
/// <param name="context"><see cref="IChannelHandlerContext" /> instance.</param>
/// <param name="packet">CONNECT packet.</param>
async void Connect(IChannelHandlerContext context, ConnectPacket packet)
{
bool connAckSent = false;
Exception exception = null;
try
{
if (!this.IsInState(StateFlags.WaitingForConnect))
{
ShutdownOnError(context, "CONNECT has been received in current session already. Only one CONNECT is expected per session.");
return;
}
this.stateFlags = StateFlags.ProcessingConnect;
AuthenticationResult authResult = await this.authProvider.AuthenticateAsync(packet.ClientId,
packet.Username, packet.Password, context.Channel.RemoteAddress);
if (!authResult.IsSuccessful)
{
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedNotAuthorized
});
PerformanceCounters.ConnectionFailedAuthPerSecond.Increment();
ShutdownOnError(context, "Authentication failed.");
return;
}
this.deviceId = authResult.DeviceId;
this.iotHubClient = await this.deviceClientFactory(authResult);
bool sessionPresent = await this.EstablishSessionStateAsync(this.deviceId, packet.CleanSession);
this.keepAliveTimeout = this.DeriveKeepAliveTimeout(packet);
if (packet.HasWill)
{
var will = new PublishPacket(packet.WillQualityOfService, false, packet.WillRetain);
will.TopicName = packet.WillTopicName;
will.Payload = packet.WillMessage;
this.willPacket = will;
}
this.sessionContext = new Dictionary<string, string>
{
{ DeviceIdParam, this.deviceId }
};
this.StartReceiving(context);
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
SessionPresent = sessionPresent,
ReturnCode = ConnectReturnCode.Accepted
});
this.CompleteConnect(context);
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
if (!connAckSent)
{
try
{
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedServerUnavailable
});
}
catch (Exception ex)
{
if (MqttIotHubAdapterEventSource.Log.IsVerboseEnabled)
{
MqttIotHubAdapterEventSource.Log.Verbose("Error sending 'Server Unavailable' CONNACK.", ex.ToString());
}
}
}
ShutdownOnError(context, "CONNECT", exception);
}
}
async void ShutdownOnReceiveError(IChannelHandlerContext context, string exception)
{
this.publishPubAckProcessor.Abort();
this.publishProcessor.Abort();
this.publishPubRecProcessor.Abort();
this.pubRelPubCompProcessor.Abort();
IDeviceClient hub = this.iotHubClient;
if (hub != null)
{
this.iotHubClient = null;
try
{
await hub.DisposeAsync();
}
catch (Exception ex)
{
MqttIotHubAdapterEventSource.Log.Info("Failed to close IoT Hub Client cleanly.", ex.ToString());
}
}
ShutdownOnError(context, "Receive", exception);
}
/// <summary>
/// Performs complete initialization of <see cref="MqttIotHubAdapter" /> based on received CONNECT packet.
/// </summary>
/// <param name="context"><see cref="IChannelHandlerContext" /> instance.</param>
/// <param name="packet">CONNECT packet.</param>
async void Connect(IChannelHandlerContext context, ConnectPacket packet)
{
bool connAckSent = false;
Exception exception = null;
try
{
if (!this.IsInState(StateFlags.WaitingForConnect))
{
ShutdownOnError(context, "CONNECT has been received in current session already. Only one CONNECT is expected per session.");
return;
}
this.stateFlags = StateFlags.ProcessingConnect;
AuthenticationResult authResult = await this.authProvider.AuthenticateAsync(packet.ClientId,
packet.Username, packet.Password, context.Channel.RemoteAddress);
if (authResult == null)
{
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedNotAuthorized
});
PerformanceCounters.ConnectionFailedAuthPerSecond.Increment();
ShutdownOnError(context, "Authentication failed.");
return;
}
this.identity = authResult.Identity;
this.iotHubClient = await this.deviceClientFactory(authResult);
bool sessionPresent = await this.EstablishSessionStateAsync(this.identity.ToString(), packet.CleanSession);
this.keepAliveTimeout = this.DeriveKeepAliveTimeout(packet);
if (packet.HasWill)
{
var will = new PublishPacket(packet.WillQualityOfService, false, packet.WillRetain);
will.TopicName = packet.WillTopicName;
will.Payload = packet.WillMessage;
this.willPacket = will;
}
this.sessionContext = new Dictionary <string, string>
{
{ DeviceIdParam, this.identity.DeviceId }
};
this.StartReceiving(context);
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
SessionPresent = sessionPresent,
ReturnCode = ConnectReturnCode.Accepted
});
this.CompleteConnect(context);
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
if (!connAckSent)
{
try
{
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedServerUnavailable
});
}
catch (Exception ex)
{
if (MqttIotHubAdapterEventSource.Log.IsVerboseEnabled)
{
MqttIotHubAdapterEventSource.Log.Verbose("Error sending 'Server Unavailable' CONNACK.", ex.ToString());
}
}
}
ShutdownOnError(context, "CONNECT", exception);
}
}
public async Task OpenDeviceConnectionAsync(IStreamingDevice streamingDevice, IDeviceClient deviceClient, IClientWebSocket webSocket, ITcpClient tcpClient, CancellationTokenSource cts)
{
// Run a virtual device
await streamingDevice.OpenConnectionAsync(deviceClient, webSocket, tcpClient, cts).ConfigureAwait(false);
}
public UpdateReportedPropertiesCommand(IDeviceClient deviceClient)
{
_deviceClient = deviceClient;
}
public QueuedReceiverDeviceClient(string deviceId, IDeviceClient deviceClient)
{
this.deviceId = deviceId ?? throw new ArgumentNullException(nameof(deviceId));
this.deviceClient = deviceClient ?? throw new System.ArgumentNullException(nameof(deviceClient));
this.receiveAsyncLock = new SemaphoreSlim(1, 1);
}
public async Task Start(CancellationToken cts)
{
var correlationId = Guid.NewGuid().ToString();
IDeviceClient deviceClient = null;
var stopwatch = Stopwatch.StartNew();
try
{
deviceClient = CreateDeviceClient();
deviceClient.SetConnectionStatusChangesHandler(OnConnectionStatusChanged);
deviceClient.OperationTimeoutInMilliseconds = deviceRunnerConfiguration.DeviceOperationTimeoutInMilliseconds;
if (deviceRunnerConfiguration.DeviceRetryPolicy)
{
deviceClient.SetRetryPolicy(new ExponentialBackoff(10, TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(10), TimeSpan.FromMilliseconds(500)));
}
else
{
deviceClient.SetRetryPolicy(new NoRetry());
}
await deviceClient.OpenAsync();
stopwatch.Stop();
Logger.Log($"{deviceId}: deviceClient created: {stopwatch.ElapsedMilliseconds}ms (retryPolicy={deviceRunnerConfiguration.DeviceRetryPolicy}, operationTimeoutInMilliseconds={deviceClient.OperationTimeoutInMilliseconds})");
}
catch (Exception ex)
{
Logger.Log($"{deviceId}: deviceClient creation failed: {ex.Message}");
return;
}
var number = 0;
var maxMsTwinUpdate = 0L;
var numSlowTwin = 0;
long maxMsC2D = 0;
int numSlowC2D = 0;
long maxMsSendEvent = 0;
int numSlowSendEvent = 0;
while (!cts.IsCancellationRequested)
{
number++;
// Update Device Twin with increasing "Number"
if (this.deviceRunnerConfiguration.UpdateTwin)
{
try
{
var reportedProperties = new TwinCollection();
reportedProperties["Number"] = $"{correlationId}-{number}";
stopwatch.Restart();
Logger.Log($"{deviceId}: begin twins update {number}.");
await deviceClient.UpdateReportedPropertiesAsync(reportedProperties);
stopwatch.Stop();
if (maxMsTwinUpdate < stopwatch.ElapsedMilliseconds)
{
maxMsTwinUpdate = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds > 4000)
{
numSlowTwin++;
}
Logger.Log($"{deviceId}: twins updated {number}: {stopwatch.ElapsedMilliseconds}ms. Max: {maxMsTwinUpdate}ms. Delays: {numSlowTwin}");
}
catch (IotHubCommunicationException iotHubCommunicationException)
{
Logger.Log($"{deviceId}: iothub problem, waiting {deviceRunnerConfiguration.DelayAfterIotHubCommunicationError}ms. {iotHubCommunicationException.Message}");
await Task.Delay(deviceRunnerConfiguration.DelayAfterIotHubCommunicationError);
}
catch (Exception ex)
{
Logger.Log($"{deviceId}: failed to get update twin. {ex.Message}");
}
}
if (this.deviceRunnerConfiguration.SendEvent)
{
try
{
var message = new Message(Encoding.UTF8.GetBytes($"{correlationId}-{number}"));
message.CorrelationId = correlationId;
message.ContentType = "application/json";
stopwatch.Restart();
Logger.Log($"{deviceId}: begin send event {number}.");
await deviceClient.SendEventAsync(message);
stopwatch.Stop();
if (maxMsSendEvent < stopwatch.ElapsedMilliseconds)
{
maxMsSendEvent = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds > 4000)
{
numSlowSendEvent++;
}
Logger.Log($"{deviceId}: send event {number}: {stopwatch.ElapsedMilliseconds}ms. Max: {maxMsSendEvent}ms. Delays: {numSlowSendEvent}");
}
catch (IotHubCommunicationException iotHubCommunicationException)
{
Logger.Log($"{deviceId}: iothub problem, waiting {deviceRunnerConfiguration.DelayAfterIotHubCommunicationError}ms. {iotHubCommunicationException.Message}");
await Task.Delay(deviceRunnerConfiguration.DelayAfterIotHubCommunicationError);
}
catch (Exception ex)
{
Logger.Log($"{deviceId}: failed to send event. {ex.Message}");
}
}
if (this.deviceRunnerConfiguration.CloudToDeviceMessage)
{
try
{
// Check Cloud-to-Device Message
Logger.Log($"{deviceId}: checking c2d message");
stopwatch.Restart();
Message c2dMsg = await deviceClient.ReceiveAsync(TimeSpan.FromMilliseconds(500));
stopwatch.Stop();
if (maxMsC2D < stopwatch.ElapsedMilliseconds)
{
maxMsC2D = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds > 4000)
{
numSlowC2D++;
}
Logger.Log($"{deviceId}: done checking c2d message: {stopwatch.ElapsedMilliseconds}ms. Max: {maxMsC2D}ms. Delays: {numSlowC2D}");
if (c2dMsg != null)
{
var c2dMsgBody = c2dMsg.GetBodyAsText();
Logger.Log($"{deviceId}: c2d message received '{c2dMsgBody}'");
if (deviceRunnerConfiguration.CheckPendingCloudToDeviceMessage)
{
stopwatch.Restart();
var pendingMessage = await deviceClient.ReceiveAsync(TimeSpan.FromMilliseconds(200));
stopwatch.Stop();
if (maxMsC2D < stopwatch.ElapsedMilliseconds)
{
maxMsC2D = stopwatch.ElapsedMilliseconds;
}
if (stopwatch.ElapsedMilliseconds > 4000)
{
numSlowC2D++;
}
Logger.Log($"{deviceId}: done checking pending c2d message: {stopwatch.ElapsedMilliseconds}ms. Max: {maxMsC2D}ms. Delays: {numSlowC2D}");
if (pendingMessage != null)
{
var pendingMessageBody = pendingMessage.GetBodyAsText();
Logger.Log($"{deviceId}: abandoning c2d message '{pendingMessageBody}'");
await deviceClient.AbandonAsync(pendingMessage);
Logger.Log($"{deviceId}: done abandoning c2d message '{pendingMessageBody}'");
}
}
if (deviceRunnerConfiguration.CompleteCloudToDeviceMessage)
{
Logger.Log($"{deviceId}: completing c2d message '{c2dMsgBody}'");
await deviceClient.CompleteAsync(c2dMsg);
Logger.Log($"{deviceId}: done completing c2d message '{c2dMsgBody}'");
}
}
else
{
Logger.Log($"{deviceId}: no c2d message received");
}
}
catch (IotHubCommunicationException iotHubCommunicationException)
{
Logger.Log($"{deviceId}: iothub problem, waiting {deviceRunnerConfiguration.DelayAfterIotHubCommunicationError}ms. {iotHubCommunicationException.Message}");
await Task.Delay(deviceRunnerConfiguration.DelayAfterIotHubCommunicationError);
}
catch (Exception ex)
{
Logger.Log($"{deviceId}: failed to handle cloud to device message. {ex.Message}");
}
}
await Task.Delay(this.deviceRunnerConfiguration.DeviceLoopDelay);
}
}
public SendEventCommand(IDeviceClient deviceClient)
{
_deviceClient = deviceClient;
}
async void CloseIotHubConnection()
{
if (!this.ConnectedToHub)
{
// closure happened before IoT Hub connection was established or it was initiated due to disconnect
return;
}
try
{
this.publishProcessor.Complete();
this.publishPubAckProcessor.Complete();
this.publishPubRecProcessor.Complete();
this.pubRelPubCompProcessor.Complete();
await Task.WhenAll(
this.publishProcessor.Completion,
this.publishPubAckProcessor.Completion,
this.publishPubRecProcessor.Completion,
this.pubRelPubCompProcessor.Completion);
IDeviceClient hub = this.iotHubClient;
this.iotHubClient = null;
await hub.DisposeAsync();
}
catch (Exception ex)
{
MqttIotHubAdapterEventSource.Log.Info("Failed to close IoT Hub Client cleanly.", ex.ToString());
}
}
