Merge pull request #129 from Azure-Samples/drwill/deviceSamples

Hardcode client version, improve TransportType selection, remove ConfigureAwait, and misc code cleanup

Author: David R. Williamson

iot-hub/Samples/common/DeviceStreamingCommon.cs

@@ -22,7 +22,7 @@ public static async Task<ClientWebSocket> GetStreamingClientAsync(Uri url, strin
             var wsClient = new ClientWebSocket();
             wsClient.Options.SetRequestHeader("Authorization", "Bearer " + authorizationToken);
 
-            await wsClient.ConnectAsync(url, cancellationToken).ConfigureAwait(false);
+            await wsClient.ConnectAsync(url, cancellationToken);
 
             return wsClient;
         }

iot-hub/Samples/device/DeviceReconnectionSample/ColorConsoleLogger.cs

@@ -13,17 +13,15 @@ namespace Microsoft.Azure.Devices.Client.Samples
     /// </summary>
     public class ColorConsoleLogger : ILogger
     {
-        private readonly string _name;
         private readonly ColorConsoleLoggerConfiguration _config;
 
         /// <summary>
         /// Initializes an instance of <see cref="ColorConsoleLogger"/>.
         /// </summary>
         /// <param name="name">The category name for each <see cref="ILogger"/> instance. This is usually the class name where the logger is initialized.</param>
         /// <param name="config">The <see cref="ColorConsoleLoggerConfiguration"/> settings to be used for logging.</param>
-        public ColorConsoleLogger(string name, ColorConsoleLoggerConfiguration config)
+        public ColorConsoleLogger(ColorConsoleLoggerConfiguration config)
         {
-            _name = name;
             _config = config;
         }
 
@@ -32,7 +30,6 @@ public ColorConsoleLogger(string name, ColorConsoleLoggerConfiguration config)
         /// </summary>
         /// <typeparam name="TState">The type of the state to begin scope for.</typeparam>
         /// <param name="state">The identifier for the scope.</param>
-        /// <returns></returns>
         public IDisposable BeginScope<TState>(TState state)
         {
             throw new NotImplementedException();
@@ -42,7 +39,6 @@ public IDisposable BeginScope<TState>(TState state)
         /// Checks if the given log level is enabled.
         /// </summary>
         /// <param name="logLevel">The log level to be checked.</param>
-        /// <returns></returns>
         public bool IsEnabled(LogLevel logLevel)
         {
             return logLevel >= _config.MinLogLevel;

iot-hub/Samples/device/DeviceReconnectionSample/ColorConsoleLoggerConfiguration.cs

@@ -15,49 +15,19 @@ public class ColorConsoleLoggerConfiguration
         // If the EventId is set to 0, the logger will log all events.
         internal const int DefaultEventId = 0;
 
-        private static readonly IReadOnlyDictionary<LogLevel, ConsoleColor> s_defaultColorMapping = new Dictionary<LogLevel, ConsoleColor>
+        /// <summary>
+        /// A dictionary containing the log level to console color mappings to be used while writing log entries to the console.
+        /// </summary>
+        public IReadOnlyDictionary<LogLevel, ConsoleColor> LogLevelToColorMapping { get; } = new Dictionary<LogLevel, ConsoleColor>
         {
             { LogLevel.Trace, ConsoleColor.Blue },
             { LogLevel.Debug, ConsoleColor.DarkYellow },
             { LogLevel.Information, ConsoleColor.Cyan },
             { LogLevel.Warning, ConsoleColor.DarkMagenta },
             { LogLevel.Error, ConsoleColor.Red },
-            { LogLevel.Critical, ConsoleColor.DarkRed }
+            { LogLevel.Critical, ConsoleColor.DarkRed },
         };
 
-        /// <summary>
-        /// Initialize an instance of <see cref="ColorConsoleLoggerConfiguration"/> with default color mappings.
-        /// </summary>
-        public ColorConsoleLoggerConfiguration()
-        {
-            LogLevelToColorMapping = s_defaultColorMapping;
-        }
-
-        /// <summary>
-        /// Initialize an instance of <see cref="ColorConsoleLoggerConfiguration"/> by overriding the default color mappings with the supplied custom mappings.
-        /// </summary>
-        /// <param name="customConsoleColorMapping">A dictionary of log level to console color mapping that will be used to override the default color mapping.</param>
-        public ColorConsoleLoggerConfiguration(IDictionary<LogLevel, ConsoleColor> customConsoleColorMapping)
-            : this ()
-        {
-            var map = (IDictionary<LogLevel, ConsoleColor> )LogLevelToColorMapping;
-
-            // If a custom color mapping is provided, use it to override the default color mapping.
-            foreach (KeyValuePair<LogLevel, ConsoleColor> entry in customConsoleColorMapping)
-            {
-                if (map.ContainsKey(entry.Key))
-                {
-                    map[entry.Key] = entry.Value;
-                }
-            }
-            LogLevelToColorMapping = (IReadOnlyDictionary<LogLevel, ConsoleColor>)map;
-        }
-
-        /// <summary>
-        /// A dictionary containing the log level to console color mappings to be used while writing log entries to the console.
-        /// </summary>
-        public IReadOnlyDictionary<LogLevel, ConsoleColor> LogLevelToColorMapping { get; }
-
         /// <summary>
         /// The min log level that will be written to the console, defaults to <see cref="LogLevel.Information"/>.
         /// </summary>
@@ -66,6 +36,6 @@ public ColorConsoleLoggerConfiguration(IDictionary<LogLevel, ConsoleColor> custo
         /// <summary>
         /// The list of event Ids to be written to the console. By default, all event Ids are written.
         /// </summary>
-        public IEnumerable<int> EventIds { get; set; } = new List<int>() { DefaultEventId };
+        public IEnumerable<int> EventIds { get; } = new int[] { DefaultEventId };
     }
 }

iot-hub/Samples/device/DeviceReconnectionSample/ColorConsoleLoggerProvider.cs

@@ -30,7 +30,7 @@ public ColorConsoleLoggerProvider(ColorConsoleLoggerConfiguration config)
         /// <returns>The created <see cref="ILogger"/> instance.</returns>
         public ILogger CreateLogger(string categoryName)
         {
-            return _loggers.GetOrAdd(categoryName, name => new ColorConsoleLogger(name, _config));
+            return _loggers.GetOrAdd(categoryName, name => new ColorConsoleLogger(_config));
         }
 
         /// <summary>

iot-hub/Samples/device/DeviceReconnectionSample/DeviceReconnectionSample.cs

@@ -35,6 +35,52 @@ public DeviceReconnectionSample(string deviceConnectionString, TransportType tra
             InitializeClient();
         }
 
+        public async Task RunSampleAsync()
+        {
+            using var cts = new CancellationTokenSource();
+
+            Console.CancelKeyPress += (sender, eventArgs) =>
+            {
+                eventArgs.Cancel = true;
+                cts.Cancel();
+                _logger.LogInformation("Sample execution cancellation requested; will exit.");
+            };
+
+            try
+            {
+                await Task.WhenAll(SendMessagesAsync(cts.Token), ReceiveMessagesAsync(cts.Token));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"Unrecoverable exception caught, user action is required, so exiting...: \n{ex}");
+            }
+        }
+
+        private void InitializeClient()
+        {
+            // If the client reports Connected status, it is already in operational state.
+            if (s_connectionStatus != ConnectionStatus.Connected)
+            {
+                lock (_lock)
+                {
+                    _logger.LogDebug($"Attempting to initialize the client instance, current status={s_connectionStatus}");
+
+                    // If the device client instance has been previously initialized, then dispose it.
+                    // The s_wasEverConnected variable is required to store if the client ever reported Connected status.
+                    if (s_wasEverConnected && s_connectionStatus == ConnectionStatus.Disconnected)
+                    {
+                        s_deviceClient?.Dispose();
+                        s_wasEverConnected = false;
+                    }
+
+                    s_deviceClient = DeviceClient.CreateFromConnectionString(_deviceConnectionString, _transportType);
+                    s_deviceClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler);
+                    s_deviceClient.OperationTimeoutInMilliseconds = (uint)s_operationTimeout.TotalMilliseconds;
+                    _logger.LogDebug($"Initialized the client instance.");
+                }
+            }
+        }
+
         private void ConnectionStatusChangeHandler(ConnectionStatus status, ConnectionStatusChangeReason reason)
         {
             _logger.LogDebug($"Connection status changed: status={status}, reason={reason}");
@@ -98,59 +144,13 @@ private void ConnectionStatusChangeHandler(ConnectionStatus status, ConnectionSt
             }
         }
 
