Refactor logger aliases and default logger definitions on startup.

Author: brdeyo

VERSION

@@ -1 +1 @@
-2.1.25
+2.1.26

…ent.Core/Logging/LoggerAliasAttribute.cs …irtualClient.Contracts/AliasAttribute.cssrc/VirtualClient/VirtualClient.Core/Logging/LoggerAliasAttribute.cs renamed to src/VirtualClient/VirtualClient.Contracts/AliasAttribute.cs src/VirtualClient/VirtualClient.Core/Logging/LoggerAliasAttribute.cs renamed to src/VirtualClient/VirtualClient.Contracts/AliasAttribute.cs

@@ -1,23 +1,23 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-namespace VirtualClient.Common
+namespace VirtualClient.Contracts
 {
     using System;
     using System.Collections.Generic;
     using VirtualClient.Common.Extensions;
 
     /// <summary>
-    /// Defines one or more aliases for ILoggerProvider class.
+    /// Defines one or more aliases for a given class for reflection support.
     /// </summary>
     [AttributeUsage(validOn: AttributeTargets.Class)]
-    public class LoggerAliasAttribute : Attribute
+    public class AliasAttribute : Attribute
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="LoggerAliasAttribute"/> class.
+        /// Initializes a new instance of the <see cref="AliasAttribute"/> class.
         /// </summary>
         /// <param name="alias">Alias or aliases delimited by comma.</param>
-        public LoggerAliasAttribute(string alias)
+        public AliasAttribute(string alias)
         {
             alias.ThrowIfNullOrEmpty(nameof(alias));
             this.Aliases = alias.Split(',');

src/VirtualClient/VirtualClient.Contracts/ComponentTypeCache.cs

@@ -123,6 +123,51 @@ public bool TryGetComponentType(string componentType, [DynamicallyAccessedMember
             return type != null;
         }
 
+        /// <summary>
+        /// Returns true if 1 or more matching types exists in the type cache.
+        /// </summary>
+        /// <param name="baseType">The base type of the component (e.g. ILoggerProvider).</param>
+        /// <param name="alias">An alias for the matching type.</param>
+        /// <param name="types">A set of types having a matching alias.</param>
+        /// <returns>
+        /// True if 1 or more matching types exists in the type cache.
+        /// </returns>
+        public bool TryGetComponentTypes(Type baseType, string alias, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] out IEnumerable<Type> types)
+        {
+            baseType.ThrowIfNull(nameof(baseType));
+            alias.ThrowIfNullOrWhiteSpace(nameof(alias));
+
+            types = null;
+            List<Type> matchingAliasedTypes = new List<Type>();
+            IEnumerable<CachedComponentType> matchedTypes = this.Where(t => t.Type.IsAssignableTo(baseType));
+
+            if (matchedTypes?.Any() == true)
+            {
+                foreach (CachedComponentType matchedType in matchedTypes)
+                {
+                    if (!matchedType.Type.IsAbstract)
+                    {
+                        IEnumerable<AliasAttribute> aliases = matchedType.Type.GetCustomAttributes<AliasAttribute>();
+                        foreach (AliasAttribute attribute in aliases)
+                        {
+                            if (attribute.Aliases.Contains(alias, StringComparer.OrdinalIgnoreCase))
+                            {
+                                matchingAliasedTypes.Add(matchedType.Type);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (matchingAliasedTypes.Any())
+            {
+                types = matchingAliasedTypes;
+            }
+
+            return types != null;
+        }
+
         private static IEnumerable<string> GetAssemblies(string directoryPath)
         {
             List<string> assemblies = new List<string>();

src/VirtualClient/VirtualClient.Contracts/Constants.cs

@@ -204,6 +204,11 @@ public static class EnvironmentVariable
         /// Name = VC_SUDO_USER
         /// </summary>
         public const string VC_SUDO_USER = nameof(VC_SUDO_USER);
+
+        /// <summary>
+        /// Name = VC_TEMP_DIR
+        /// </summary>
+        public const string VC_TEMP_DIR = nameof(VC_TEMP_DIR);
     }
 
     /// <summary>

src/VirtualClient/VirtualClient.Contracts/PlatformSpecifics.cs

@@ -151,7 +151,7 @@ public PlatformSpecifics(PlatformID platform, Architecture architecture, string
         /// <summary>
         /// The directory where scripts related to workloads exist.
         /// </summary>
-        public string TempDirectory { get; }
+        public string TempDirectory { get; set; }
 
         /// <summary>
         /// The directory where built-in tools/toolsets are stored.

src/VirtualClient/VirtualClient.Contracts/VirtualClientComponent.cs

@@ -236,6 +236,24 @@ public EnvironmentLayout Layout
             }
         }
 
+        /// <summary>
+        /// The name of the file to which log files should be
+        /// written (e.g. ipmiutil -> ipmiutil_sel.log).
+        /// </summary>
+        public string LogFileName
+        {
+            get
+            {
+                this.Parameters.TryGetValue(nameof(VirtualClientComponent.LogFileName), out IConvertible logFileName);
+                return logFileName?.ToString();
+            }
+
+            protected set
+            {
+                this.Parameters[nameof(this.LogFolderName)] = value;
+            }
+        }
+
         /// <summary>
         /// The name of the directory/folder to which log files should be
         /// written (e.g. geekbench -> ./logs/geekbench).

src/VirtualClient/VirtualClient.Contracts/VirtualClientRuntime.cs

@@ -57,6 +57,16 @@ public static class VirtualClientRuntime
         /// </summary>
         public static string[] CommandLineArguments { get; internal set; }
 
+        /// <summary>
+        /// Metadata provided to VC on the command line.
+        /// </summary>
+        public static IReadOnlyDictionary<string, IConvertible> CommandLineMetadata { get; internal set; }
+
+        /// <summary>
+        /// Parameters provided to VC on the command line.
+        /// </summary>
+        public static IReadOnlyDictionary<string, IConvertible> CommandLineParameters { get; internal set; }
+
         /// <summary>
         /// The current experiment ID for the application.
         /// </summary>

src/VirtualClient/VirtualClient.Core/Configuration/DefaultSettings.cs

@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace VirtualClient.Configuration
+{
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Represents default settings for the application.
+    /// </summary>
+    public class DefaultSettings
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultSettings"/> class.
+        /// </summary>
+        public DefaultSettings()
+        {
+        }
+
+        /// <summary>
+        /// The default directory to write log files.
+        /// </summary>
+        public string LogDirectory { get; set; }
+
+        /// <summary>
+        /// The default log-to-file instruction.
+        /// </summary>
+        public bool LogToFile { get; set; }
+
+        /// <summary>
+        /// The default loggers for the application.
+        /// </summary>
+        public IEnumerable<string> Loggers { get; set; }
+
+        /// <summary>
+        /// The default directory to install (and search for) packages.
+        /// </summary>
+        public string PackageDirectory { get; set; }
+
+        /// <summary>
+        /// The default directory for state files/state management.
+        /// </summary>
+        public string StateDirectory { get; set; }
+
+        /// <summary>
+        /// The default directory for temp files.
+        /// </summary>
+        public string TempDirectory { get; set; }
+
+        /// <summary>
+        /// Creates the defaults for the application.
+        /// </summary>
+        public static DefaultSettings Create()
+        {
+            return new DefaultSettings
+            {
+                LogToFile = false,
+                LogDirectory = "./logs",
+                PackageDirectory = "./packages",
+                StateDirectory = "./state",
+                TempDirectory = "./temp",
+                Loggers = new string[] { "console" }
+            };
+        }
+    }
+}

src/VirtualClient/VirtualClient.Core/DependencyFactory.cs

@@ -248,6 +248,29 @@ public static IEnumerable<ILoggerProvider> CreateEventHubLoggerProviders(Depende
             return loggerProviders;
         }
 
+        /// <summary>
+        /// Creates logger providers for writing telemetry to local CSV files.
+        /// </summary>
+        /// <param name="logFileDirectory">The path to the directory where log files are written.</param>
+        public static IEnumerable<ILoggerProvider> CreateCsvFileLoggerProviders(string logFileDirectory)
+        {
+            logFileDirectory.ThrowIfNullOrWhiteSpace(nameof(logFileDirectory));
+
+            // 20MB
+            // General Sizing:
+            // Around 34,400 metric records will fit inside of a single CSV file at 20MB.
+            const long maxFileSizeBytes = 20000000;
+
+            List<ILoggerProvider> loggerProviders = new List<ILoggerProvider>();
+
+            string metricsCsvFilePath = Path.Combine(logFileDirectory, "metrics.csv");
+            ILoggerProvider metricsCsvProvider = new MetricsCsvFileLoggerProvider(metricsCsvFilePath, maxFileSizeBytes);
+            loggerProviders.Add(metricsCsvProvider);
+            VirtualClientRuntime.CleanupTasks.Add(new Action_(() => metricsCsvProvider.Dispose()));
+
+            return loggerProviders;
+        }
+
         /// <summary>
         /// Creates logger providers for writing telemetry to local log files.
         /// </summary>
@@ -295,30 +318,6 @@ public static ILoggerProvider CreateFileLoggerProvider(string logFilePath, TimeS
             return loggerProvider;
         }
 
-        /// <summary>
-        /// Creates logger providers for writing telemetry to local CSV files.
-        /// </summary>
-        /// <param name="csvFilePath">The full path for the log file (e.g. C:\users\any\VirtualClient\logs\metrics.csv).</param>
-        public static ILoggerProvider CreateCsvFileLoggerProvider(string csvFilePath)
-        {
-            csvFilePath.ThrowIfNullOrWhiteSpace(nameof(csvFilePath));
-
-            // 20MB
-            // General Sizing:
-            // Around 34,400 metric records will fit inside of a single CSV file at 20MB.
-            const long maxFileSizeBytes = 20000000;
-
-            ILoggerProvider loggerProvider = null;
-
-            if (!string.IsNullOrWhiteSpace(csvFilePath))
-            {
-                loggerProvider = new MetricsCsvFileLoggerProvider(csvFilePath, maxFileSizeBytes);
-                VirtualClientRuntime.CleanupTasks.Add(new Action_(() => loggerProvider.Dispose()));
-            }
-
-            return loggerProvider;
-        }
-
         /// <summary>
         /// Creates logger providers for writing telemetry to local log files.
         /// </summary>
@@ -356,24 +355,17 @@ public static IEnumerable<ILoggerProvider> CreateFileLoggerProviders(string logF
 
                 // Metrics/Results
                 ILoggerProvider metricsLoggerProvider = DependencyFactory.CreateFileLoggerProvider(
-                    Path.Combine(logFileDirectory, settings.MetricsFileName), 
-                    TimeSpan.FromSeconds(3), 
+                    Path.Combine(logFileDirectory, settings.MetricsFileName),
+                    TimeSpan.FromSeconds(3),
                     LogLevel.Trace,
                     new SerilogJsonTextFormatter(propertiesToExcludeForMetrics)).HandleMetrics();
 
                 loggerProviders.Add(metricsLoggerProvider);
 
-                // Metrics/Results in CSV Format
-                ILoggerProvider metricsCsvLoggerProvider = DependencyFactory.CreateCsvFileLoggerProvider(
-                    Path.Combine(logFileDirectory, 
-                    settings.MetricsCsvFileName)).HandleMetrics();
-
-                loggerProviders.Add(metricsCsvLoggerProvider);
-
                 // System Events
                 ILoggerProvider eventsLoggerProvider = DependencyFactory.CreateFileLoggerProvider(
-                    Path.Combine(logFileDirectory, settings.EventsFileName), 
-                    TimeSpan.FromSeconds(5), 
+                    Path.Combine(logFileDirectory, settings.EventsFileName),
+                    TimeSpan.FromSeconds(5),
                     LogLevel.Trace,
                     new SerilogJsonTextFormatter(propertiesToExcludeForEvents)).HandleSystemEvents();
 

src/VirtualClient/VirtualClient.Core/Logging/Console/ConsoleLoggerProvider.cs

@@ -4,13 +4,11 @@
 namespace VirtualClient.Logging
 {
     using Microsoft.Extensions.Logging;
-    using VirtualClient.Common;
 
     /// <summary>
     /// A very thin settings passthrough provider as a stop gap to handle the missing obsoleted functionality .NET Core 2.2 and .NET Core 3.0 implementation.
     /// See https://github.com/aspnet/EntityFramework.Docs/pull/1164 for full discussion of issue.
     /// </summary>
-    [LoggerAlias("Console")]
     public sealed class ConsoleLoggerProvider : ILoggerProvider
     {
         /// <summary>