fix: bulk creation of dependent resource directly in abstract resource

Author: csviri

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/AbstractDependentResource.java

@@ -1,5 +1,7 @@
 package io.javaoperatorsdk.operator.processing.dependent;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Optional;
 
 import org.slf4j.Logger;
@@ -24,23 +26,54 @@ public abstract class AbstractDependentResource<R, P extends HasMetadata>
   protected Creator<R, P> creator;
   protected Updater<R, P> updater;
 
-  // todo discuss, rather implement this as interface?
-  private ResourceDiscriminator<R, P> resourceDiscriminator;
+  protected List<ResourceDiscriminator<R, P>> resourceDiscriminator = new ArrayList<>(1);
+  // used just for bulk creation
+  protected BulkResourceDiscriminatorFactory<R, P> bulkResourceDiscriminatorFactory;
 
   @SuppressWarnings("unchecked")
   public AbstractDependentResource() {
     creator = creatable ? (Creator<R, P>) this : null;
     updater = updatable ? (Updater<R, P>) this : null;
   }
 
-  @SuppressWarnings("unchecked")
   @Override
   public ReconcileResult<R> reconcile(P primary, Context<P> context) {
-    Optional<R> maybeActual = getSecondaryResource(primary, context);
+    var count = count(primary, context);
+    if (isBulkResourceCreation(primary, context)) {
+      initDiscriminators(count);
+    }
+    for (int i = 0; i < count; i++) {
+      reconcileWithIndex(primary, i, context);
+    }
+    // todo result
+    return null;
+  }
+
+  private void initDiscriminators(int count) {
+    if (resourceDiscriminator.size() == count) {
+      return;
+    }
+    if (resourceDiscriminator.size() < count) {
+      for (int i = resourceDiscriminator.size() - 1; i < count; i++) {
+        resourceDiscriminator.add(bulkResourceDiscriminatorFactory.createResourceDiscriminator(i));
+      }
+    }
+    if (resourceDiscriminator.size() < count) {
+      for (int i = resourceDiscriminator.size() - 1; i < count; i++) {
+        resourceDiscriminator.add(bulkResourceDiscriminatorFactory.createResourceDiscriminator(i));
+      }
+    }
+    if (resourceDiscriminator.size() > count) {
+      resourceDiscriminator.subList(count, resourceDiscriminator.size()).clear();
+    }
+  }
+
+  protected ReconcileResult<R> reconcileWithIndex(P primary, int i, Context<P> context) {
+    Optional<R> maybeActual = getSecondaryResource(primary, i, context);
     if (creatable || updatable) {
       if (maybeActual.isEmpty()) {
         if (creatable) {
-          var desired = desired(primary, context);
+          var desired = desired(primary, i, context);
           throwIfNull(desired, primary, "Desired");
           logForOperation("Creating", primary, desired);
           var createdResource = handleCreate(desired, primary, context);
@@ -49,7 +82,8 @@ public ReconcileResult<R> reconcile(P primary, Context<P> context) {
       } else {
         final var actual = maybeActual.get();
         if (updatable) {
-          final var match = updater.match(actual, primary, context);
+          // todo simplify matcher?
+          final var match = updater.match(actual, primary, i, context);
           if (!match.matched()) {
             final var desired = match.computedDesired().orElse(desired(primary, context));
             throwIfNull(desired, primary, "Desired");
@@ -69,14 +103,27 @@ public ReconcileResult<R> reconcile(P primary, Context<P> context) {
     return ReconcileResult.noOperation(maybeActual.orElse(null));
   }
 
+  // todo check
   protected Optional<R> getSecondaryResource(P primary, Context<P> context) {
-    if (resourceDiscriminator == null) {
+    if (resourceDiscriminator.isEmpty()) {
       return context.getSecondaryResource(resourceType());
     } else {
-      return context.getSecondaryResource(resourceType(), resourceDiscriminator);
+      return context.getSecondaryResource(resourceType(), resourceDiscriminator.get(0));
     }
   }
 
+  protected Optional<R> getSecondaryResource(P primary, int index, Context<P> context) {
+    if (index > 0 && resourceDiscriminator.isEmpty()) {
+      throw new IllegalStateException(
+          "Handling resources in bulk bot no resource discriminators set.");
+    }
+    if (!isBulkResourceCreation(primary, context)) {
+      return getSecondaryResource(primary, context);
+    }
+
+    return context.getSecondaryResource(resourceType(), resourceDiscriminator.get(index));
+  }
+
   private void throwIfNull(R desired, P primary, String descriptor) {
     if (desired == null) {
       throw new DependentResourceException(
@@ -112,7 +159,7 @@ protected R handleCreate(R desired, P primary, Context<P> context) {
   protected abstract void onCreated(ResourceID primaryResourceId, R created);
 
   /**
-   * Allows sub-classes to perform additional processing on the updated resource if needed.
+   * Allows subclasses to perform additional processing on the updated resource if needed.
    *
    * @param primaryResourceId the {@link ResourceID} of the primary resource associated with the
    *        newly updated resource
@@ -134,14 +181,36 @@ protected R desired(P primary, Context<P> context) {
         "desired method must be implemented if this DependentResource can be created and/or updated");
   }
 
-  // todo review & refactor configuration to cover all cases
-  public ResourceDiscriminator<R, P> getResourceDiscriminator() {
-    return resourceDiscriminator;
+  protected R desired(P primary, int index, Context<P> context) {
+    if (!isBulkResourceCreation(primary, context)) {
+      return desired(primary, context);
+    } else {
+      throw new IllegalStateException(
+          "desired() with index method must be implemented for bulk DependentResource creation");
+    }
   }
 
   public AbstractDependentResource<R, P> setResourceDiscriminator(
       ResourceDiscriminator<R, P> resourceDiscriminator) {
-    this.resourceDiscriminator = resourceDiscriminator;
+    this.resourceDiscriminator.add(resourceDiscriminator);
+    return this;
+  }
+
+  protected int count(P primary, Context<P> context) {
+    return 1;
+  }
+
+  protected boolean isBulkResourceCreation(P primary, Context<P> context) {
+    return false;
+  }
+
+  public BulkResourceDiscriminatorFactory<R, P> getBulkResourceDiscriminatorFactory() {
+    return bulkResourceDiscriminatorFactory;
+  }
+
+  public AbstractDependentResource<R, P> setBulkResourceDiscriminatorFactory(
+      BulkResourceDiscriminatorFactory<R, P> bulkResourceDiscriminatorFactory) {
+    this.bulkResourceDiscriminatorFactory = bulkResourceDiscriminatorFactory;
     return this;
   }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/BulkResourceDiscriminatorFactory.java

@@ -0,0 +1,10 @@
+package io.javaoperatorsdk.operator.processing.dependent;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.ResourceDiscriminator;
+
+public interface BulkResourceDiscriminatorFactory<R, P extends HasMetadata> {
+
+  ResourceDiscriminator<R, P> createResourceDiscriminator(int index);
+
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/dependent/Updater.java

@@ -8,4 +8,13 @@ public interface Updater<R, P extends HasMetadata> {
   R update(R actual, R desired, P primary, Context<P> context);
 
   Result<R> match(R actualResource, P primary, Context<P> context);
+
+  // todo change to simple desired matching?
+  default Result<R> match(R actualResource, P primary, int index, Context<P> context) {
+    if (index == 0) {
+      return match(actualResource, primary, context);
+    } else {
+      throw new IllegalStateException("Implement this");
+    }
+  }
 }