-        public async Task RunSampleAsync()
-        {
-            using var cts = new CancellationTokenSource();
-
-            Console.CancelKeyPress += (sender, eventArgs) =>
-            {
-                eventArgs.Cancel = true;
-                cts.Cancel();
-                _logger.LogInformation("Sample execution cancellation requested, will exit.");
-            };
-
-            try
-            {
-                await Task.WhenAll(SendMessagesAsync(cts.Token), ReceiveMessagesAsync(cts.Token));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError($"Unrecoverable exception caught, user action is required, so exiting...: \n{ex}");
-            }
-        }
-
-        private void InitializeClient()
-        {
-            // If the client reports Connected status, it is already in operational state.
-            if (s_connectionStatus != ConnectionStatus.Connected)
-            {
-                lock (_lock)
-                {
-                    _logger.LogDebug($"Attempting to initialize the client instance, current status={s_connectionStatus}");
-
-                    // If the device client instance has been previously initialized, then dispose it.
-                    // The s_wasEverConnected variable is required to store if the client ever reported Connected status.
-                    if (s_wasEverConnected && s_connectionStatus == ConnectionStatus.Disconnected)
-                    {
-                        s_deviceClient?.Dispose();
-                        s_wasEverConnected = false;
-                    }
-
-                    s_deviceClient = DeviceClient.CreateFromConnectionString(_deviceConnectionString, _transportType);
-                    s_deviceClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler);
-                    s_deviceClient.OperationTimeoutInMilliseconds = (uint)s_operationTimeout.TotalMilliseconds;
-                    _logger.LogDebug($"Initialized the client instance.");
-                }
-            }
-        }
-
         private async Task SendMessagesAsync(CancellationToken cancellationToken)
         {
             int count = 0;
+
             while (!cancellationToken.IsCancellationRequested)
             {
-                count++;
-                _logger.LogInformation($"Device sending message {count} to IoTHub...");
+                _logger.LogInformation($"Device sending message {count++} to IoTHub...");
 
                 try
                 {
@@ -218,24 +218,23 @@ private async Task SendMessageAsync(int count)
         private async Task ReceiveMessageAndCompleteAsync()
         {
             using Message receivedMessage = await s_deviceClient.ReceiveAsync(s_sleepDuration);
-            if (receivedMessage != null)
+            if (receivedMessage == null)
             {
-                string messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
-                _logger.LogInformation($"Received message: {messageData}");
+                _logger.LogInformation("No message received, timed out");
+                return;
+            }
 
-                int propCount = 0;
-                foreach (var prop in receivedMessage.Properties)
-                {
-                    _logger.LogInformation($"Property[{propCount++}> Key={prop.Key} : Value={prop.Value}");
-                }
+            string messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes());
+            var formattedMessage = new StringBuilder($"Received message: {messageData}\n");
 
-                await s_deviceClient.CompleteAsync(receivedMessage);
-                _logger.LogInformation($"Marked message [{messageData}] as \"Complete\".");
-            }
-            else
+            foreach (var prop in receivedMessage.Properties)
             {
-                _logger.LogWarning("No message received, timed out");
+                formattedMessage.AppendLine($"\tProperty: key={prop.Key}, value={prop.Value}");
             }
+            _logger.LogInformation(formattedMessage.ToString());
+
+            await s_deviceClient.CompleteAsync(receivedMessage);
+            _logger.LogInformation($"Completed message [{messageData}].");
         }
     }
 }

