refactor: Dependency Injection Registration and OperatorBuilder

This allows one controller to support more than one entity type and/or
one entity-type to be managed by more than one controller.
It is not recommended to implement the latter case, as the watchers
will pass the same object version to all controllers
and there will be race conditions as all controllers are called
simultaneously.

All the `...Type` classes and their generic variants are removed in favor of
adding registrations in `IComponentRegistrar`

Additionally, any special logic for instantiating these registrations should be
encapsulated in separate classes such as with `IControllerInstanceBuilder` in
order to avoid violating SRP as much as possible (introducing that much
reflection can really distract from what a class is really meant to handle).

BREAKING CHANGE: `EntityRbacAttribute` and `GenericRbacAttribute`
are now only found when added to Kubernetes "relevant" classes.
Instead of scanning all assemblies for those attributes, only
controllers, finalizers and webhooks may be decorated and considered
when generating the RBAC rules in the generator. To migrate,
add any of the attributes above to a controller, finalizer or webhook
instead of anywhere else in the code.

Author: erin-allison

config/Common.targets

@@ -12,6 +12,9 @@
         <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
             <_Parameter1>$(MSBuildProjectName).Test</_Parameter1>
         </AssemblyAttribute>
+        <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+            <_Parameter1>$(MSBuildProjectName).TestOperator.Test</_Parameter1>
+        </AssemblyAttribute>
         <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
             <!--So that internals are visible to the Moq library-->
             <_Parameter1>DynamicProxyGenAssembly2</_Parameter1>

docs/docs/advanced.md

@@ -0,0 +1,60 @@
+# Advanced Topics
+
+## Assembly Scanning
+
+By default, KubeOps scans the assembly containing the main entrypoint for 
+controller, finalizer, webhook and entity types, and automatically registers
+all types that implement the correct interfaces for usage.
+
+If some of the above are stored in a different assembly, KubeOps must be
+specifically instructed to scan that assembly <xref:KubeOps.Operator.Builder.IOperatorBuilder.AddResourceAssembly(System.Reflection.Assembly)> or else those types won't be loaded.
+
+```csharp
+public class Startup
+{
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.AddKubernetesOperator()
+            .AddResourceAssembly(typeof(CustomEntityController).Assembly)
+    }
+    
+    public void Configure(IApplicationBuilder app)
+    {
+        app.UseKubernetesOperator();
+    }
+}
+```
+
+## Manual Registration
+
+If desired, the default behavior of assembly scanning can be disabled so
+specific components can be registered manually. (Using both methods in parallel
+is supported, such as if you want to load all components from one assembly and
+only some from another.)
+
+See <xref:KubeOps.Operator.Builder.IOperatorBuilder> for details on the methods
+utilized in this registration pattern.
+
+```csharp
+public class Startup
+{
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.AddKubernetesOperator(settings =>
+            {
+                settings.EnableAssemblyScanning = false;
+            })
+            .AddEntity<V1DemoEntityClone>()
+            .AddController<DemoController, V1DemoEntityClone>()
+            .AddController<DemoControllerClone>()
+            .AddFinalizer<DemoFinalizer>()
+            .AddValidationWebhook<DemoValidator>()
+            .AddMutationWebhook<DemoMutator>();
+    }
+
+    public void Configure(IApplicationBuilder app)
+    {
+        app.UseKubernetesOperator();
+    }
+}
+```

docs/docs/finalizer.md

