refactor: update controller and finalizer interfaces to return `Resul…

…t<TEntity>`

examples/ConversionWebhookOperator/Controller/V1TestEntityController.cs

@@ -8,15 +8,15 @@ namespace ConversionWebhookOperator.Controller;
 [EntityRbac(typeof(V1TestEntity), Verbs = RbacVerb.All)]
 public class V1TestEntityController(ILogger<V1TestEntityController> logger) : IEntityController<V1TestEntity>
 {
-    public Task ReconcileAsync(V1TestEntity entity, CancellationToken cancellationToken)
+    public Task<Result<V1TestEntity>> ReconcileAsync(V1TestEntity entity, CancellationToken cancellationToken)
     {
         logger.LogInformation("Reconciling entity {Entity}.", entity);
-        return Task.CompletedTask;
+        return Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
     }
 
-    public Task DeletedAsync(V1TestEntity entity, CancellationToken cancellationToken)
+    public Task<Result<V1TestEntity>> DeletedAsync(V1TestEntity entity, CancellationToken cancellationToken)
     {
         logger.LogInformation("Deleted entity {Entity}.", entity);
-        return Task.CompletedTask;
+        return Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
     }
 }

examples/Operator/Controller/V1TestEntityController.cs

@@ -10,18 +10,18 @@
 namespace Operator.Controller;
 
 [EntityRbac(typeof(V1TestEntity), Verbs = RbacVerb.All)]
-public class V1TestEntityController(ILogger<V1TestEntityController> logger)
+public sealed  class V1TestEntityController(ILogger<V1TestEntityController> logger)
     : IEntityController<V1TestEntity>
 {
-    public Task ReconcileAsync(V1TestEntity entity, CancellationToken cancellationToken)
+    public Task<Result<V1TestEntity>> ReconcileAsync(V1TestEntity entity, CancellationToken cancellationToken)
     {
         logger.LogInformation("Reconciling entity {Entity}.", entity);
-        return Task.CompletedTask;
+        return Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
     }
 
-    public Task DeletedAsync(V1TestEntity entity, CancellationToken cancellationToken)
+    public Task<Result<V1TestEntity>> DeletedAsync(V1TestEntity entity, CancellationToken cancellationToken)
     {
         logger.LogInformation("Deleting entity {Entity}.", entity);
-        return Task.CompletedTask;
+        return Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
     }
 }

examples/Operator/Finalizer/FinalizerOne.cs

@@ -1,13 +1,12 @@
-using KubeOps.Abstractions.Finalizer;
+using KubeOps.Abstractions.Controller;
+using KubeOps.Abstractions.Finalizer;
 
 using Operator.Entities;
 
 namespace Operator.Finalizer;
 
-public class FinalizerOne : IEntityFinalizer<V1TestEntity>
+public sealed class FinalizerOne : IEntityFinalizer<V1TestEntity>
 {
-    public Task FinalizeAsync(V1TestEntity entity, CancellationToken cancellationToken)
-    {
-        return Task.CompletedTask;
-    }
+    public Task<Result<V1TestEntity>> FinalizeAsync(V1TestEntity entity, CancellationToken cancellationToken)
+        => Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
 }

examples/WebhookOperator/Controller/V1TestEntityController.cs

@@ -6,17 +6,17 @@
 namespace WebhookOperator.Controller;
 
 [EntityRbac(typeof(V1TestEntity), Verbs = RbacVerb.All)]
-public class V1TestEntityController(ILogger<V1TestEntityController> logger) : IEntityController<V1TestEntity>
+public sealed class V1TestEntityController(ILogger<V1TestEntityController> logger) : IEntityController<V1TestEntity>
 {
-    public Task ReconcileAsync(V1TestEntity entity, CancellationToken cancellationToken)
+    public Task<Result<V1TestEntity>> ReconcileAsync(V1TestEntity entity, CancellationToken cancellationToken)
     {
         logger.LogInformation("Reconciling entity {Entity}.", entity);
-        return Task.CompletedTask;
+        return Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
     }
 
-    public Task DeletedAsync(V1TestEntity entity, CancellationToken cancellationToken)
+    public Task<Result<V1TestEntity>> DeletedAsync(V1TestEntity entity, CancellationToken cancellationToken)
     {
         logger.LogInformation("Deleted entity {Entity}.", entity);
-        return Task.CompletedTask;
+        return Task.FromResult(Result<V1TestEntity>.ForSuccess(entity));
     }
 }

src/KubeOps.Abstractions/Controller/IEntityController{TEntity}.cs

@@ -33,24 +33,23 @@ namespace KubeOps.Abstractions.Controller;
 /// }
 /// </code>
 /// </example>
-public interface IEntityController<in TEntity>
+public interface IEntityController<TEntity>
     where TEntity : IKubernetesObject<V1ObjectMeta>
 {
     /// <summary>
-    /// Called for `added` and `modified` events from the watcher.
+    /// Reconciles the state of the specified entity with the desired state.
+    /// This method is triggered for `added` and `modified` events from the watcher.
     /// </summary>
-    /// <param name="entity">The entity that fired the reconcile event.</param>
-    /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
-    /// <returns>A task that completes when the reconciliation is done.</returns>
-    Task ReconcileAsync(TEntity entity, CancellationToken cancellationToken);
+    /// <param name="entity">The entity that initiated the reconcile operation.</param>
+    /// <param name="cancellationToken">The token used to signal cancellation of the operation.</param>
+    /// <returns>A task that represents the asynchronous operation and contains the result of the reconcile process.</returns>
+    Task<Result<TEntity>> ReconcileAsync(TEntity entity, CancellationToken cancellationToken);
 
     /// <summary>
     /// Called for `delete` events for a given entity.
     /// </summary>
     /// <param name="entity">The entity that fired the deleted event.</param>
     /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
-    /// <returns>
-    /// A task that completes, when the reconciliation is done.
-    /// </returns>
-    Task DeletedAsync(TEntity entity, CancellationToken cancellationToken);
+    /// <returns>A task that represents the asynchronous operation and contains the result of the reconcile process.</returns>
+    Task<Result<TEntity>> DeletedAsync(TEntity entity, CancellationToken cancellationToken);
 }

