Some unit Tests and Refactoring some Commands (#14)

Author: pmdevers

examples/SimpleOperator/Program.cs

@@ -4,7 +4,8 @@
 using SimpleOperator.Projects;
 
 
-var builder = OperatorHost.CreateOperatorApplicationBuilder(args);
+var builder = OperatorHost.CreateOperatorApplicationBuilder(args)
+    .WithName("simple-operator");
 
 builder.AddController<TestItemController>()
     .WithFinalizer("testitem.local.finalizer"); 
@@ -14,10 +15,6 @@
 
 var app = builder.Build();
 
-var writer = new StringWriter();
-
-await new Install(app, writer).RunAsync();
-
-Console.WriteLine(writer.ToString());
+app.AddInstall();
 
 await app.RunAsync();

examples/SimpleOperator/Properties/launchSettings.json

@@ -2,27 +2,35 @@
     "profiles": {
         "Operator": {
             "commandName": "Project",
-            "commandLineArgs": "--operator",
+            "commandLineArgs": "operator",
             "environmentVariables": {
                 "ASPNETCORE_ENVIRONMENT": "Development"
             },
             "dotnetRunMessages": true
         },
         "Install": {
             "commandName": "Project",
-            "commandLineArgs": "install=true --export true",
+            "commandLineArgs": "install",
             "environmentVariables": {
                 "ASPNETCORE_ENVIRONMENT": "Development"
             },
             "dotnetRunMessages": true
         },
-        "CLI": {
+        "Help": {
             "commandName": "Project",
             "commandLineArgs": "",
             "environmentVariables": {
                 "ASPNETCORE_ENVIRONMENT": "Development"
             },
             "dotnetRunMessages": true
+        },
+        "Version": {
+            "commandName": "Project",
+            "commandLineArgs": "version",
+            "environmentVariables": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "dotnetRunMessages": true
         }
     },
    "$schema": "http://json.schemastore.org/launchsettings.json"

src/Directory.Build.props

@@ -43,5 +43,6 @@
       <PackagePath>\</PackagePath>
     </None>
     <InternalsVisibleTo Include="$(MSBuildProjectName).Tests"/>
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2"/>
   </ItemGroup>
 </Project>

src/K8sOperator.NET.Generators/Install.cs

@@ -1,5 +1,6 @@
 using k8s;
 using k8s.Models;
+using K8sOperator.NET.Builder;
 using K8sOperator.NET.Extensions;
 using K8sOperator.NET.Generators.Builders;
 using K8sOperator.NET.Metadata;
@@ -9,15 +10,16 @@ namespace K8sOperator.NET.Generators;
 /// <summary>
 /// 
 /// </summary>
-/// <param name="app"></param>
-/// <param name="writer"></param>
-public class Install(IOperatorApplication app, StringWriter writer)
+[OperatorArgument("install", Description = "Generates the install manifests")]
+public class InstallCommand(IOperatorApplication app) : IOperatorCommand
 {
+    private readonly StringWriter _output = new();
+
     /// <summary>
     /// 
     /// </summary>
     /// <returns></returns>
-    public async Task RunAsync()
+    public async Task RunAsync(string[] args)
     {
         var watchers = app.DataSource.GetWatchers(app.ServiceProvider);
         var clusterrole = CreateClusterRole(app.DataSource.Metadata, watchers);
@@ -34,12 +36,14 @@ public async Task RunAsync()
         await Write(clusterrole);
         await Write(clusterrolebinding);
         await Write(deployment);
+
+        Console.WriteLine(_output.ToString());
     }
 
     private async Task Write(IKubernetesObject obj)
     {
-        await writer.WriteLineAsync(KubernetesYaml.Serialize(obj));
-        await writer.WriteLineAsync("---");
+        await _output.WriteLineAsync(KubernetesYaml.Serialize(obj));
+        await _output.WriteLineAsync("---");
     }
 
     private static V1CustomResourceDefinition CreateCustomResourceDefinition(IEventWatcher item)

src/K8sOperator.NET.Generators/OperatorApplicationExtensions.cs

@@ -0,0 +1,22 @@
+using K8sOperator.NET.Builder;
+
+namespace K8sOperator.NET.Generators;
+
+/// <summary>
+/// 
+/// </summary>
+public static class OperatorApplicationExtensions
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="TBuilder"></typeparam>
+    /// <param name="builder"></param>
+    /// <param name="order"></param>
+    /// <returns></returns>
+    public static IOperatorCommandConventionBuilder AddInstall<TBuilder>(this TBuilder builder, int? order = null)
+        where TBuilder : IOperatorApplication
+    {
+        return builder.AddCommand<InstallCommand>(order ?? -1);
+    }
+}

src/K8sOperator.NET/Builder/ControllerConventionBuilder.cs

@@ -1,35 +1,13 @@
 namespace K8sOperator.NET.Builder;
 
 /// <summary>
-/// Desribes a Operator Convention Builder
+/// 
 /// </summary>
-public interface IControllerConventionBuilder
-{
-    /// <summary>
-    /// Add Convention
-    /// </summary>
-    /// <param name="convention"></param>
-    void Add(Action<IControllerBuilder> convention);
-
-    /// <summary>
-    /// Add Finally Convention
-    /// </summary>
-    /// <param name="convention"></param>
-    void Finally(Action<IControllerBuilder> convention);
-}
-
+public interface IControllerConventionBuilder : IConventionBuilder<IControllerBuilder> { }
 
 internal class ControllerConventionBuilder(
     ICollection<Action<IControllerBuilder>> conventions,
-    ICollection<Action<IControllerBuilder>> finallyConventions) : IControllerConventionBuilder
+    ICollection<Action<IControllerBuilder>> finallyConventions) 
+: ConventionBuilder<IControllerBuilder>(conventions, finallyConventions), IControllerConventionBuilder
 {
-    public void Add(Action<IControllerBuilder> convention)
-    {
-        conventions.Add(convention);
-    }
-
-    public void Finally(Action<IControllerBuilder> convention)
-    {
-        finallyConventions.Add(convention);
-    }
 }

src/K8sOperator.NET/Builder/ConventionBuilder.cs

@@ -0,0 +1,34 @@
+namespace K8sOperator.NET.Builder;
+
+/// <summary>
+/// Desribes a Operator Convention Builder
+/// </summary>
+public interface IConventionBuilder<out T>
+{
+    /// <summary>
+    /// Add Convention
+    /// </summary>
+    /// <param name="convention"></param>
+    void Add(Action<T> convention);
+
+    /// <summary>
+    /// Add Finally Convention
+    /// </summary>
+    /// <param name="convention"></param>
+    void Finally(Action<T> convention);
+}
+
+internal class ConventionBuilder<T>(
+    ICollection<Action<T>> conventions,
+    ICollection<Action<T>> finallyConventions) : IConventionBuilder<T>
+{
+    public void Add(Action<T> convention)
+    {
+        conventions.Add(convention);
+    }
+
+    public void Finally(Action<T> convention)
+    {
+        finallyConventions.Add(convention);
+    }
+}

src/K8sOperator.NET/Builder/OperatorCommandBuilder.cs

@@ -0,0 +1,97 @@
+using K8sOperator.NET.Metadata;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace K8sOperator.NET.Builder;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IOperatorCommandBuilder
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    IServiceProvider ServiceProvider { get; }
+    /// <summary>
+    /// 
+    /// </summary>
+    List<object> Metadata { get; }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public interface IOperatorCommand
+{    
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    Task RunAsync(string[] args);
+}
+
+internal class OperatorCommandBuilder(IServiceProvider serviceProvider, Type commandType) : IOperatorCommandBuilder
+{
+    public IServiceProvider ServiceProvider { get; } = serviceProvider;
+    public Type CommandType { get; } = commandType;
+    public List<object> Metadata { get; } = [];
+
+    public IOperatorCommand Build()
+    {
+        var meta = CommandType.GetCustomAttribute<OperatorArgumentAttribute>(false) ?? new(CommandType.Name.Replace("Command", string.Empty).ToLower());
+        Metadata.Add(meta);
+
+        return (IOperatorCommand)ActivatorUtilities.CreateInstance(ServiceProvider, CommandType);
+    }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public static class OperatorCommandsBuilderExtensions 
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static IOperatorCommandConventionBuilder AddCommand<T>(this IOperatorApplication app, int order = 1)
+        where T : class, IOperatorCommand
+    {
+        return app.Commands.AddCommand(typeof(T), order);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="TBuilder"></typeparam>
+    /// <param name="builder"></param>
+    /// <param name="argument"></param>
+    /// <param name="description"></param>
+    /// <returns></returns>
+    public static TBuilder WithArgument<TBuilder>(this TBuilder builder, string argument, string description)
+        where TBuilder : IOperatorCommandConventionBuilder
+    {
+        FinallyReplace(builder, new OperatorArgumentAttribute(argument) { Description = description});
+        return builder;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="TBuilder"></typeparam>
+    /// <param name="builder"></param>
+    /// <param name="item"></param>
+    /// <returns></returns>
+    public static TBuilder FinallyReplace<TBuilder>(this TBuilder builder, object item)
+        where TBuilder : IOperatorCommandConventionBuilder
+    {
+        builder.Finally(b => {
+            b.Metadata.RemoveAll(x => x.GetType() == item.GetType());
+            b.Metadata.Add(item);
+        });
+
+        return builder;
+    }
+}

src/K8sOperator.NET/Builder/OperatorCommandConventionBuilder.cs

@@ -0,0 +1,14 @@
+
+namespace K8sOperator.NET.Builder;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IOperatorCommandConventionBuilder : IConventionBuilder<IOperatorCommandBuilder> { }
+
+internal class OperatorCommandConventionBuilder(
+    ICollection<Action<IOperatorCommandBuilder>> conventions,
+    ICollection<Action<IOperatorCommandBuilder>> finallyConventions)
+: ConventionBuilder<IOperatorCommandBuilder>(conventions, finallyConventions), IOperatorCommandConventionBuilder
+{
+}

src/K8sOperator.NET/Builder/OperatorHostBuilder.cs

@@ -3,6 +3,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using System.Data.Common;
 using System.Reflection;
 
 namespace K8sOperator.NET.Builder;
@@ -32,6 +33,11 @@ public interface IOperatorApplicationBuilder
     /// </summary>
     IControllerDataSource DataSource { get; }
 
+    /// <summary>
+    /// 
+    /// </summary>
+    IKubernetesBuilder Kubernetes { get; }
+
     /// <summary>
     /// Gets the list of metadata associated with the application.
     /// </summary>
@@ -66,6 +72,7 @@ internal OperatorApplicationBuilder(string[] args)
     {
         _logging = new(_serviceCollection);
         _kubernetes = new(_serviceCollection);
+
         _args = args;
 
         ConfigureConfiguration();
@@ -86,13 +93,11 @@ private void ConfigureMetadata()
 
         _metadata.AddRange([operatorName, dockerImage]);
     }
-
     public IConfigurationManager Configuration => _configurationManager;
     public IServiceCollection Services => _serviceCollection;
     public ILoggingBuilder Logging => _logging;
     public IKubernetesBuilder Kubernetes => _kubernetes;
     public IControllerDataSource DataSource => _datasource;
-
     public List<object> Metadata => _metadata;
 
     public IControllerConventionBuilder AddController(Type controllerType)
@@ -103,17 +108,21 @@ public IControllerConventionBuilder AddController(Type controllerType)
 
     public IOperatorApplication Build()
     {
+       _serviceCollection.AddSingleton<IConfiguration>(_configurationManager);
+       _serviceCollection.AddSingleton<IControllerDataSource>(_datasource);
+       _serviceCollection.AddSingleton<IOperatorApplication>(x => new OperatorHostApplication(x, _args));
+
        var serviceProvider = _serviceCollection.BuildServiceProvider();
-       return new OperatorHostApplication(serviceProvider, _configurationManager, DataSource);
+       return serviceProvider.GetRequiredService<IOperatorApplication>();
     }
 
     private void ConfigureConfiguration()
     {
         _configurationManager
             .SetBasePath(Directory.GetCurrentDirectory())
-            //.AddJsonFile("appsettings.json", true, true)
-            //.AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", true, true)
-            //.AddEnvironmentVariables()
+            .AddJsonFile("appsettings.json", true, true)
+            .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", true, true)
+            .AddEnvironmentVariables()
             .AddCommandLine(_args);
     }