Make validator provider cache the types it discovers (#370)

Progress on NuGet/Engineering#1190

Author: joelverhagen

src/NuGet.Services.Validation.Orchestrator/ValidatorProvider.cs

@@ -12,57 +12,85 @@ namespace NuGet.Services.Validation.Orchestrator
 {
     public class ValidatorProvider : IValidatorProvider
     {
+        /// <summary>
+        /// This is a cache of all of the <see cref="IValidator"/> and <see cref="IProcessor"/> implementations
+        /// available.
+        /// </summary>
+        private static EvaluatedTypes _evaluatedTypes;
+        private static object _evaluatedTypesLock = new object();
+
         private readonly IServiceProvider _serviceProvider;
         private readonly ILogger<ValidatorProvider> _logger;
-        private readonly Dictionary<string, Type> _validatorTypes;
-        private readonly Dictionary<string, Type> _processorTypes;
 
         public ValidatorProvider(IServiceProvider serviceProvider, ILogger<ValidatorProvider> logger)
         {
             _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
-            using (_logger.BeginScope("Enumerating all IValidator implementations"))
+            InitializeEvaluatedTypes(Assembly.GetCallingAssembly());
+        }
+
+        /// <summary>
+        /// Discovers all <see cref="IValidator"/> and <see cref="IProcessor"/> types available and caches the result.
+        /// </summary>
+        private void InitializeEvaluatedTypes(Assembly callingAssembly)
+        {
+            if (_evaluatedTypes != null)
+            {
+                return;
+            }
+
+            lock (_evaluatedTypesLock)
             {
-                _logger.LogTrace("Before enumeration");
-                IEnumerable<Type> candidateTypes = GetCandidateTypes(Assembly.GetCallingAssembly());
-
-                _validatorTypes = candidateTypes
-                    .Where(type => typeof(IValidator).IsAssignableFrom(type)
-                           && type != typeof(IValidator)
-                           && type != typeof(IProcessor))
-                    .ToDictionary(type => type.Name);
-
-                _processorTypes = _validatorTypes
-                    .Values
-                    .Where(IsProcessor)
-                    .ToDictionary(type => type.Name);
-
-                _logger.LogTrace("After enumeration, got {NumImplementations} implementations: {TypeNames}",
-                    _validatorTypes.Count,
-                    _validatorTypes.Keys);
+                if (_evaluatedTypes != null)
+                {
+                    return;
+                }
+
+                using (_logger.BeginScope("Enumerating all IValidator implementations"))
+                {
+                    _logger.LogTrace("Before enumeration");
+                    IEnumerable<Type> candidateTypes = GetCandidateTypes(callingAssembly);
+
+                    var validatorTypes = candidateTypes
+                        .Where(type => typeof(IValidator).IsAssignableFrom(type)
+                               && type != typeof(IValidator)
+                               && type != typeof(IProcessor))
+                        .ToDictionary(type => type.Name);
+
+                    var processorTypes = validatorTypes
+                        .Values
+                        .Where(IsProcessorType)
+                        .ToDictionary(type => type.Name);
+
+                    _logger.LogTrace("After enumeration, got {NumImplementations} implementations: {TypeNames}",
+                        validatorTypes.Count,
+                        validatorTypes.Keys);
+
+                    _evaluatedTypes = new EvaluatedTypes(validatorTypes, processorTypes);
+                }
             }
         }
 
         public bool IsValidator(string validatorName)
         {
             validatorName = validatorName ?? throw new ArgumentNullException(nameof(validatorName));
 
-            return _validatorTypes.ContainsKey(validatorName);
+            return _evaluatedTypes.ValidatorTypes.ContainsKey(validatorName);
         }
 
         public bool IsProcessor(string validatorName)
         {
             validatorName = validatorName ?? throw new ArgumentNullException(nameof(validatorName));
 
-            return _processorTypes.ContainsKey(validatorName);
+            return _evaluatedTypes.ProcessorTypes.ContainsKey(validatorName);
         }
 
         public IValidator GetValidator(string validatorName)
         {
             validatorName = validatorName ?? throw new ArgumentNullException(nameof(validatorName));
 
-            if (_validatorTypes.TryGetValue(validatorName, out Type validatorType))
+            if (_evaluatedTypes.ValidatorTypes.TryGetValue(validatorName, out Type validatorType))
             {
                 return (IValidator)_serviceProvider.GetRequiredService(validatorType);
             }
@@ -82,9 +110,23 @@ private static IEnumerable<Type> GetCandidateTypes(Assembly callingAssembly)
             return candidateTypes;
         }
 
-        private static bool IsProcessor(Type type)
+        private static bool IsProcessorType(Type type)
         {
             return typeof(IProcessor).IsAssignableFrom(type);
         }
+
+        private class EvaluatedTypes
+        {
+            public EvaluatedTypes(
+                IReadOnlyDictionary<string, Type> validatorTypes,
+                IReadOnlyDictionary<string, Type> processorTypes)
+            {
+                ValidatorTypes = validatorTypes ?? throw new ArgumentNullException(nameof(validatorTypes));
+                ProcessorTypes = processorTypes ?? throw new ArgumentNullException(nameof(validatorTypes));
+            }
+
+            public IReadOnlyDictionary<string, Type> ValidatorTypes { get; }
+            public IReadOnlyDictionary<string, Type> ProcessorTypes { get; }
+        }
     }
 }

tests/NuGet.Services.Validation.Orchestrator.Tests/ValidationProviderFacts.cs

@@ -2,15 +2,51 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Concurrent;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Moq;
+using Validation.PackageSigning.Core.Tests.Support;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace NuGet.Services.Validation.Orchestrator.Tests
 {
     public class ValidationProviderFacts
     {
+        public class Constructor
+        {
+            private readonly ITestOutputHelper _output;
+
+            public Constructor(ITestOutputHelper output)
+            {
+                _output = output ?? throw new ArgumentNullException(nameof(output));
+            }
+
+            [Fact]
+            public void CachesEvaluatedTypes()
+            {
+                var messages = new ConcurrentBag<string>();
+                var serviceProvider = new Mock<IServiceProvider>();
+                var loggerFactory = new LoggerFactory().AddXunit(_output);
+                var innerLogger = loggerFactory.CreateLogger<ValidatorProvider>();
+                var logger = new RecordingLogger<ValidatorProvider>(innerLogger);
+
+                _output.WriteLine("Initializing the first instance.");
+
+                var targetA = new ValidatorProvider(serviceProvider.Object, logger);
+                var messageCountA = logger.Messages.Count;
+
+                _output.WriteLine("Initializing the second instance.");
+
+                var targetB = new ValidatorProvider(serviceProvider.Object, logger);
+                var messageCountB = logger.Messages.Count;
+
+                Assert.Equal(messageCountA, messageCountB);
+            }
+        }
+
         public class IsProcessor : BaseFacts
         {
             [Theory]

…gnature.Tests/Support/RecordingLogger.cs …ng.Core.Tests/Support/RecordingLogger.cstests/Validation.PackageSigning.ExtractAndValidateSignature.Tests/Support/RecordingLogger.cs renamed to tests/Validation.PackageSigning.Core.Tests/Support/RecordingLogger.cs tests/Validation.PackageSigning.ExtractAndValidateSignature.Tests/Support/RecordingLogger.cs renamed to tests/Validation.PackageSigning.Core.Tests/Support/RecordingLogger.cs

@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 
-namespace Validation.PackageSigning.ExtractAndValidateSignature.Tests
+namespace Validation.PackageSigning.Core.Tests.Support
 {
     public class RecordingLogger<T> : ILogger<T>
     {

tests/Validation.PackageSigning.Core.Tests/Validation.PackageSigning.Core.Tests.csproj

@@ -41,6 +41,7 @@
     <Compile Include="Support\CertificateIntegrationTestFixture.cs" />
     <Compile Include="Support\DbSetMockFactory.cs" />
     <Compile Include="Support\ExtensionMethods.cs" />
+    <Compile Include="Support\RecordingLogger.cs" />
     <Compile Include="Support\TestDbAsyncEnumerable.cs" />
     <Compile Include="Support\TestDbAsyncEnumerator.cs" />
     <Compile Include="Support\TestDbAsyncQueryProvider.cs" />

tests/Validation.PackageSigning.ExtractAndValidateSignature.Tests/Validation.PackageSigning.ExtractAndValidateSignature.Tests.csproj

@@ -35,7 +35,6 @@
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Support\RecordingLogger.cs" />
     <Compile Include="Support\CertificateIntegrationTestCollection.cs" />
     <Compile Include="Support\CertificateIntegrationTestFixture.cs" />
     <Compile Include="HashFacts.cs" />