allowing AddDataProtection()

Author: brettsam

src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/DependencyValidator.cs

@@ -50,7 +50,8 @@ private static ExpectedDependencyBuilder CreateExpectedDependencies()
                 .Optional<FunctionsScaleMonitorService>()
                 .Optional<FuncAppFileProvisioningService>() // Used by powershell.
                 .Optional<JobHostService>() // Missing when host is offline.
-                .Optional<FunctionsSyncService>(); // Conditionally registered.
+                .Optional<FunctionsSyncService>() // Conditionally registered.
+                .OptionalExternal("Microsoft.AspNetCore.DataProtection.Internal.DataProtectionHostedService", "Microsoft.AspNetCore.DataProtection", "adb9793829ddae60"); // Popularly-registered by DataProtection.
 
             expected.ExpectSubcollection<ILoggerProvider>()
                 .Expect<AzureMonitorDiagnosticLoggerProvider>()

src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/ExpectedCollectionBuilder.cs

@@ -43,5 +43,11 @@ public ExpectedCollectionBuilder Optional<TImplementation>(ServiceLifetime lifet
             _match.AddOptional<TImplementation>(lifetime);
             return this;
         }
+
+        public ExpectedCollectionBuilder OptionalExternal(string externalTypeName, string assemblyName, string assemblyPublicKeyToken)
+        {
+            _match.AddOptionalExternal(externalTypeName, assemblyName, assemblyPublicKeyToken);
+            return this;
+        }
     }
 }

src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/ServiceMatch.cs

@@ -14,6 +14,11 @@ internal class ServiceMatch
     {
         private readonly ICollection<ServiceDescriptor> _requiredDescriptors = new Collection<ServiceDescriptor>();
         private readonly ICollection<ServiceDescriptor> _optionalDescriptors = new Collection<ServiceDescriptor>();
+
+        // We may not be able to load the type at all -- for example third-party services that we want to allow.
+        // For this, track the types as strings and we'll match them during IsMatch. These will always be optional.
+        private readonly ICollection<ExternalService> _optionalExternalServices = new Collection<ExternalService>();
+
         private readonly MatchType _match;
 
         private ServiceMatch(Type serviceType, MatchType match)
@@ -136,6 +141,16 @@ public void AddOptional<TImplementation>(ServiceLifetime lifetime)
             _optionalDescriptors.Add(desc);
         }
 
+        public void AddOptionalExternal(string externalTypeName, string assemblyName, string assemblyPublicKey)
+        {
+            if (_match != MatchType.Collection)
+            {
+                throw new InvalidOperationException("Optional matches only apply to Collections.");
+            }
+
+            _optionalExternalServices.Add(new ExternalService(externalTypeName, assemblyName, assemblyPublicKey));
+        }
+
         public IEnumerable<InvalidServiceDescriptor> FindInvalidServices(IServiceCollection services)
         {
             if (services == null)
@@ -163,7 +178,7 @@ public IEnumerable<InvalidServiceDescriptor> FindInvalidServices(IServiceCollect
                     return Enumerable.Empty<InvalidServiceDescriptor>();
 
                 case MatchType.Collection:
-                    return FindCollectionDifferences(registered, _requiredDescriptors, _optionalDescriptors);
+                    return FindCollectionDifferences(registered, _requiredDescriptors, _optionalDescriptors, _optionalExternalServices);
 
                 case MatchType.Subcollection:
                     return FindMissingServicesInCollection(registered, _requiredDescriptors);
@@ -201,13 +216,19 @@ private static bool IsMatch(ServiceDescriptor expected, ServiceDescriptor regist
                 expected.ServiceType == registered.ServiceType;
         }
 
-        private static IEnumerable<InvalidServiceDescriptor> FindCollectionDifferences(IEnumerable<ServiceDescriptor> registeredServices, IEnumerable<ServiceDescriptor> expectedServices, IEnumerable<ServiceDescriptor> optionalServices)
+        private static IEnumerable<InvalidServiceDescriptor> FindCollectionDifferences(IEnumerable<ServiceDescriptor> registeredServices, IEnumerable<ServiceDescriptor> expectedServices,
+            IEnumerable<ServiceDescriptor> optionalServices, IEnumerable<ExternalService> optionalExternalServices)
         {
             // Don't report optional services as missing.
             var missingServices = FindMissingServicesInCollection(registeredServices, expectedServices);
 
             var extraServices = registeredServices
-                .Where(r => !expectedServices.Any(e => IsMatch(e, r)) && !optionalServices.Any(o => IsMatch(o, r)))
+                .Where(r =>
+                {
+                    return !expectedServices.Any(e => IsMatch(e, r))
+                        && !optionalServices.Any(o => IsMatch(o, r))
+                        && !optionalExternalServices.Any(o => o.IsMatch(r.ImplementationType));
+                })
                 .Select(p => new InvalidServiceDescriptor(p, InvalidServiceDescriptorReason.Invalid));
 
             return missingServices.Concat(extraServices);
@@ -219,5 +240,52 @@ private static IEnumerable<InvalidServiceDescriptor> FindMissingServicesInCollec
                 .Where(e => !registeredServices.Any(r => IsMatch(e, r)))
                 .Select(p => new InvalidServiceDescriptor(p, InvalidServiceDescriptorReason.Missing));
         }
+
+        private class ExternalService
+        {
+            public ExternalService(string typeName, string assemblyName, string assemblyPublicKey)
+            {
+                TypeName = typeName;
+                AssemblyName = assemblyName;
+                AssemblyPublicKey = assemblyPublicKey;
+            }
+
+            public string TypeName { get; }
+
+            public string AssemblyName { get; }
+
+            public string AssemblyPublicKey { get; }
+
+            public bool IsMatch(Type serviceType)
+            {
+                if (serviceType == null)
+                {
+                    return false;
+                }
+
+                var serviceAssemblyName = serviceType.Assembly.GetName();
+
+                return serviceType.FullName == TypeName
+                    && serviceAssemblyName.Name == AssemblyName
+                    && GetPublicKeyTokenString(serviceAssemblyName.GetPublicKeyToken()) == AssemblyPublicKey;
+            }
+
+            private static string GetPublicKeyTokenString(byte[] token)
+            {
+                if (token == null || token.Length == 0)
+                {
+                    return null;
+                }
+
+                string tokenString = string.Empty;
+
+                for (int i = 0; i < token.Length; i++)
+                {
+                    tokenString += string.Format("{0:x2}", token[i]);
+                }
+
+                return tokenString;
+            }
+        }
     }
-}
+}

