AddConfig using reflection (#42)

This adds a new method to the configuration utils, that allows you to
dynamically register config objects from public members of an arbitrary type.

It also modifies the old AddConfig method to use this new one, return
the config object (to make configuration easier), and accept subtypes of
VersionedConfig instead of BaseConfig.

Author: einarmo

Cognite.Config/Configuration.cs

@@ -1,6 +1,9 @@
+using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Reflection;
 using System.Text.RegularExpressions;
 using YamlDotNet.Core;
 using YamlDotNet.Core.Events;
@@ -170,6 +173,34 @@ private static int GetVersion(Dictionary<object, object> versionedConfig)
             }
             throw new ConfigurationException("The yaml configuration file should contain a 'version' tag");
         }
+        /// <summary>
+        /// Attempt to add the list of config-object types to the <see cref="ServiceCollection"/>, it looks at
+        /// the public properties of <typeparamref name="T"/>.
+        /// Applies to subtypes of the types given in <paramref name="types"/>. Having multiple candidates
+        /// for a type can be unpredictable.
+        /// </summary>
+        /// <typeparam name="T">Configuration object type</typeparam>
+        /// <param name="services">Services to add to</param>
+        /// <param name="config">Configuration object to add from</param>
+        /// <param name="types">List of types that should be added</param>
+        public static void AddConfig<T>(this IServiceCollection services, T config, params Type[] types)
+        {
+            if (!types.Any()) return;
+            foreach (var prop in typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public))
+            {
+                if (!prop.CanRead) continue;
+                foreach (var type in types)
+                {
+                    if (type.IsAssignableFrom(prop.PropertyType))
+                    {
+                        var value = prop.GetValue(config);
+                        if (value is null) break;
+                        services.AddSingleton(type, value);
+                        break;
+                    }
+                }
+            }
+        }
     }
 
     internal class TemplatedValueDeserializer : INodeDeserializer

ExtractorUtils.Test/ConfigurationTest.cs

@@ -6,6 +6,7 @@
 using Cognite.Extractor.Logging;
 using Cognite.Extractor.Metrics;
 using Cognite.Extractor.Utils;
+using Cognite.Extractor.StateStorage;
 
 namespace ExtractorUtils.Test
 {
@@ -215,5 +216,64 @@ public static void InjectConfiguration() {
             File.Delete(path2);
             File.Delete(path3);
         }
+
+        public class ExtendedCogniteConfig : CogniteConfig
+        {
+            public int DataSetId { get; set; }
+        }
+
+        public class CustomConfig
+        {
+            public string SomeValue { get; set; }
+        }
+
+        public class ExtendedConfig : VersionedConfig
+        {
+            public LoggerConfig Logger { get; set; }
+
+            public ExtendedCogniteConfig Cognite { get; set; }
+
+            public StateStoreConfig StateStore { get; set; }
+
+            public CustomConfig CustomConfig { get; set; }
+            public override void GenerateDefaults()
+            {
+                Logger = new LoggerConfig();
+            }
+        }
+
+        [Fact]
+        public static void TestExtendedConfiguration()
+        {
+            string path = "test-custom-config.yml";
+            string[] lines = {  "version: 2",
+                                "logger:",
+                                "  console:",
+                                "    level: verbose",
+                                "cognite:",
+                                "  data-set-id: 123",
+                                "custom-config:",
+                                "  some-value: value" };
+            var services = new ServiceCollection();
+
+            File.WriteAllLines(path, lines);
+
+            var config = services.AddConfig<ExtendedConfig>(path, 2);
+            services.AddConfig(config, typeof(CustomConfig));
+            using var provider = services.BuildServiceProvider();
+
+            var cogniteConfig = provider.GetRequiredService<CogniteConfig>();
+            var loggerConfig = provider.GetRequiredService<LoggerConfig>();
+            var customConfig = provider.GetRequiredService<CustomConfig>();
+
+            Assert.NotNull(cogniteConfig);
+            Assert.NotNull(loggerConfig);
+            Assert.NotNull(customConfig);
+            Assert.Equal(123, (cogniteConfig as ExtendedCogniteConfig).DataSetId);
+            Assert.Equal("value", customConfig.SomeValue);
+
+            File.Delete(path);
+
+        }
     }
 }

ExtractorUtils/Configuration/Configuration.cs

@@ -2,6 +2,7 @@
 using Cognite.Extractor.Configuration;
 using Cognite.Extractor.Logging;
 using Cognite.Extractor.Metrics;
+using Cognite.Extractor.StateStorage;
 
 namespace Cognite.Extractor.Utils
 {
@@ -21,19 +22,18 @@ public static class ConfigurationExtensions
         /// <param name="services">The service collection</param>
         /// <param name="path">Path to the file</param>
         /// <param name="acceptedConfigVersions">Accepted versions</param>
-        /// <typeparam name="T">A type that inherits from <see cref="BaseConfig"/></typeparam>
+        /// <typeparam name="T">A type that inherits from <see cref="VersionedConfig"/></typeparam>
         /// <exception cref="ConfigurationException">Thrown when the version is not valid, 
         /// the yaml file is not found or in case of yaml parsing error</exception>
-        public static void AddConfig<T>(this IServiceCollection services,
+        /// <returns>An instance of the configuration object</returns>
+        public static T AddConfig<T>(this IServiceCollection services,
                                         string path,
-                                        params int[] acceptedConfigVersions) where T : BaseConfig 
+                                        params int[] acceptedConfigVersions) where T : VersionedConfig 
         {
             var config = ConfigurationUtils.TryReadConfigFromFile<T>(path, acceptedConfigVersions);
             services.AddSingleton<T>(config);
-            services.AddSingleton(config.Cognite);
-            services.AddSingleton(config.Logger);
-            services.AddSingleton(config.Metrics);
-            services.AddSingleton(config.StateStore);
+            services.AddConfig<T>(config, typeof(CogniteConfig), typeof(LoggerConfig), typeof(MetricsConfig), typeof(StateStoreConfig));
+            return config;
         }
     }