protected Details( string iothubConnectionString, string eventhubCompatibleEndpointWithEntityPath, string deviceId, string certificateFileName, string edgeHostName, bool useWebSockets ) { this.iothubConnectionString = iothubConnectionString; this.eventhubCompatibleEndpointWithEntityPath = eventhubCompatibleEndpointWithEntityPath; this.deviceId = deviceId; this.certificateFileName = certificateFileName; this.edgeHostName = edgeHostName; if (useWebSockets) { this.serviceClientTransportType = ServiceClientTransportType.Amqp_WebSocket_Only; this.eventHubClientTransportType = EventHubClientTransportType.AmqpWebSockets; this.deviceClientTransportType = DeviceClientTransportType.Mqtt_WebSocket_Only; } else { this.serviceClientTransportType = ServiceClientTransportType.Amqp; this.eventHubClientTransportType = EventHubClientTransportType.Amqp; this.deviceClientTransportType = DeviceClientTransportType.Mqtt; } }
static async Task <int> MainAsync() { Logger.LogInformation("DirectMethodCloudSender Main() started."); IConfiguration configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("config/appsettings.json", optional: true) .AddEnvironmentVariables() .Build(); string serviceClientConnectionString = Preconditions.CheckNonWhiteSpace(configuration.GetValue <string>("ServiceClientConnectionString"), "ServiceClientConnectionString"); // Get device id of this device, exposed as a system variable by the iot edge runtime string targetDeviceId = configuration.GetValue <string>("IOTEDGE_DEVICEID"); string targetModuleId = configuration.GetValue("TargetModuleId", "DirectMethodReceiver"); TransportType transportType = configuration.GetValue("ClientTransportType", TransportType.Amqp_Tcp_Only); TimeSpan dmDelay = configuration.GetValue("DirectMethodDelay", TimeSpan.FromSeconds(5)); (CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), null); await CallDirectMethodFromCloud(serviceClientConnectionString, targetDeviceId, targetModuleId, transportType, dmDelay, cts); completed.Set(); handler.ForEach(h => GC.KeepAlive(h)); Logger.LogInformation("DirectMethodCloudSender Main() finished."); return(0); }
private static ITransportSettings CreateTransportSettingsFromName(Microsoft.Azure.Devices.Client.TransportType transportType, string proxyAddress) { switch (transportType) { case Microsoft.Azure.Devices.Client.TransportType.Http1: return(new Http1TransportSettings { Proxy = proxyAddress == null ? null : new WebProxy(proxyAddress), }); case Microsoft.Azure.Devices.Client.TransportType.Amqp: case Microsoft.Azure.Devices.Client.TransportType.Amqp_Tcp_Only: return(new AmqpTransportSettings(TransportType.Amqp_Tcp_Only)); // Overriding as per error message if using Amqp only case Microsoft.Azure.Devices.Client.TransportType.Amqp_WebSocket_Only: return(new AmqpTransportSettings(transportType) { Proxy = proxyAddress == null ? null : new WebProxy(proxyAddress), }); case Microsoft.Azure.Devices.Client.TransportType.Mqtt: case Microsoft.Azure.Devices.Client.TransportType.Mqtt_Tcp_Only: return(new MqttTransportSettings(TransportType.Mqtt_Tcp_Only)); // Overriding as per error message if using Mqtt only case Microsoft.Azure.Devices.Client.TransportType.Mqtt_WebSocket_Only: return(new MqttTransportSettings(transportType) { Proxy = proxyAddress == null ? null : new WebProxy(proxyAddress), }); } throw new NotSupportedException($"Unknown transport: '{transportType}'."); }
public static DeviceClient CreateSelfSignedDevice(TransportType transport, string deviceId) { Console.Write("Connecting to hub.... "); var registryManager = RegistryManager.CreateFromConnectionString(hubConnStr); Console.WriteLine("done"); Console.Write("Creating device with self signed key.... "); var certificate = GetSelfSigned(); var device = new Microsoft.Azure.Devices.Device(deviceId) { Authentication = new AuthenticationMechanism { X509Thumbprint = new X509Thumbprint { PrimaryThumbprint = certificate.Thumbprint } } }; var createdDevice = registryManager.AddDeviceAsync(device).Result; Console.WriteLine($"done. Id='{deviceId}', X509Thumbprint = '{createdDevice.Authentication.X509Thumbprint.PrimaryThumbprint}'"); Console.Write("Connecting to device... "); var auth = new DeviceAuthenticationWithX509Certificate(deviceId, certificate); var client = DeviceClient.Create(hubUrl, auth, transport); Console.WriteLine("done"); return(client); }
public static DeviceClient CreateClient(TransportType transport, string deviceId) { Console.WriteLine("Connecting to IoT Hub with certificate:"); var certificate = GetSelfSigned(); DeviceAuthenticationWithX509Certificate auth = new DeviceAuthenticationWithX509Certificate(deviceId, certificate); Console.WriteLine($"----------\n{auth.Certificate}----------"); DeviceClient client = DeviceClient.Create(hubUrl, auth, transport); return(client); }
public async Task DisposeAsync() { string deviceConnectionString = Environment.GetEnvironmentVariable("IoTHubDeviceConnectionString"); Microsoft.Azure.Devices.Client.TransportType transportType = Microsoft.Azure.Devices.Client.TransportType.Mqtt; using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transportType)) { // purge messaging services output.WriteLine("Purging Service Bus messages"); PurgeServiceBusMessagesAsync(workOrderQueueClient, output); PurgeServiceBusMessagesAsync(createAlertErrorQueueClient, output); PurgeServiceBusMessagesAsync(createAlertTopicSubscriptionClient, output); output.WriteLine("Purging IoT Hub messages"); await PurgeIoTHubMessagesAsync(deviceClient); // find the case (title property is equal to alertid) output.WriteLine("Deleting Dynamics entities"); QueryExpression caseQueryExpression = FindEntityWithPropertyValue("incident", "title", uniqueFaultName); EntityCollection caseQueryExpressionResult = this.cdsServiceClient.RetrieveMultiple(caseQueryExpression); if (caseQueryExpressionResult != null && caseQueryExpressionResult.Entities.Count > 0) { Entity retrievedCase = caseQueryExpressionResult.Entities[0]; this.cdsServiceClient.Delete("incident", retrievedCase.Id); output.WriteLine($"Deleted incident entity with id {retrievedCase.Id}"); } // find the work order (msdyn_workordersummary property is equal to alertid) associated with the alert QueryExpression workOrderQueryExpression = FindEntityWithPropertyValue("msdyn_workorder", "msdyn_workordersummary", uniqueFaultName, true); EntityCollection workOrderQueryExpressionResult = this.cdsServiceClient.RetrieveMultiple(workOrderQueryExpression); if (workOrderQueryExpressionResult != null && workOrderQueryExpressionResult.Entities.Count > 0) { // find the resource requirement attached to work order Entity retrievedWorkOrder = workOrderQueryExpressionResult.Entities[0]; string workOrderName = (string)retrievedWorkOrder["msdyn_name"]; QueryExpression resourceRequirementExpression = FindEntityWithPropertyValue("msdyn_resourcerequirement", "msdyn_name", workOrderName); EntityCollection resourceRequirementExpressionResult = this.cdsServiceClient.RetrieveMultiple(resourceRequirementExpression); if (resourceRequirementExpressionResult != null && resourceRequirementExpressionResult.Entities.Count > 0) { Entity retrievedResourceRequirement = resourceRequirementExpressionResult.Entities[0]; this.cdsServiceClient.Delete("msdyn_resourcerequirement", retrievedResourceRequirement.Id); output.WriteLine($"Deleted msdyn_resourcerequirement entity with id {retrievedResourceRequirement.Id}"); } this.cdsServiceClient.Delete("msdyn_workorder", retrievedWorkOrder.Id); output.WriteLine($"Deleted msdyn_workorder entity with id {retrievedWorkOrder.Id}"); } foreach (KeyValuePair <Guid, string> pair in entitiesToDelete) { this.cdsServiceClient.Delete(pair.Value, pair.Key); output.WriteLine($"Deleted {pair.Value} entity with id {pair.Key}"); } entitiesToDelete.Clear(); } }
public async void RunE2ETest() { string deviceConnectionString = Environment.GetEnvironmentVariable("IoTHubDeviceConnectionString"); string maxRetriesEnvironmentVariable = Environment.GetEnvironmentVariable("VerificationMaxRetries"); string retrySecondsEnvironmentVariable = Environment.GetEnvironmentVariable("VerificationRetrySeconds"); string shouldCreateWorkOrderEnvironmentVariable = Environment.GetEnvironmentVariable("ShouldCreateWorkOrder"); int maxRetries = maxRetriesEnvironmentVariable != null?int.Parse(maxRetriesEnvironmentVariable) : 10; int retrySeconds = retrySecondsEnvironmentVariable != null?int.Parse(retrySecondsEnvironmentVariable) : 5; bool shouldCreateWorkOrder = shouldCreateWorkOrderEnvironmentVariable != null?bool.Parse(shouldCreateWorkOrderEnvironmentVariable) : false; Microsoft.Azure.Devices.Client.TransportType transportType = Microsoft.Azure.Devices.Client.TransportType.Mqtt; using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transportType)) { // generate unique GUIDs string uniqueAssetName = Guid.NewGuid().ToString(); string uniqueAssetPath = Guid.NewGuid().ToString(); uniqueFaultName = Guid.NewGuid().ToString(); output.WriteLine($"Generated unique AssetName - {uniqueAssetName}"); output.WriteLine($"Generated unique AssetPath - {uniqueAssetPath}"); output.WriteLine($"Generated unique FaultName - {uniqueFaultName}"); // send message to IoTHub output.WriteLine("Sending message to IoT Hub"); string currentISOTimeString = DateTime.UtcNow.ToString("o"); await SendIconicsFaultDataToIoTHubAsync(deviceClient, uniqueAssetName, uniqueAssetPath, uniqueFaultName, "Active", currentISOTimeString); // verify Dynamics Alert and Asset output.WriteLine("Attempting Dynamics Alert and Asset verification"); AssetAlertVerification assetAlertVerification = VerifyDynamicsAssetAndAlert(maxRetries, retrySeconds, uniqueAssetName, uniqueFaultName); // create WorkOrder if necessary if (shouldCreateWorkOrder) { CreateWorkOrderIfNecessary(assetAlertVerification.verifiedAlertId); } EventHubConsumerClient consumer = new EventHubConsumerClient(EventHubConsumerClient.DefaultConsumerGroupName, Environment.GetEnvironmentVariable("IoTHubEventHubEndpoint"), Environment.GetEnvironmentVariable("IoTHubEventHubName")); // verify work order acknowledgement in IoTHub output.WriteLine("Attempting IoT Hub work order acknowledgement verification"); bool iotHubMessageVerified = await VerifyWorkOrderAcknowledgementAsync(consumer, maxRetries, retrySeconds, uniqueAssetPath, uniqueFaultName); // assert Assert.True(assetAlertVerification.assetVerified); Assert.True(assetAlertVerification.alertVerified); Assert.True(iotHubMessageVerified); } }
private async void Button_Click_Device(object sender, RoutedEventArgs e) { string s_port = "22";// tbSvcTimeout2.Text; int port = int.Parse(s_port, CultureInfo.InvariantCulture); string s_deviceConnectionString = Azure_IoTHub_Connections.MyConnections.DeviceConnectionString; Microsoft.Azure.Devices.Client.TransportType s_transportType = Microsoft.Azure.Devices.Client.TransportType.Amqp; string s_deviceId = Azure_IoTHub_Connections.MyConnections.DeviceId; await Task.Run(() => { try { port = int.Parse(s_port, CultureInfo.InvariantCulture); using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(s_deviceConnectionString, s_transportType)) { if (deviceClient == null) { Console.WriteLine("Failed to create DeviceClient!"); return; } var sample = new DeviceStreamSample(deviceClient, "localhost", port, UpdateDeviceOutputText, OnDeviceStatusUpdate); sample.RunSampleAsync(new CancellationTokenSource()).GetAwaiter().GetResult(); } //if (DeviceBasicMode) // DeviceStream_Device.RunDevice(device_cs, OnDeviceRecvTextIO).GetAwaiter().GetResult(); //if (!DeviceUseCustomClass) // DeviceStream_Device.RunDevice(device_cs, OnDeviceRecvTextIO, OnDeviceStatusUpdate, ActionCommand, AppSettingsValues.Settings.KeepDeviceListening ).GetAwaiter().GetResult(); //else // DeviceStream_Device.RunDevice(device_cs, OnDeviceRecvTextIO, OnDeviceStatusUpdate, ActionCommand, AppSettingsValues.Settings.KeepDeviceListening, new DeviceSvcCurrentSettings_Example()).GetAwaiter().GetResult(); } catch (TaskCanceledException) { OnDeviceStatusUpdate("0 Error App.RunClient(): Task cancelled"); } catch (OperationCanceledException) { OnDeviceStatusUpdate("0 Error App.RunClient(): Operation cancelled"); } catch (Exception ex) { OnDeviceStatusUpdate("0 Error App.RunClient(): " + ex.Message); } }); }
public async Task <bool> Connect() { string endPointURI = _APIURL + "device-api/DeviceAuth/" + _IoTDeviceID; string IoTDeviceString = await callAPIService("GET", endPointURI, null); dynamic IoTDeviceJSONObj = JObject.Parse(IoTDeviceString); _IoTHubName = IoTDeviceJSONObj.IoTHubName; _IoTHubProtocol = IoTDeviceJSONObj.IoTHubProtocol; _IoTHubAuthenticationType = IoTDeviceJSONObj.IoTHubAuthenticationType; _IoTDeviceKey = IoTDeviceJSONObj.DeviceKey; _ContainerName = IoTDeviceJSONObj.ContainerName; _CertificateFileName = IoTDeviceJSONObj.CertificateFileName; _CertificatePassword = IoTDeviceJSONObj.CertificatePassword; try { Microsoft.Azure.Devices.Client.TransportType protocol = Microsoft.Azure.Devices.Client.TransportType.Http1; //MessageBox.Show("HTTP1"); switch (_IoTHubProtocol.ToLower()) { case "amqp": protocol = Microsoft.Azure.Devices.Client.TransportType.Amqp; break; case "mqtt": protocol = Microsoft.Azure.Devices.Client.TransportType.Mqtt; break; case "https": protocol = Microsoft.Azure.Devices.Client.TransportType.Http1; break; } if (_CDSClient == null) { _CDSClient = DeviceClient.Create(_IoTHubName, new DeviceAuthenticationWithRegistrySymmetricKey(_IoTDeviceID, _IoTDeviceKey), protocol); _CDSClient.OperationTimeoutInMilliseconds = 86400000; } } catch (Exception ex) { Console.WriteLine(ex.Message); //MessageBox.Show(ex.ToString()); } return(true); }
// Example: // DeviceLoad.exe {OutputStorageConnectionString} {DeviceClientEndpoint} {DevicePerVm} {MessagePerMin} {DurationInMin} {BatchJobId} {DeviceIdPrefix} [MessageFormat] // OutputStorageConnectionString: DefaultEndpointsProtocol=https;AccountName={name};AccountKey={key};EndpointSuffix={core.windows.net} // DeviceClientEndpoint: HostName={http://xx.chinacloudapp.cn};SharedAccessKeyName=owner;SharedAccessKey={key} static void Main(string[] args) { setting = Setting.Parse(args); if (setting == null) { Environment.Exit(-1); } ServicePointManager.DefaultConnectionLimit = 200; if (!Enum.TryParse(setting.Transport, out transport)) { transport = Microsoft.Azure.Devices.Client.TransportType.Mqtt; } wallclock = Stopwatch.StartNew(); var devices = CreateDevices().Result; SendMessages(devices).Wait(); }
public async void ValidateDynamicsInActiveAlert() { string deviceConnectionString = Environment.GetEnvironmentVariable("IoTHubDeviceConnectionString"); string maxRetriesEnvironmentVariable = Environment.GetEnvironmentVariable("VerificationMaxRetries"); string retrySecondsEnvironmentVariable = Environment.GetEnvironmentVariable("VerificationRetrySeconds"); string shouldCreateWorkOrderEnvironmentVariable = Environment.GetEnvironmentVariable("ShouldCreateWorkOrder"); int maxRetries = maxRetriesEnvironmentVariable != null?int.Parse(maxRetriesEnvironmentVariable) : 10; int retrySeconds = retrySecondsEnvironmentVariable != null?int.Parse(retrySecondsEnvironmentVariable) : 5; Microsoft.Azure.Devices.Client.TransportType transportType = Microsoft.Azure.Devices.Client.TransportType.Mqtt; using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transportType)) { // generate unique GUIDs string uniqueAssetName = Guid.NewGuid().ToString(); string uniqueAssetPath = Guid.NewGuid().ToString(); uniqueFaultName = Guid.NewGuid().ToString(); output.WriteLine($"Generated unique AssetName - {uniqueAssetName}"); output.WriteLine($"Generated unique AssetPath - {uniqueAssetPath}"); output.WriteLine($"Generated unique FaultName - {uniqueFaultName}"); // send message to IoTHub output.WriteLine("Sending message to IoT Hub"); string currentISOTimeString = DateTime.UtcNow.ToString("o"); await SendIconicsFaultDataToIoTHubAsync(deviceClient, uniqueAssetName, uniqueAssetPath, uniqueFaultName, "Active", currentISOTimeString); // verify Dynamics Alert and Asset output.WriteLine("Attempting Dynamics Alert and Asset verification"); AssetAlertVerification assetAlertVerification = VerifyDynamicsAssetAndAlert(maxRetries, retrySeconds, uniqueAssetName, uniqueFaultName); output.WriteLine("Sending message to IoT Hub with Fault State as InActive"); await SendIconicsFaultDataToIoTHubAsync(deviceClient, uniqueAssetName, uniqueAssetPath, uniqueFaultName, "InActive", currentISOTimeString); bool inActiveAlertVerified = VerifyDynamicsInActiveAlert(maxRetries, retrySeconds, uniqueFaultName); // assert Assert.True(assetAlertVerification.assetVerified); Assert.True(assetAlertVerification.alertVerified); Assert.True(inActiveAlertVerified); } }
static async Task <DeviceBenchmarkEntry> StartClient(string IoTHub, string IoTDevicePrefix, int deviceNumber, string commonKey, int maxMessages, int messageSize, Microsoft.Azure.Devices.Client.TransportType transportType) { string connectionString = "HostName=" + IoTHub + ";DeviceId=" + IoTDevicePrefix + deviceNumber + ";SharedAccessKey=" + commonKey; string deviceName = IoTDevicePrefix + deviceNumber; DateTime startTime = DateTime.Now; try { DeviceClient device = DeviceClient.CreateFromConnectionString(connectionString, transportType); await device.OpenAsync(); int mycounter = 1; Console.WriteLine($"Device {deviceName} started"); DateTime startTimeWithoutConnect = DateTime.Now; while (mycounter <= maxMessages) { var IoTMessage = new Microsoft.Azure.Devices.Client.Message(new byte[messageSize]); await device.SendEventAsync(IoTMessage); mycounter++; } DateTime endTimeWithoutConnect = DateTime.Now; double messagesPerSecondWithoutConnect = maxMessages / (endTimeWithoutConnect - startTimeWithoutConnect).TotalSeconds; Console.WriteLine($"Device {deviceName}: Messages Per Second Without Connect: { messagesPerSecondWithoutConnect}"); await device.CloseAsync(); DateTime endTime = DateTime.Now; double messagesPerSecond = maxMessages / (endTime - startTime).TotalSeconds; Console.WriteLine($"Device {deviceName}: Messages Per Second: { messagesPerSecond}"); Console.WriteLine($"Device {deviceName} ended"); DeviceBenchmarkEntry benchmarkEntry = new DeviceBenchmarkEntry() { StartTime = startTime, EndTime = endTime, StartTimeWithoutConnect = startTimeWithoutConnect, EndTimeWithoutConnect = endTimeWithoutConnect, DeviceName = deviceName, MaxMessages = maxMessages, MessageSize = messageSize, MessagePerSecond = messagesPerSecond, MessagePerSecondWithoutConnect = messagesPerSecondWithoutConnect }; return(benchmarkEntry); } catch (Exception er) { Console.WriteLine($"Error starting device: {deviceName} error: {er.InnerException.Message}"); } return(null); }
static void Main(string[] args) { CommandLine.Parser.Default.ParseArguments <Options>(args) .WithParsed <Options>(opts => { string IoTHub = opts.IotHubConnectionString.Split(';')[0].Split('=')[1]; Console.WriteLine("Creating Devices"); CreateDevices(opts.DeviceCount, opts.IotHubConnectionString).Wait(); // Messagesize if (opts.MessageSize > 262143) { Console.WriteLine($"Setting MessageSize to maximum of {MAXMESSAGESIZE}"); MessageSize = MAXMESSAGESIZE; } else { MessageSize = opts.MessageSize; } // Transporttype switch (opts.TransportType) { case "MQTT": TransportType = Microsoft.Azure.Devices.Client.TransportType.Mqtt; break; case "AMQP": TransportType = Microsoft.Azure.Devices.Client.TransportType.Amqp; break; case "HTTP": TransportType = Microsoft.Azure.Devices.Client.TransportType.Http1; break; default: TransportType = Microsoft.Azure.Devices.Client.TransportType.Mqtt; break; } Console.WriteLine($"Starting Devices: DeviceCount: {opts.DeviceCount} MaxMessages:{opts.MaxMessages} MessageSize:{MessageSize} TransportType:{TransportType}"); DateTime startTime = DateTime.Now; BenchmarkEntry benchmarkEntry = new BenchmarkEntry() { StartTime = startTime, DeviceCount = opts.DeviceCount, MaxMessages = opts.MaxMessages, MessageSize = MessageSize, DeviceBenchmarks = new List <DeviceBenchmarkEntry>(), TransportType = opts.TransportType }; Task[] tasks = new Task[opts.DeviceCount]; for (int deviceNumber = 1; deviceNumber <= opts.DeviceCount; deviceNumber++) { tasks[deviceNumber - 1] = StartClient(IoTHub, IoTDevicePrefix, deviceNumber, CommonKey, opts.MaxMessages, MessageSize, TransportType).ContinueWith(task => { benchmarkEntry.DeviceBenchmarks.Add(task.Result); }); } Task.WaitAll(tasks); DateTime endTime = DateTime.Now; double messagesPerSecond = opts.DeviceCount * opts.MaxMessages / (endTime - startTime).TotalSeconds; benchmarkEntry.EndTime = endTime; benchmarkEntry.MessagePerSecond = messagesPerSecond; WriteResultsToFile(benchmarkEntry, opts.BenchmarkFileNamePath).Wait(); Console.WriteLine("All Messages are sent"); Console.WriteLine($"Total Clients: {opts.DeviceCount}"); Console.WriteLine($"Message Size: {opts.MessageSize}"); Console.WriteLine($"Total Messages Sent: {opts.DeviceCount * opts.MaxMessages}"); Console.WriteLine($"Total Execution Time: {(endTime - startTime).TotalSeconds} seconds"); Console.WriteLine($"Messages Per Second: {messagesPerSecond}"); Thread.Sleep(7000); // Wait before starting to delete devices DeleteDevices(opts.DeviceCount, opts.IotHubConnectionString).Wait(); }); }
public Edge() { this.Transport = Microsoft.Azure.Devices.Client.TransportType.Mqtt; }
static async Task CallDirectMethodFromCloud( string serviceClientConnectionString, string deviceId, string moduleId, TransportType transportType, TimeSpan delay, CancellationTokenSource cts) { Logger.LogInformation("CallDirectMethodFromCloud started."); ModuleClient moduleClient = null; ServiceClient serviceClient = null; try { Guid batchId = Guid.NewGuid(); int count = 1; IotHubConnectionStringBuilder iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(serviceClientConnectionString); Logger.LogInformation($"Prepare to call Direct Method from cloud ({iotHubConnectionStringBuilder.IotHubName}) on device [{deviceId}] module [{moduleId}]"); serviceClient = ServiceClient.CreateFromConnectionString(serviceClientConnectionString, Microsoft.Azure.Devices.TransportType.Amqp); var cloudToDeviceMethod = new CloudToDeviceMethod("HelloWorldMethod").SetPayloadJson("{ \"Message\": \"Hello\" }"); moduleClient = await ModuleUtil.CreateModuleClientAsync( transportType, ModuleUtil.DefaultTimeoutErrorDetectionStrategy, ModuleUtil.DefaultTransientRetryStrategy, Logger); while (!cts.Token.IsCancellationRequested) { Logger.LogInformation($"Calling Direct Method from cloud ({iotHubConnectionStringBuilder.IotHubName}) on device [{deviceId}] module [{moduleId}] of count {count}."); try { CloudToDeviceMethodResult result = await serviceClient.InvokeDeviceMethodAsync(deviceId, moduleId, cloudToDeviceMethod, CancellationToken.None); if (result.Status == (int)HttpStatusCode.OK) { var eventMessage = new Message(Encoding.UTF8.GetBytes($"Direct Method [{transportType}] Call succeeded.")); eventMessage.Properties.Add("sequenceNumber", count.ToString()); eventMessage.Properties.Add("batchId", batchId.ToString()); Logger.LogInformation($"Calling Direct Method from cloud with count {count} succeeded."); await moduleClient.SendEventAsync(RouteOutputName, eventMessage); } else { Logger.LogError($"Calling Direct Method from cloud with count {count} failed with status code {result.Status}."); } count++; } catch (Exception e) { Logger.LogError($"Exception caught with count {count}: {e}"); } await Task.Delay(delay, cts.Token); } } catch (Exception e) { Logger.LogError($"Exception caught: {e}"); throw; } finally { Logger.LogInformation("Close connection for service client and module client"); if (serviceClient != null) { await serviceClient.CloseAsync(); } if (moduleClient != null) { await moduleClient.CloseAsync(); } } Logger.LogInformation("CallDirectMethodFromCloud finished."); }
public DeviceClient CreateDeviceClient(Device device, TransportType transportType) { return(DeviceClient.Create(configuration[ConfigurationKeys.IotHubUri], new DeviceAuthenticationWithRegistrySymmetricKey(device.Id, device.Authentication.SymmetricKey.PrimaryKey), transportType)); }