test/WebJobs.Script.Tests/Configuration/ExpectedDependencyBuilderTests.cs

@@ -253,14 +253,21 @@ public void ExpectCollection_OptionalService_Exists()
             services.AddSingleton<ITestSomething, TestSomethingA>();
             services.AddSingleton<ITestSomething, TestSomethingB>();
             services.AddSingleton<ITestSomething, TestSomethingC>();
+            services.AddSingleton<ITestSomething, TestSomethingD>();
+
+            services.AddSingleton<IJobHost, JobHost>();
 
             ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
 
             validator.ExpectCollection<ITestSomething>()
                 .Expect<TestSomethingA>()
                 .Optional<TestSomethingB>()
+                .OptionalExternal(typeof(TestSomethingD).FullName, typeof(TestSomethingD).Assembly.GetName().Name, null)
                 .Expect<TestSomethingC>();
 
+            validator.ExpectCollection<IJobHost>()
+                .OptionalExternal("Microsoft.Azure.WebJobs.JobHost", "Microsoft.Azure.WebJobs.Host", "31bf3856ad364e35");
+
             var invalidDescriptors = validator.FindInvalidServices(services);
             Assert.Empty(invalidDescriptors);
         }
@@ -353,6 +360,38 @@ public void ExpectSubcollection_MissingServices()
             Assert.Equal(typeof(ITestSomething), missingC.Descriptor.ServiceType);
         }
 
+        [Fact]
+        public void ExpectCollection_OptionalExternalService_IncorrectKey()
+        {
+            ServiceCollection services = new ServiceCollection();
+            services.AddSingleton<IJobHost, JobHost>();
+
+            ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
+
+            validator.ExpectCollection<IJobHost>()
+                .OptionalExternal("Microsoft.Azure.WebJobs.JobHost", "Microsoft.Azure.WebJobs.Host", "abcdef");
+
+            var invalidDescriptor = validator.FindInvalidServices(services).Single();
+            Assert.Equal(InvalidServiceDescriptorReason.Invalid, invalidDescriptor.Reason);
+            Assert.Equal(typeof(IJobHost), invalidDescriptor.Descriptor.ServiceType);
+        }
+
+        [Fact]
+        public void ExpectCollection_OptionalExternalService_Factory()
+        {
+            ServiceCollection services = new ServiceCollection();
+            services.AddSingleton<IJobHost>(s => (JobHost)null);
+
+            ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
+
+            validator.ExpectCollection<IJobHost>()
+                .OptionalExternal("Microsoft.Azure.WebJobs.JobHost", "Microsoft.Azure.WebJobs.Host", "31bf3856ad364e35");
+
+            var invalidDescriptor = validator.FindInvalidServices(services).Single();
+            Assert.Equal(InvalidServiceDescriptorReason.Invalid, invalidDescriptor.Reason);
+            Assert.Equal(typeof(IJobHost), invalidDescriptor.Descriptor.ServiceType);
+        }
+
         [Fact]
         public void ExpectNone()
         {