SubscriptionProcessor is now set up to use ScopedMessageHandler (#473)

* SubscriptionProcessor is now set up to use ScopedMessageHandler by default, so that individual jobs don't have to do same setup over and over.

* Added specific check for the case when `ISubscriptionProcessor<T>` is not configured in the DI, suggesting to use the default setup from `SubcriptionProcessorJob<T>`.
Update jobs code to include a call to that helper method.

Author: agr

src/Validation.Common.Job/JsonConfigurationJob.cs

@@ -184,7 +184,16 @@ private void ConfigureLibraries(IServiceCollection services)
             services.AddLogging();
         }
 
+        /// <summary>
+        /// Method to be implemented in derived classes to provide Autofac-specific configuration for
+        /// that specific job (like setting up keyed resolution).
+        /// </summary>
         protected abstract void ConfigureAutofacServices(ContainerBuilder containerBuilder);
+
+        /// <summary>
+        /// Method to be implemented in derived classes to provide DI container configuration
+        /// specific for the job.
+        /// </summary>
         protected abstract void ConfigureJobServices(IServiceCollection services, IConfigurationRoot configurationRoot);
     }
 }

src/Validation.Common.Job/SubcriptionProcessorJob.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Threading.Tasks;
+using Autofac;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using NuGet.Services.ServiceBus;
@@ -19,7 +20,13 @@ public abstract class SubcriptionProcessorJob<T> : JsonConfigurationJob
 
         public override async Task Run()
         {
-            var processor = _serviceProvider.GetRequiredService<ISubscriptionProcessor<T>>();
+            var processor = _serviceProvider.GetService<ISubscriptionProcessor<T>>();
+
+            if (processor == null)
+            {
+                throw new Exception($"DI container was not set up to produce instances of ISubscriptionProcessor<{typeof(T).Name}>. " +
+                    $"Call SubcriptionProcessorJob<T>.ConfigureDefaultSubscriptionProcessor() or set it up your way.");
+            }
 
             processor.Start();
 
@@ -33,5 +40,21 @@ public override async Task Run()
                     processor.NumberOfMessagesInProgress);
             }
         }
+
+        protected static void ConfigureDefaultSubscriptionProcessor(ContainerBuilder containerBuilder)
+        {
+            const string bindingKey = "SubscriptionProcessorJob_SubscriptionProcessorKey";
+
+            containerBuilder
+                .RegisterType<ScopedMessageHandler<T>>()
+                .Keyed<IMessageHandler<T>>(bindingKey);
+
+            containerBuilder
+                .RegisterType<SubscriptionProcessor<T>>()
+                .WithParameter(
+                    (parameter, context) => parameter.ParameterType == typeof(IMessageHandler<T>),
+                    (parameter, context) => context.ResolveKeyed(bindingKey, typeof(IMessageHandler<T>)))
+                .As<ISubscriptionProcessor<T>>();
+        }
     }
 }

src/Validation.PackageSigning.ProcessSignature/Job.cs

@@ -68,26 +68,14 @@ protected override void ConfigureJobServices(IServiceCollection services, IConfi
 
         protected override void ConfigureAutofacServices(ContainerBuilder containerBuilder)
         {
-            const string validateSignatureBindingKey = "ValidateSignatureKey";
-            var signatureValidationMessageHandlerType = typeof(IMessageHandler<SignatureValidationMessage>);
+            ConfigureDefaultSubscriptionProcessor(containerBuilder);
 
             containerBuilder
                 .RegisterType<ValidatorStateService>()
                 .WithParameter(
                     (pi, ctx) => pi.ParameterType == typeof(string),
                     (pi, ctx) => ValidatorName.PackageSignatureProcessor)
                 .As<IValidatorStateService>();
-
-            containerBuilder
-                .RegisterType<ScopedMessageHandler<SignatureValidationMessage>>()
-                .Keyed<IMessageHandler<SignatureValidationMessage>>(validateSignatureBindingKey);
-
-            containerBuilder
-                .RegisterType<SubscriptionProcessor<SignatureValidationMessage>>()
-                .WithParameter(
-                    (parameter, context) => parameter.ParameterType == signatureValidationMessageHandlerType,
-                    (parameter, context) => context.ResolveKeyed(validateSignatureBindingKey, signatureValidationMessageHandlerType))
-                .As<ISubscriptionProcessor<SignatureValidationMessage>>();
         }
     }
 }

src/Validation.PackageSigning.ValidateCertificate/Job.cs

@@ -47,19 +47,7 @@ protected override void ConfigureJobServices(IServiceCollection services, IConfi
 
         protected override void ConfigureAutofacServices(ContainerBuilder containerBuilder)
         {
-            const string validateCertificateBindingKey = "ValidateCertificateKey";
-            var certificateValidationMessageHandlerType = typeof(IMessageHandler<CertificateValidationMessage>);
-
-            containerBuilder
-                .RegisterType<ScopedMessageHandler<CertificateValidationMessage>>()
-                .Keyed<IMessageHandler<CertificateValidationMessage>>(validateCertificateBindingKey);
-
-            containerBuilder
-                .RegisterType<SubscriptionProcessor<CertificateValidationMessage>>()
-                .WithParameter(
-                    (parameter, context) => parameter.ParameterType == certificateValidationMessageHandlerType,
-                    (parameter, context) => context.ResolveKeyed(validateCertificateBindingKey, certificateValidationMessageHandlerType))
-                .As<ISubscriptionProcessor<CertificateValidationMessage>>();
+            ConfigureDefaultSubscriptionProcessor(containerBuilder);
         }
     }
 }