iot-hub/Samples/device/DeviceReconnectionSample/DeviceReconnectionSample.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

iot-hub/Samples/device/DeviceReconnectionSample/Program.cs

@@ -10,8 +10,6 @@ namespace Microsoft.Azure.Devices.Client.Samples
 {
     public class Program
     {
-        private const string SdkEventProviderPrefix = "Microsoft-Azure-";
-
         // String containing Hostname, Device Id & Device Key in one of the following formats:
         //  "HostName=<iothub_host_name>;DeviceId=<device_id>;SharedAccessKey=<device_key>"
         //  "HostName=<iothub_host_name>;CredentialType=SharedAccessSignature;DeviceId=<device_id>;SharedAccessSignature=SharedAccessSignature sr=<iot_host>/devices/<device_id>&sig=<token>&se=<expiry_time>";
@@ -22,11 +20,15 @@ public class Program
         // - create a launchSettings.json (see launchSettings.json.template) containing the variable
         private static string s_deviceConnectionString = Environment.GetEnvironmentVariable("IOTHUB_DEVICE_CONN_STRING");
 
-        // Select one of the following transports used by DeviceClient to connect to IoT Hub.
-        private static TransportType s_transportType = TransportType.Amqp;
-        //private static TransportType s_transportType = TransportType.Mqtt;
-        //private static TransportType s_transportType = TransportType.Amqp_WebSocket_Only;
-        //private static TransportType s_transportType = TransportType.Mqtt_WebSocket_Only;
+        // Specify one of the following transports used by DeviceClient to connect to IoT Hub.
+        //   Mqtt
+        //   Mqtt_WebSocket_Only
+        //   Mqtt_Tcp_Only
+        //   Amqp
+        //   Amqp_WebSocket_Only
+        //   Amqp_Tcp_only
+        //   Http1
+        private static readonly string s_transportType = Environment.GetEnvironmentVariable("IOTHUB_DEVICE_TRANSPORT_TYPE");
 
         public static async Task<int> Main(string[] args)
         {
@@ -40,18 +42,40 @@ public static async Task<int> Main(string[] args)
                     MinLogLevel = LogLevel.Debug,
                 });
             var logger = loggerFactory.CreateLogger<Program>();
-            var sdkEventListener = new ConsoleEventListener(SdkEventProviderPrefix, logger);
+
+            const string SdkEventProviderPrefix = "Microsoft-Azure-";
+            // Instantiating this seems to do all we need for outputing SDK events to our console log
+            _ = new ConsoleEventListener(SdkEventProviderPrefix, logger);
 
             if (string.IsNullOrEmpty(s_deviceConnectionString) && args.Length > 0)
             {
                 s_deviceConnectionString = args[0];
             }
 
-            var sample = new DeviceReconnectionSample(s_deviceConnectionString, s_transportType, logger);
+            var sample = new DeviceReconnectionSample(s_deviceConnectionString, GetTransportType(args), logger);
             await sample.RunSampleAsync();
 
-            logger.LogInformation("Done, exiting...");
+            logger.LogInformation("Done.");
             return 0;
         }
+
+        private static TransportType GetTransportType(string[] args)
+        {
+            // Check environment variable for transport type
+            if (Enum.TryParse(s_transportType, true, out TransportType transportType))
+            {
+                return transportType;
+            }
+
+                // then check argument for transport type
+            if (args.Length > 1
+                && Enum.TryParse(args[1], true, out transportType))
+            {
+                return transportType;
+            }
+
+                    // otherwise default to MQTT
+            return TransportType.Mqtt;
+        }
     }
 }

iot-hub/Samples/device/DeviceStreamingSample/DeviceClientStreamingSample.csproj

@@ -3,6 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
+    <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>