private static async void SendDeviceToCloudMessagesAsync() { double minTemperature = 20; double minHumidity = 60; int messageId = 1; Random rand = new Random(); for (int i = 0; i < messN; i++) { double currentTemperature = Math.Round((minTemperature + rand.NextDouble() * 15), 2); double currentHumidity = Math.Round((minHumidity + rand.NextDouble() * 20), 2); string level = (currentTemperature > 30 ? "critical" : "normal"); var telemetryDataPoint = new { messageId = messageId++, deviceId = deviceID, temperature = currentTemperature, humidity = currentHumidity, }; var messageString = JsonConvert.SerializeObject(telemetryDataPoint); var message = new Message(Encoding.ASCII.GetBytes(messageString)); message.Properties.Add("level", level); await iotClient.SendEventAsync(message); Console.WriteLine("{0} > Sending message - level: {1} - {2}", DateTime.Now, level, messageString); await Task.Delay(100); } Console.WriteLine("Closing..."); await iotClient.CloseAsync(); }
private async Task ReceiveSingleMessageAsync(TestDeviceType type, Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, s_devicePrefix, type).ConfigureAwait(false); using DeviceClient deviceClient = testDevice.CreateDeviceClient(transport); using var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); await deviceClient.OpenAsync().ConfigureAwait(false); if (transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only) { // Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client. await deviceClient.ReceiveAsync(s_fiveSeconds).ConfigureAwait(false); } await serviceClient.OpenAsync().ConfigureAwait(false); (Message msg, string payload, string p1Value) = ComposeC2dTestMessage(Logger); using (msg) { await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false); await VerifyReceivedC2DMessageAsync(transport, deviceClient, testDevice.Id, msg, payload, Logger).ConfigureAwait(false); } await deviceClient.CloseAsync().ConfigureAwait(false); await serviceClient.CloseAsync().ConfigureAwait(false); }
/// <summary> /// Shuts down the IoTHub communication. /// </summary> public void Shutdown() { // send cancellation token and wait for last IoT Hub message to be sent. try { _tokenSource.Cancel(); _dequeueAndSendTask.Wait(); if (_iotHubClient != null) { _iotHubClient.CloseAsync().Wait(); } if (_sendTimer != null) { _sendTimer.Dispose(); } if (_sendQueueEvent != null) { _sendQueueEvent.Dispose(); } } catch (Exception e) { Trace(e, "Failure while shutting down IoTHub messaging."); } }
// INSERT Main method below here public static async Task Main(string[] args) { using (var security = new SecurityProviderSymmetricKey(registrationId, individualEnrollmentPrimaryKey, individualEnrollmentSecondaryKey)) using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly)) { ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, dpsIdScope, security, transport); using (deviceClient = await ProvisionDevice(provClient, security)) { await deviceClient.OpenAsync().ConfigureAwait(false); // INSERT Setup OnDesiredPropertyChanged Event Handling below here await deviceClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null).ConfigureAwait(false); // INSERT Load Device Twin Properties below here var twin = await deviceClient.GetTwinAsync().ConfigureAwait(false); await OnDesiredPropertyChanged(twin.Properties.Desired, null); // Start reading and sending device telemetry Console.WriteLine("Start reading and sending device telemetry..."); await SendDeviceToCloudMessagesAsync(); await deviceClient.CloseAsync().ConfigureAwait(false); } } }
static async Task startClient(string IoTHub, string IoTDevicePrefix, int deviceNumber, string commonKey, int maxMessages, int messageDelaySeconds) { allClientStarted++; runningDevices++; string connectionString = "HostName=" + IoTHub + ";DeviceId=" + IoTDevicePrefix + deviceNumber + ";SharedAccessKey=" + commonKey; DeviceClient device = DeviceClient.CreateFromConnectionString(connectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt); await device.OpenAsync(); Random rnd = new Random(); int mycounter = 1; Console.WriteLine("Device " + IoTDevicePrefix + deviceNumber + " started"); while (mycounter <= maxMessages) { Thread.Sleep((messageDelaySeconds * 1000) + rnd.Next(1, 100)); string message = "{ \'loadTest\':\'True\', 'sequenceNumber': " + mycounter + ", \'SubmitTime\': \'" + DateTime.UtcNow + "\', \'randomValue\':" + rnd.Next(1, 4096 * 4096) + " }"; Microsoft.Azure.Devices.Client.Message IoTMessage = new Microsoft.Azure.Devices.Client.Message(Encoding.UTF8.GetBytes(message)); await device.SendEventAsync(IoTMessage); totalMessageSent++; mycounter++; } await device.CloseAsync(); Console.WriteLine("Device " + IoTDevicePrefix + deviceNumber + " ended"); runningDevices--; }
protected async Task CloseAsync(CancellationToken ct) { if (_dc == null) { return; } _m.ScheduleTime = null; _m.OperationType = TelemetryMetrics.DeviceOperationClose; _sw.Restart(); try { await _dc.CloseAsync(ct).ConfigureAwait(false); } catch (Exception ex) { _m.ErrorMessage = $"{ex.GetType().Name} - {ex.Message}"; throw; } finally { _m.ExecuteTime = _sw.ElapsedMilliseconds; await _writer.WriteAsync(_m).ConfigureAwait(false); } }
private async Task ReceiveSingleMessage(TestDeviceType type, Client.TransportType transport) { ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, type).ConfigureAwait(false); DeviceClient deviceClient = testDevice.CreateDeviceClient(transport); try { await deviceClient.OpenAsync().ConfigureAwait(false); if (transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only) { _log.WriteLine("Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client."); await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2)).ConfigureAwait(false); } string payload, messageId, p1Value; await serviceClient.OpenAsync().ConfigureAwait(false); Message msg = ComposeC2DTestMessage(out payload, out messageId, out p1Value); await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false); await VerifyReceivedC2DMessage(transport, deviceClient, payload, p1Value).ConfigureAwait(false); } finally { await deviceClient.CloseAsync().ConfigureAwait(false); await serviceClient.CloseAsync().ConfigureAwait(false); } }
private async Task ReceiveSingleMessageWithCancellationTokenAsync(TestDeviceType type, Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, s_devicePrefix, type).ConfigureAwait(false); using DeviceClient deviceClient = testDevice.CreateDeviceClient(transport); using var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); await deviceClient.OpenAsync().ConfigureAwait(false); await serviceClient.OpenAsync().ConfigureAwait(false); // For Mqtt - the device needs to have subscribed to the devicebound topic, in order for IoT Hub to deliver messages to the device. // For this reason we will make a "fake" ReceiveAsync() call, which will result in the device subscribing to the c2d topic. // Note: We need this "fake" ReceiveAsync() call even though we (SDK default) CONNECT with a CleanSession flag set to 0. // This is because this test device is newly created, and it has never subscribed to IoT hub c2d topic. // Hence, IoT hub doesn't know about its CleanSession preference yet. if (transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only) { await deviceClient.ReceiveAsync(s_fiveSeconds).ConfigureAwait(false); } (Message msg, string payload, string p1Value) = ComposeC2dTestMessage(Logger); using (msg) { await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false); } await VerifyReceivedC2dMessageWithCancellationTokenAsync(transport, deviceClient, testDevice.Id, payload, p1Value, Logger).ConfigureAwait(false); await deviceClient.CloseAsync().ConfigureAwait(false); await serviceClient.CloseAsync().ConfigureAwait(false); }
async Task EnsureDeviceQueueLengthAsync(string hostname, Device device, int expectedLength) { await Task.Delay(TimeSpan.FromSeconds(1)); DeviceClient deviceClient = null; try { deviceClient = DeviceClient.Create( hostname, new DeviceAuthenticationWithRegistrySymmetricKey(this.deviceId, device.Authentication.SymmetricKey.PrimaryKey)); int leftToTarget = expectedLength; while (true) { using (Client.Message message = await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2))) { if (message == null) { break; } leftToTarget--; Assert.True(leftToTarget >= 0, $"actual device queue length is greater than expected ({expectedLength})."); } } Assert.True(leftToTarget == 0, $"actual device length is less than expected ({expectedLength})."); } finally { if (deviceClient != null) { await deviceClient.CloseAsync(); } } }
public void Run(IBackgroundTaskInstance taskInstance) { deferral = taskInstance.GetDeferral(); InitGPIO(); try { Console.WriteLine("Connecting to hub"); Client = DeviceClient.CreateFromConnectionString(DeviceConnectionString, TransportType.Mqtt); // setup callback for "writeLine" method Client.SetMethodHandlerAsync("lightOn", TurnLightOn, null).Wait(); Client.SetMethodHandlerAsync("lightOff", TurnLightOff, null).Wait(); Console.WriteLine("Waiting for direct method call\n Press enter to exit."); Console.ReadLine(); Console.WriteLine("Exiting..."); // as a good practice, remove the "writeLine" handler Client.SetMethodHandlerAsync("lightOn", null, null).Wait(); Client.SetMethodHandlerAsync("lightOff", null, null).Wait(); Client.CloseAsync().Wait(); } catch (Exception ex) { Console.WriteLine(); Console.WriteLine("Error in sample: {0}", ex.Message); } }
private async Task SendMethodAndRespondRecovery(Client.TransportType transport, string faultType, string reason, int delayInSec) { Tuple <string, string> deviceInfo = TestUtil.CreateDevice(DevicePrefix, hostName, registryManager); var assertResult = new TaskCompletionSource <Tuple <bool, bool> >(); DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport); await deviceClient.SetMethodHandlerAsync(MethodName, (request, context) => { assertResult.SetResult(new Tuple <bool, bool>(request.Name.Equals(MethodName), request.DataAsJson.Equals(ServiceRequestJson))); return(Task.FromResult(new MethodResponse(Encoding.UTF8.GetBytes(DeviceResponseJson), 200))); }, null); await ServiceSendMethodAndVerifyResponse(deviceInfo.Item1, MethodName, DeviceResponseJson, ServiceRequestJson, assertResult); // send error command await deviceClient.SendEventAsync(TestUtil.ComposeErrorInjectionProperties(faultType, reason, delayInSec)); // allow time for connection recovery await Task.Delay(TimeSpan.FromSeconds(3)); assertResult = new TaskCompletionSource <Tuple <bool, bool> >(); await ServiceSendMethodAndVerifyResponse(deviceInfo.Item1, MethodName, DeviceResponseJson, ServiceRequestJson, assertResult); await deviceClient.CloseAsync(); TestUtil.RemoveDevice(deviceInfo.Item1, registryManager); }
public void Dispose() { if (udpClient != null) { if (udpClient.Client != null && udpClient.Client.Connected) { try { udpClient.Client.Disconnect(false); } catch (Exception ex) { Console.WriteLine($"Udp Client socket disconnecting error: {ex.Message}"); } try { udpClient.Client.Close(); } catch (Exception ex) { Console.WriteLine($"Udp Client socket closing error: {ex.Message}"); } try { udpClient.Client.Dispose(); } catch (Exception ex) { Console.WriteLine($"Udp Client socket disposing error: {ex.Message}"); } } try { udpClient.Close(); } catch (Exception ex) { Console.WriteLine($"Udp Client closing error: {ex.Message}"); } try { udpClient.Dispose(); } catch (Exception ex) { Console.WriteLine($"Udp Client disposing error: {ex.Message}"); } } if (ioTHubModuleClient != null) { try { ioTHubModuleClient.CloseAsync().Wait(); } catch (Exception ex) { Console.WriteLine($"IoTHub Module Client closing error: {ex.Message}"); } try { ioTHubModuleClient.Dispose(); } catch (Exception ex) { Console.WriteLine($"IoTHub Module Client disposing error: {ex.Message}"); } } if (messageProcessor != null) { try { messageProcessor.Dispose(); } catch (Exception ex) { Console.WriteLine($"Message Processor disposing error: {ex.Message}"); } } }
private async Task ReceiveSingleMessageWithCancellationToken(TestDeviceType type, Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, type).ConfigureAwait(false); using (DeviceClient deviceClient = testDevice.CreateDeviceClient(transport)) using (ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { await deviceClient.OpenAsync().ConfigureAwait(false); if (transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only) { // Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client. await deviceClient.ReceiveAsync(TIMESPAN_FIVE_SECONDS).ConfigureAwait(false); } await serviceClient.OpenAsync().ConfigureAwait(false); (Message msg, string messageId, string payload, string p1Value) = ComposeC2DTestMessage(); await serviceClient.SendAsync(testDevice.Id, msg).ConfigureAwait(false); await VerifyReceivedC2DMessageWithCancellationTokenAsync(transport, deviceClient, testDevice.Id, payload, p1Value).ConfigureAwait(false); await deviceClient.CloseAsync().ConfigureAwait(false); await serviceClient.CloseAsync().ConfigureAwait(false); } }
private async Task ReceiveMessageInOperationTimeout(TestDeviceType type, Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix, type).ConfigureAwait(false); using (DeviceClient deviceClient = testDevice.CreateDeviceClient(transport)) { await deviceClient.OpenAsync().ConfigureAwait(false); if (transport == Client.TransportType.Mqtt_Tcp_Only || transport == Client.TransportType.Mqtt_WebSocket_Only) { // Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client. await deviceClient.ReceiveAsync(TIMESPAN_FIVE_SECONDS).ConfigureAwait(false); } try { deviceClient.OperationTimeoutInMilliseconds = Convert.ToUInt32(TIMESPAN_ONE_MINUTE.TotalMilliseconds); if (transport == Client.TransportType.Amqp || transport == Client.TransportType.Amqp_Tcp_Only || transport == Client.TransportType.Amqp_WebSocket_Only) { // For AMQP because of static 1 min interval check the cancellation token, in worst case it will block upto extra 1 min to return await ReceiveMessageWithoutTimeoutCheck(deviceClient, TIMESPAN_ONE_MINUTE).ConfigureAwait(false); } else { await ReceiveMessageWithoutTimeoutCheck(deviceClient, TIMESPAN_FIVE_SECONDS).ConfigureAwait(false); } } finally { deviceClient.OperationTimeoutInMilliseconds = DeviceClient.DefaultOperationTimeoutInMilliseconds; await deviceClient.CloseAsync().ConfigureAwait(false); } } }
private async Task ReuseAuthenticationMethod_SingleDevice(Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false); var authenticationMethod = new DeviceAuthenticationSasToken(testDevice.ConnectionString, disposeWithClient: false); // Create an instance of the device client, send a test message and then close and dispose it. DeviceClient deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, authenticationMethod, transport); using var message1 = new Client.Message(); await deviceClient.SendEventAsync(message1).ConfigureAwait(false); await deviceClient.CloseAsync(); deviceClient.Dispose(); Logger.Trace("Test with instance 1 completed"); // Perform the same steps again, reusing the previously created authentication method instance to ensure // that the sdk did not dispose the user supplied authentication method instance. DeviceClient deviceClient2 = DeviceClient.Create(testDevice.IoTHubHostName, authenticationMethod, transport); using var message2 = new Client.Message(); await deviceClient2.SendEventAsync(message2).ConfigureAwait(false); await deviceClient2.CloseAsync(); deviceClient2.Dispose(); Logger.Trace("Test with instance 2 completed, reused the previously created authentication method instance for the device client."); authenticationMethod.Dispose(); }
private async Task AuthenticationMethodDisposesTokenRefresher(Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, _devicePrefix).ConfigureAwait(false); var authenticationMethod = new DeviceAuthenticationSasToken(testDevice.ConnectionString, disposeWithClient: true); // Create an instance of the device client, send a test message and then close and dispose it. DeviceClient deviceClient = DeviceClient.Create(testDevice.IoTHubHostName, authenticationMethod, transport); using var message1 = new Client.Message(); await deviceClient.SendEventAsync(message1).ConfigureAwait(false); await deviceClient.CloseAsync(); deviceClient.Dispose(); Logger.Trace("Test with instance 1 completed"); // Perform the same steps again, reusing the previously created authentication method instance. // Since the default behavior is to dispose AuthenticationWithTokenRefresh authentication method on DeviceClient disposal, // this should now throw an ObjectDisposedException. DeviceClient deviceClient2 = DeviceClient.Create(testDevice.IoTHubHostName, authenticationMethod, transport); using var message2 = new Client.Message(); Func <Task> act = async() => await deviceClient2.SendEventAsync(message2).ConfigureAwait(false); await act.Should().ThrowAsync <ObjectDisposedException>(); }
private static async void SendDeviceToCloudMessagesAsync() { int i = 0; DateTime start = DateTime.Now; while (run) { i++; string telemetry = GenerateMessage(i, $"message:{i}"); DeviceClient deviceClient = CreateDeviceClient(deviceId, deviceKey); await deviceClient.SendEventAsync(new Microsoft.Azure.Devices.Client.Message(Encoding.UTF8.GetBytes(telemetry))); await deviceClient.CloseAsync(); Console.WriteLine("{0} ==> Sending message: {1}", DateTime.Now, telemetry); Thread.Sleep(1000); var time = DateTime.Now - start; if (time.Seconds >= duration) { Success($"Sent {i} messages, druation {time.Seconds} seconds"); run = false; } } Log("Exit SendMessage()..."); }
private static async Task Main() { if (readTheFile) { // If you want to decode an output file, put the path in ReadOneRowFromFile(), // uncomment the call here and the return command, then run this application. ReadOneRowFromFile(); } else { // Send messages to the simulated device. Each message will contain a randomly generated // Temperature and Humidity. // The "level" of each message is set randomly to "storage", "critical", or "normal". // The messages are routed to different endpoints depending on the level, temperature, and humidity. // This is set in the tutorial that goes with this sample: // http://docs.microsoft.com/azure/iot-hub/tutorial-routing Console.WriteLine("Routing Tutorial: Simulated device\n"); s_deviceClient = DeviceClient.Create(s_iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(s_myDeviceId, s_deviceKey), TransportType.Mqtt); using var cts = new CancellationTokenSource(); var messages = SendDeviceToCloudMessagesAsync(cts.Token); Console.WriteLine("Press the Enter key to stop."); Console.ReadLine(); await s_deviceClient.CloseAsync(cts.Token); cts.Cancel(); await messages; } }
// Device SDK caches the AmqpTransportSettings that are set the first time and ignores // all the settings used thereafter from that process. So set up a dummy connection using the test // AmqpTransportSettings, so that Device SDK caches it and uses it thereafter static async Task ConnectToIotHub(string connectionString) { DeviceClient dc = DeviceClient.CreateFromConnectionString(connectionString, TestSettings.AmqpTransportSettings); await dc.OpenAsync(); await dc.CloseAsync(); }
internal bool SendMessages(int numMessages, int sleepMilisecs) { var colors = Enum.GetValues(typeof(KnownColor)); try { // Note that MQTT is required for the device twin stuff to work. Me = DeviceClient.Create(Program.IotHubUri, new DeviceAuthenticationWithX509Certificate(MyDevId, MyCert), Microsoft.Azure.Devices.Client.TransportType.Mqtt); Me.OpenAsync().Wait(); QueryFWStatus(); for (byte j = 0; j < numMessages; j++) { int colorVal = (int)colors.GetValue(rr.Next(colors.Length)); var t = Me.SendEventAsync(MakeMessage(MyDevId, colorVal, MessageCount++)); t.Wait(); Thread.Sleep(sleepMilisecs); } Me.CloseAsync().Wait(); } catch (Exception ex) { Debug.WriteLine($"Error in Create or SendMessages {ex.ToString()}"); if (ex.InnerException != null) { Debug.WriteLine($"Error in SendMessages (inner exception is) {ex.InnerException.ToString()}"); } return(false); } return(true); }
private async Task ReceiveSingleMessageUsingCallbackAsync(TestDeviceType type, Client.TransportType transport) { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, s_devicePrefix, type).ConfigureAwait(false); using DeviceClient deviceClient = testDevice.CreateDeviceClient(transport); using var testDeviceCallbackHandler = new TestDeviceCallbackHandler(deviceClient, testDevice, Logger); using var serviceClient = ServiceClient.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); (Message msg, string payload, string p1Value) = ComposeC2dTestMessage(Logger); using (msg) { await testDeviceCallbackHandler.SetMessageReceiveCallbackHandlerAsync().ConfigureAwait(false); testDeviceCallbackHandler.ExpectedMessageSentByService = msg; using var cts = new CancellationTokenSource(s_tenSeconds); Logger.Trace($"Sending C2D message from service, messageId={msg.MessageId}"); await Task .WhenAll( serviceClient.SendAsync(testDevice.Id, msg), testDeviceCallbackHandler.WaitForReceiveMessageCallbackAsync(cts.Token)) .ConfigureAwait(false); } await deviceClient.CloseAsync().ConfigureAwait(false); await serviceClient.CloseAsync().ConfigureAwait(false); }
private async Task SendMethodAndRespondRecovery(Client.TransportType transport, string faultType, string reason, int delayInSec) { Tuple <string, string> deviceInfo = TestUtil.CreateDevice("E2E_Method_CSharp_", hostName, registryManager); string deviceResponseJson = "{\"name\":\"e2e_test\"}"; string serviceRequestJson = "{\"a\":123}"; string methodName = "MethodE2ETest"; var assertResult = new TaskCompletionSource <Tuple <bool, bool> >(); DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceInfo.Item2, transport); await deviceClient.SetMethodHandlerAsync(methodName, (request, context) => { assertResult.SetResult(new Tuple <bool, bool>(request.Name.Equals(methodName), request.DataAsJson.Equals(serviceRequestJson))); return(Task.FromResult(new MethodResponse(Encoding.UTF8.GetBytes(deviceResponseJson), 200))); }, null); await ServiceSendMethodAndVerifyResponse(deviceInfo.Item1, methodName, deviceResponseJson, serviceRequestJson, assertResult); // send error command await deviceClient.SendEventAsync(TestUtil.ComposeErrorInjectionProperties(faultType, reason, delayInSec)); Debug.WriteLine("Drop command sent from device client."); // allow time for connection recovery await Task.Delay(TimeSpan.FromSeconds(3)); assertResult = new TaskCompletionSource <Tuple <bool, bool> >(); await ServiceSendMethodAndVerifyResponse(deviceInfo.Item1, methodName, deviceResponseJson, serviceRequestJson, assertResult); await deviceClient.CloseAsync(); TestUtil.RemoveDevice(deviceInfo.Item1, registryManager); }
async Task CleanupDeviceQueueAsync(string hostname, Device device) { await Task.Delay(TimeSpan.FromSeconds(1)); DeviceClient deviceClient = null; try { deviceClient = DeviceClient.Create( hostname, new DeviceAuthenticationWithRegistrySymmetricKey(this.deviceId, device.Authentication.SymmetricKey.PrimaryKey)); while (true) { using (Client.Message message = await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2))) { if (message == null) { break; } if (message.LockToken != null) { await deviceClient.CompleteAsync(message.LockToken); } } } } finally { if (deviceClient != null) { await deviceClient.CloseAsync(); } } }
private static async Task Main(string[] args) { Console.WriteLine("IoT Hub Quickstarts #1 - Simulated device."); // This sample accepts the device connection string as a parameter, if present ValidateConnectionString(args); // Connect to the IoT hub using the MQTT protocol s_deviceClient = DeviceClient.CreateFromConnectionString(s_connectionString, s_transportType); // Set up a condition to quit the sample Console.WriteLine("Press control-C to exit."); using var cts = new CancellationTokenSource(); Console.CancelKeyPress += (sender, eventArgs) => { eventArgs.Cancel = true; cts.Cancel(); Console.WriteLine("Exiting..."); }; // Run the telemetry loop await SendDeviceToCloudMessagesAsync(cts.Token); // SendDeviceToCloudMessagesAsync is designed to run until cancellation has been explicitly requested by Console.CancelKeyPress. // As a result, by the time the control reaches the call to close the device client, the cancellation token source would // have already had cancellation requested. // Hence, if you want to pass a cancellation token to any subsequent calls, a new token needs to be generated. // For device client APIs, you can also call them without a cancellation token, which will set a default // cancellation timeout of 4 minutes: https://github.com/Azure/azure-iot-sdk-csharp/blob/64f6e9f24371bc40ab3ec7a8b8accbfb537f0fe1/iothub/device/src/InternalClient.cs#L1922 await s_deviceClient.CloseAsync(); s_deviceClient.Dispose(); Console.WriteLine("Device simulator finished."); }
public async Task DeviceClient_TokenConnectionDoubleRelease_Ok() { TestDevice testDevice = await TestDevice.GetTestDeviceAsync(Logger, DevicePrefix).ConfigureAwait(false); string deviceConnectionString = testDevice.ConnectionString; var config = new Configuration.IoTHub.DeviceConnectionStringParser(deviceConnectionString); string iotHub = config.IoTHub; string deviceId = config.DeviceID; string key = config.SharedAccessKey; SharedAccessSignatureBuilder builder = new SharedAccessSignatureBuilder() { Key = key, TimeToLive = new TimeSpan(0, 10, 0), Target = $"{iotHub}/devices/{WebUtility.UrlEncode(deviceId)}", }; DeviceAuthenticationWithToken auth = new DeviceAuthenticationWithToken(deviceId, builder.ToSignature()); using (DeviceClient deviceClient = DeviceClient.Create(iotHub, auth, Client.TransportType.Amqp_Tcp_Only)) { Logger.Trace($"{deviceId}: Created {nameof(DeviceClient)} ID={TestLogger.IdOf(deviceClient)}"); Logger.Trace($"{deviceId}: DeviceClient OpenAsync."); await deviceClient.OpenAsync().ConfigureAwait(false); Logger.Trace($"{deviceId}: DeviceClient SendEventAsync."); await deviceClient.SendEventAsync(new Client.Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false); Logger.Trace($"{deviceId}: DeviceClient CloseAsync."); await deviceClient.CloseAsync().ConfigureAwait(false); // First release } // Second release }
public static async Task RunAsync(ProvisioningDeviceClient provisioningDeviceClient, SecurityProvider security) { Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}"); Console.Write("ProvisioningClient RegisterAsync . . . "); DeviceRegistrationResult result = await provisioningDeviceClient.RegisterAsync().ConfigureAwait(false); Console.WriteLine($"{result.Status}"); Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}"); if (result.Status == ProvisioningRegistrationStatusType.Assigned) { X509Certificate2 certificate = (security as SecurityProviderX509).GetAuthenticationCertificate(); Console.WriteLine($"Registration certificate thumbprint: {certificate.Thumbprint}"); IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, certificate); using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp)) { Console.WriteLine("DeviceClient OpenAsync."); await iotClient.OpenAsync().ConfigureAwait(false); Console.WriteLine("DeviceClient SendEventAsync."); await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false); Console.WriteLine("DeviceClient CloseAsync."); await iotClient.CloseAsync().ConfigureAwait(false); } } }
async Task Cleanup(DeviceClient deviceClient, ServiceClient serviceClient, RegistryManager rm, string deviceName) { if (deviceClient != null) { try { await deviceClient.CloseAsync(); } catch { // ignore } } if (serviceClient != null) { await serviceClient.CloseAsync(); } // wait for the connection to be closed on the Edge side await Task.Delay(TimeSpan.FromSeconds(20)); if (rm != null) { await RegistryManagerHelper.RemoveDevice(deviceName, rm); await rm.CloseAsync(); } }
public static async Task RunSample(X509Certificate2 certificate) { using (var security = new SecurityClientX509(certificate)) using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly)) { ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(s_idScope, security, transport); Console.Write("ProvisioningClient RegisterAsync . . . "); DeviceRegistrationResult result = await provClient.RegisterAsync(); Console.WriteLine($"{result.Status}"); Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}"); if (result.Status != ProvisioningRegistrationStatusType.Assigned) { return; } IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, certificate); using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth)) { Console.WriteLine("DeviceClient OpenAsync."); await iotClient.OpenAsync(); Console.WriteLine("DeviceClient SendEventAsync."); await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage"))); Console.WriteLine("DeviceClient CloseAsync."); await iotClient.CloseAsync(); } } }
public async Task SendTelemetry(TelemetryData telemetry) { try { #if false DeviceClient dc = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey( telemetry.DeviceId, GetDeviceKey(telemetry.DeviceId) )); #else var key = await GetDeviceKey(telemetry.DeviceId); DeviceClient dc = DeviceClient.CreateFromConnectionString( $"HostName={iotHubUri};DeviceId={telemetry.DeviceId};SharedAccessKey={key}", Microsoft.Azure.Devices.Client.TransportType.Amqp); #endif var text = JsonConvert.SerializeObject(telemetry); var buffer = Encoding.UTF8.GetBytes(text); await dc.SendEventAsync(new Microsoft.Azure.Devices.Client.Message(buffer)); await dc.CloseAsync(); } catch (Exception exp) { System.Diagnostics.Trace.WriteLine($"[SendTelemetry]{exp.Message}"); System.Diagnostics.Trace.WriteLine($"Stack Trace: {exp.StackTrace}"); if (exp.InnerException != null) { System.Diagnostics.Trace.WriteLine($" - {exp.InnerException.Message}"); System.Diagnostics.Trace.WriteLine($" - {exp.InnerException.StackTrace}"); } throw; } }
private async Task InitializeAndSetupClientAsync(CancellationToken cancellationToken) { if (ShouldClientBeInitialized(s_connectionStatus)) { // Allow a single thread to dispose and initialize the client instance. await _initSemaphore.WaitAsync(cancellationToken); try { if (ShouldClientBeInitialized(s_connectionStatus)) { _logger.LogDebug($"Attempting to initialize the client instance, current status={s_connectionStatus}"); // If the device client instance has been previously initialized, close and dispose it. if (s_deviceClient != null) { try { await s_deviceClient.CloseAsync(cancellationToken); } catch (UnauthorizedException) { } // if the previous token is now invalid, this call may fail s_deviceClient.Dispose(); } s_deviceClient = DeviceClient.CreateFromConnectionString(_deviceConnectionStrings.First(), _transportType, _clientOptions); s_deviceClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler); _logger.LogDebug("Initialized the client instance."); } } finally { _initSemaphore.Release(); } // Force connection now. // We have set the "shouldExecuteOperation" function to always try to open the connection. // OpenAsync() is an idempotent call, it has the same effect if called once or multiple times on the same client. await RetryOperationHelper.RetryTransientExceptionsAsync( operationName : "OpenConnection", asyncOperation : async() => await s_deviceClient.OpenAsync(cancellationToken), shouldExecuteOperation : () => true, logger : _logger, exceptionsToBeIgnored : _exceptionsToBeIgnored, cancellationToken : cancellationToken); _logger.LogDebug($"The client instance has been opened."); // You will need to subscribe to the client callbacks any time the client is initialized. await RetryOperationHelper.RetryTransientExceptionsAsync( operationName : "SubscribeTwinUpdates", asyncOperation : async() => await s_deviceClient.SetDesiredPropertyUpdateCallbackAsync(HandleTwinUpdateNotificationsAsync, cancellationToken), shouldExecuteOperation : () => IsDeviceConnected, logger : _logger, exceptionsToBeIgnored : _exceptionsToBeIgnored, cancellationToken : cancellationToken); _logger.LogDebug("The client has subscribed to desired property update notifications."); } }