src/KubeOps.Abstractions/Controller/Result.cs

@@ -0,0 +1,43 @@
+using System.Diagnostics.CodeAnalysis;
+
+using k8s;
+using k8s.Models;
+
+namespace KubeOps.Abstractions.Controller;
+
+public sealed record Result<TEntity>
+    where TEntity : IKubernetesObject<V1ObjectMeta>
+{
+    private Result(TEntity entity, bool isSuccess, string? errorMessage, Exception? error, TimeSpan? requeueAfter)
+    {
+        Entity = entity;
+        IsSuccess = isSuccess;
+        ErrorMessage = errorMessage;
+        Error = error;
+        RequeueAfter = requeueAfter;
+    }
+
+    public TEntity Entity { get; }
+
+    [MemberNotNullWhen(false, nameof(ErrorMessage))]
+    public bool IsSuccess { get; }
+
+    [MemberNotNullWhen(true, nameof(ErrorMessage))]
+    public bool IsFailure => !IsSuccess;
+
+    public string? ErrorMessage { get; set; }
+
+    public Exception? Error { get; }
+
+    public TimeSpan? RequeueAfter { get; }
+
+    public static Result<TEntity> ForSuccess(TEntity entity, TimeSpan? requeueAfter = null)
+    {
+        return new(entity, true, null, null, requeueAfter);
+    }
+
+    public static Result<TEntity> ForFailure(TEntity entity, string errorMessage, Exception? error = null, TimeSpan? requeueAfter = null)
+    {
+        return new(entity, false, errorMessage, error, requeueAfter);
+    }
+}

src/KubeOps.Abstractions/Finalizer/IEntityFinalizer{TEntity}.cs

@@ -1,20 +1,22 @@
 using k8s;
 using k8s.Models;
 
+using KubeOps.Abstractions.Controller;
+
 namespace KubeOps.Abstractions.Finalizer;
 
 /// <summary>
 /// Finalizer for an entity.
 /// </summary>
 /// <typeparam name="TEntity">The type of the entity.</typeparam>
-public interface IEntityFinalizer<in TEntity>
+public interface IEntityFinalizer<TEntity>
     where TEntity : IKubernetesObject<V1ObjectMeta>
 {
     /// <summary>
     /// Finalize an entity that is pending for deletion.
     /// </summary>
     /// <param name="entity">The kubernetes entity that needs to be finalized.</param>
     /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
-    /// <returns>A task that resolves when the operation is done.</returns>
-    Task FinalizeAsync(TEntity entity, CancellationToken cancellationToken);
+    /// <returns>A task that represents the asynchronous operation and contains the result of the reconcile process.</returns>
+    Task<Result<TEntity>> FinalizeAsync(TEntity entity, CancellationToken cancellationToken);
 }

src/KubeOps.Abstractions/KubeOps.Abstractions.csproj

@@ -15,7 +15,8 @@
 
     <ItemGroup>
         <PackageReference Include="KubernetesClient" Version="16.0.7" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
         <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.6"/>
     </ItemGroup>
 
-</Project>
+</Project>

src/KubeOps.Abstractions/Queue/EntityRequeue.cs

@@ -43,5 +43,5 @@ namespace KubeOps.Abstractions.Queue;
 /// }
 /// </code>
 /// </example>
-public delegate void EntityRequeue<TEntity>(TEntity entity, TimeSpan requeueIn)
+public delegate void EntityRequeue<in TEntity>(TEntity entity, TimeSpan requeueIn)
     where TEntity : IKubernetesObject<V1ObjectMeta>;

src/KubeOps.Operator/Queue/EntityRequeueBackgroundService.cs

@@ -2,6 +2,7 @@
 using k8s.Models;
 
 using KubeOps.Abstractions.Controller;
+using KubeOps.Abstractions.Finalizer;
 using KubeOps.KubernetesClient;
 
 using Microsoft.Extensions.DependencyInjection;
@@ -118,8 +119,21 @@ private async Task ReconcileSingleAsync(TEntity queued, CancellationToken cancel
             return;
         }
 
-        await using var scope = provider.CreateAsyncScope();
-        var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity>>();
-        await controller.ReconcileAsync(entity, cancellationToken);
+        if (entity.DeletionTimestamp() is not null)
+        {
+            if (entity.Finalizers()?.Count > 0)
+            {
+                var identifier = entity.Finalizers()[0];
+                await using var scope = provider.CreateAsyncScope();
+                var finalizer = scope.ServiceProvider.GetRequiredKeyedService<IEntityFinalizer<TEntity>>(identifier);
+                await finalizer.FinalizeAsync(entity, cancellationToken);
+            }
+        }
+        else
+        {
+            await using var scope = provider.CreateAsyncScope();
+            var controller = scope.ServiceProvider.GetRequiredService<IEntityController<TEntity>>();
+            await controller.ReconcileAsync(entity, cancellationToken);
+        }
     }
 }