@@ -65,3 +65,24 @@ public class TestController : IResourceController<V1TestEntity>
     }
 }
 ```
+
+Alternatively, the <xref:KubeOps.Operator.Finalizer.IFinalizerManager`1.RegisterAllFinalizersAsync(`0)>
+method can be used to attach all finalizers known to the operator for that entity type.
+
+```csharp
+public class TestController : IResourceController<V1TestEntity>
+{
+    private readonly IFinalizerManager<V1TestEntity> _manager;
+
+    public TestController(IFinalizerManager<V1TestEntity> manager)
+    {
+        _manager = manager;
+    }
+
+    public async Task<ResourceControllerResult> CreatedAsync(V1TestEntity resource)
+    {
+        await _manager.RegisterAllFinalizersAsync(resource);
+        return null;
+    }
+}
+```

docs/docs/toc.yml

@@ -18,6 +18,8 @@
   href: utilities.md
 - name: CLI Commands
   href: commands.md
+- name: Advanced Topics
+  href: advanced.md
 - name: MS Build extensions
   href: ms_build.md
 - name: Testing

src/KubeOps.Testing/KubernetesOperatorFactory.cs

@@ -4,6 +4,7 @@
 using DotnetKubernetesClient;
 using k8s;
 using k8s.Models;
+using KubeOps.Operator.Builder;
 using KubeOps.Operator.Controller;
 using KubeOps.Operator.Kubernetes;
 using KubeOps.Operator.Leadership;
@@ -57,17 +58,15 @@ public void Run()
         public Task EnqueueEvent<TEntity>(ResourceEventType type, TEntity resource)
             where TEntity : class, IKubernetesObject<V1ObjectMeta>
         {
-            var controller = Services.GetRequiredService<ManagedResourceController<TEntity>>() as
-                MockManagedResourceController<TEntity>;
+            var controller = GetMockController<TEntity>();
 
             return controller?.EnqueueEvent(type, resource) ?? Task.CompletedTask;
         }
 
         public Task EnqueueFinalization<TEntity>(TEntity resource)
             where TEntity : class, IKubernetesObject<V1ObjectMeta>
         {
-            var controller = Services.GetRequiredService<ManagedResourceController<TEntity>>() as
-                MockManagedResourceController<TEntity>;
+            var controller = GetMockController<TEntity>();
 
             return controller?.EnqueueFinalization(resource) ?? Task.CompletedTask;
         }
@@ -106,10 +105,22 @@ protected override void ConfigureWebHost(IWebHostBuilder builder)
                     services.RemoveAll(typeof(IKubernetesClient));
                     services.AddSingleton<IKubernetesClient, MockKubernetesClient>();
 
-                    services.RemoveAll(typeof(ManagedResourceController<>));
-                    services.AddSingleton(typeof(ManagedResourceController<>), typeof(MockManagedResourceController<>));
+                    services.RemoveAll<Func<IComponentRegistrar.ControllerRegistration, IManagedResourceController>>();
+                    services.AddSingleton(
+                        s => (Func<IComponentRegistrar.ControllerRegistration, IManagedResourceController>)(r =>
+                            (IManagedResourceController)ActivatorUtilities.CreateInstance(
+                                s,
+                                typeof(MockManagedResourceController<>).MakeGenericType(r.EntityType),
+                                r)));
                 });
             builder.ConfigureLogging(logging => logging.ClearProviders());
         }
+
+        private MockManagedResourceController<TEntity>? GetMockController<TEntity>()
+            where TEntity : class, IKubernetesObject<V1ObjectMeta> =>
+            Services.GetRequiredService<IControllerInstanceBuilder>()
+                .BuildControllers<TEntity>()
+                .OfType<MockManagedResourceController<TEntity>>()
+                .FirstOrDefault();
     }
 }

src/KubeOps.Testing/MockManagedResourceController{TResource}.cs

@@ -7,9 +7,9 @@
 using KubeOps.Operator.Caching;
 using KubeOps.Operator.Controller;
 using KubeOps.Operator.DevOps;
-using KubeOps.Operator.Finalizer;
 using KubeOps.Operator.Kubernetes;
 using Microsoft.Extensions.Logging;
+using static KubeOps.Operator.Builder.IComponentRegistrar;
 
 namespace KubeOps.Testing
 {
@@ -24,8 +24,8 @@ public MockManagedResourceController(
             IServiceProvider services,
             ResourceControllerMetrics<TEntity> metrics,
             OperatorSettings settings,
-            IFinalizerManager<TEntity> finalizerManager)
-            : base(logger, client, watcher, cache, services, metrics, settings, finalizerManager)
+            ControllerRegistration controllerRegistration)
+            : base(logger, client, watcher, cache, services, metrics, settings, controllerRegistration)
         {
         }
 

src/KubeOps/Operator/ApplicationBuilderExtensions.cs

@@ -1,7 +1,7 @@
-using System.Linq;
+using System;
+using System.Linq;
 using System.Reflection;
 using KubeOps.Operator.Builder;
-using KubeOps.Operator.Services;
 using KubeOps.Operator.Webhooks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Diagnostics.HealthChecks;
@@ -45,32 +45,39 @@ public static void UseKubernetesOperator(
                         .CreateLogger("ApplicationStartup");
 
                     using var scope = app.ApplicationServices.CreateScope();
-                    var locator = scope.ServiceProvider.GetRequiredService<ResourceLocator>();
+                    var componentRegistrar = scope.ServiceProvider.GetRequiredService<IComponentRegistrar>();
+                    var webhookMetadataBuilder = scope.ServiceProvider.GetRequiredService<IWebhookMetadataBuilder>();
 
-                    foreach (var (validatorType, resourceType) in locator.ValidatorTypes)
+                    foreach (var wh in componentRegistrar.ValidatorRegistrations)
                     {
+                        (Type validatorType, Type entityType) = wh;
+
                         var validator = scope.ServiceProvider.GetRequiredService(validatorType);
                         var registerMethod = typeof(IAdmissionWebhook<,>)
-                            .MakeGenericType(resourceType, typeof(ValidationResult))
+                            .MakeGenericType(entityType, typeof(ValidationResult))
                             .GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
                             .First(m => m.Name == "Register");
                         registerMethod.Invoke(validator, new object[] { endpoints });
-                        var (name, endpoint) = Webhooks.Webhooks.Metadata<ValidationResult>(validator, resourceType);
+                        var (name, endpoint) =
+                            webhookMetadataBuilder.GetMetadata<ValidationResult>(validator, entityType);
                         logger.LogInformation(
                             @"Registered validation webhook ""{name}"" under ""{endpoint}"".",
                             name,
                             endpoint);
                     }
 
-                    foreach (var (mutatorType, resourceType) in locator.MutatorTypes)
+                    foreach (var wh in componentRegistrar.MutatorRegistrations)
                     {
+                        (Type mutatorType, Type entityType) = wh;
+
                         var mutator = scope.ServiceProvider.GetRequiredService(mutatorType);
                         var registerMethod = typeof(IAdmissionWebhook<,>)
-                            .MakeGenericType(resourceType, typeof(MutationResult))
+                            .MakeGenericType(entityType, typeof(MutationResult))
                             .GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
                             .First(m => m.Name == "Register");
                         registerMethod.Invoke(mutator, new object[] { endpoints });
-                        var (name, endpoint) = Webhooks.Webhooks.Metadata<MutationResult>(mutator, resourceType);
+                        var (name, endpoint) =
+                            webhookMetadataBuilder.GetMetadata<MutationResult>(mutator, entityType);
                         logger.LogInformation(
                             @"Registered mutation webhook ""{name}"" under ""{endpoint}"".",
                             name,

src/KubeOps/Operator/Builder/AssemblyScanner.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using k8s;
+using k8s.Models;
+using KubeOps.Operator.Controller;
+using KubeOps.Operator.Finalizer;
+using KubeOps.Operator.Webhooks;
+
+namespace KubeOps.Operator.Builder
+{
+    internal class AssemblyScanner : IAssemblyScanner
+    {
+        private readonly IOperatorBuilder _operatorBuilder;
+        private readonly List<(Type Type, MethodInfo RegistrationMethod)> _registrationDefinitions;
+
+        public AssemblyScanner(IOperatorBuilder operatorBuilder)
+        {
+            _operatorBuilder = operatorBuilder;
+
+            var operatorBuilderMethods = typeof(OperatorBuilderExtensions).GetMethods(
+                BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+
+            _registrationDefinitions =
+                new (Type Type, string MethodName)[]
+                    {
+                        new() { Type = typeof(IKubernetesObject<V1ObjectMeta>), MethodName = nameof(OperatorBuilderExtensions.AddEntity) },
+                        new() { Type = typeof(IResourceController<>), MethodName = nameof(OperatorBuilderExtensions.AddController) },
+                        new() { Type = typeof(IResourceFinalizer<>), MethodName = nameof(OperatorBuilderExtensions.AddFinalizer) },
+                        new() { Type = typeof(IValidationWebhook<>), MethodName = nameof(OperatorBuilderExtensions.AddValidationWebhook) },
+                        new() { Type = typeof(IMutationWebhook<>), MethodName = nameof(OperatorBuilderExtensions.AddMutationWebhook) },
+                    }
+                    .Select<(Type Type, string MethodName), (Type Type, MethodInfo RegistrationMethod)>(
+                        t => new()
+                        {
+                            Type = t.Type,
+                            RegistrationMethod = operatorBuilderMethods.Single(
+                                m => m.Name == t.MethodName && m.GetGenericArguments().Length == 1),
+                        })
+                    .ToList();
+        }
+
+        public IAssemblyScanner AddAssembly(Assembly assembly)
+        {
+            var types = assembly.GetTypes()
+                .Where(t => (t.Attributes & TypeAttributes.Abstract) == 0);
+
+            var registrationMethods = _registrationDefinitions.Join(
+                    types,
+                    _ => 1,
+                    _ => 1,
+                    (registrationDefinition, type) =>
+                        new { RegistrationDefinition = registrationDefinition, ComponentType = type })
+                .Where(
+                    t => t.ComponentType.GetInterfaces()
+                        .Any(
+                            i => (i.IsConstructedGenericType && i.GetGenericTypeDefinition().IsEquivalentTo(t.RegistrationDefinition.Type)) ||
+                            (t.RegistrationDefinition.Type.IsConstructedGenericType && i.IsEquivalentTo(t.RegistrationDefinition.Type))))
+                .Select(
+                    t => t.RegistrationDefinition.RegistrationMethod.MakeGenericMethod(t.ComponentType));
+
+            foreach (var method in registrationMethods)
+            {
+                method.Invoke(null, new object[] { _operatorBuilder });
+            }
+
+            return this;
+        }
+    }
+}

src/KubeOps/Operator/Builder/ComponentRegistrar.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using k8s;
+using k8s.Models;
+using KubeOps.Operator.Controller;
+using KubeOps.Operator.Finalizer;
+using KubeOps.Operator.Webhooks;
+using static KubeOps.Operator.Builder.IComponentRegistrar;
+
+namespace KubeOps.Operator.Builder
+{
+    internal class ComponentRegistrar : IComponentRegistrar
+    {
+        private readonly HashSet<EntityRegistration> _entityRegistrations = new();
+        private readonly HashSet<ControllerRegistration> _controllerRegistrations = new();
+        private readonly HashSet<FinalizerRegistration> _finalizerRegistrations = new();
+        private readonly HashSet<ValidatorRegistration> _validatorRegistrations = new();
+        private readonly HashSet<MutatorRegistration> _mutatorRegistrations = new();
+
+        public ImmutableHashSet<EntityRegistration> EntityRegistrations => _entityRegistrations.ToImmutableHashSet();
+
+        public ImmutableHashSet<ControllerRegistration> ControllerRegistrations => _controllerRegistrations.ToImmutableHashSet();
+
+        public ImmutableHashSet<FinalizerRegistration> FinalizerRegistrations => _finalizerRegistrations.ToImmutableHashSet();
+
+        public ImmutableHashSet<ValidatorRegistration> ValidatorRegistrations => _validatorRegistrations.ToImmutableHashSet();
+
+        public ImmutableHashSet<MutatorRegistration> MutatorRegistrations => _mutatorRegistrations.ToImmutableHashSet();
+
+        public IComponentRegistrar RegisterEntity<TEntity>()
+            where TEntity : IKubernetesObject<V1ObjectMeta>
+        {
+            _entityRegistrations.Add(new EntityRegistration(typeof(TEntity)));
+
+            return this;
+        }
+
+        public IComponentRegistrar RegisterController<TController, TEntity>()
+            where TController : class, IResourceController<TEntity>
+            where TEntity : IKubernetesObject<V1ObjectMeta>
+        {
+            _controllerRegistrations.Add(new ControllerRegistration(typeof(TController), typeof(TEntity)));
+
+            return RegisterEntity<TEntity>();
+        }
+
+        public IComponentRegistrar RegisterFinalizer<TFinalizer, TEntity>()
+            where TFinalizer : class, IResourceFinalizer<TEntity>
+            where TEntity : IKubernetesObject<V1ObjectMeta>
+        {
+            _finalizerRegistrations.Add(new FinalizerRegistration(typeof(TFinalizer), typeof(TEntity)));
+
+            return this;
+        }
+
+        public IComponentRegistrar RegisterValidator<TValidator, TEntity>()
+            where TValidator : class, IValidationWebhook<TEntity>
+            where TEntity : IKubernetesObject<V1ObjectMeta>
+        {
+            _validatorRegistrations.Add(new ValidatorRegistration(typeof(TValidator), typeof(TEntity)));
+
+            return this;
+        }
+
+        public IComponentRegistrar RegisterMutator<TMutator, TEntity>()
+            where TMutator : class, IMutationWebhook<TEntity>
+            where TEntity : IKubernetesObject<V1ObjectMeta>
+        {
+            _mutatorRegistrations.Add(new MutatorRegistration(typeof(TMutator), typeof(TEntity)));
+
+            return RegisterEntity<TEntity>();
+        }
+    }
+}

src/KubeOps/Operator/Builder/DisabledAssemblyScanner.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Reflection;
+
+namespace KubeOps.Operator.Builder
+{
+    internal class DisabledAssemblyScanner : IAssemblyScanner
+    {
+        public IAssemblyScanner AddAssembly(Assembly assembly)
+        {
+            throw new InvalidOperationException("Assembly scanning is disabled by current operator configuration.");
+        }
+    }
+}