test passes

Author: csviri

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

@@ -40,27 +40,41 @@ public AbstractDependentResource() {
   public ReconcileResult<R> reconcile(P primary, Context<P> context) {
     var count = count(primary, context).orElse(1);
     if (isBulkResourceCreation(primary, context)) {
-      initDiscriminators(count);
+      cleanupBulkResourcesIfRequired(count, resourceDiscriminator.size(), primary, context);
+      adjustDiscriminators(count);
     }
     ReconcileResult<R> result = new ReconcileResult<>();
     for (int i = 0; i < count; i++) {
-      var res = reconcileWithIndex(primary, i, context);
+      var res = reconcileIndexAware(primary, i, context);
       result.addReconcileResult(res);
     }
     return result;
   }
 
-  private void initDiscriminators(int count) {
-    if (resourceDiscriminator.size() == count) {
+  private void cleanupBulkResourcesIfRequired(int targetCount, int actualCount, P primary,
+      Context<P> context) {
+    if (targetCount >= actualCount) {
       return;
     }
-    if (resourceDiscriminator.size() < count) {
-      for (int i = resourceDiscriminator.size() - 1; i < count; i++) {
-        resourceDiscriminator.add(bulkResourceDiscriminatorFactory.createResourceDiscriminator(i));
-      }
+    for (int i = targetCount; i < actualCount; i++) {
+      var resource = getSecondaryResourceIndexAware(primary, i, context);
+      var index = i;
+      resource.ifPresent(r -> {
+        deleteBulkResourceWithIndex(primary, r, index, context);
+      });
+    }
+  }
+
+  protected void deleteBulkResourceWithIndex(P primary, R resource, int i, Context<P> context) {
+    throw new IllegalStateException("Implement if handling bulk resources.");
+  }
+
+  private void adjustDiscriminators(int count) {
+    if (resourceDiscriminator.size() == count) {
+      return;
     }
     if (resourceDiscriminator.size() < count) {
-      for (int i = resourceDiscriminator.size() - 1; i < count; i++) {
+      for (int i = resourceDiscriminator.size(); i < count; i++) {
         resourceDiscriminator.add(bulkResourceDiscriminatorFactory.createResourceDiscriminator(i));
       }
     }
@@ -69,12 +83,12 @@ private void initDiscriminators(int count) {
     }
   }
 
-  protected ReconcileResult<R> reconcileWithIndex(P primary, int i, Context<P> context) {
-    Optional<R> maybeActual = getSecondaryResource(primary, i, context);
+  protected ReconcileResult<R> reconcileIndexAware(P primary, int i, Context<P> context) {
+    Optional<R> maybeActual = getSecondaryResourceIndexAware(primary, i, context);
     if (creatable || updatable) {
       if (maybeActual.isEmpty()) {
         if (creatable) {
-          var desired = desired(primary, i, context);
+          var desired = desiredIndexAware(primary, i, context);
           throwIfNull(desired, primary, "Desired");
           logForOperation("Creating", primary, desired);
           var createdResource = handleCreate(desired, primary, context);
@@ -90,7 +104,8 @@ protected ReconcileResult<R> reconcileWithIndex(P primary, int i, Context<P> con
             match = updater.match(actual, primary, context);
           }
           if (!match.matched()) {
-            final var desired = match.computedDesired().orElse(desired(primary, context));
+            final var desired =
+                match.computedDesired().orElse(desiredIndexAware(primary, i, context));
             throwIfNull(desired, primary, "Desired");
             logForOperation("Updating", primary, desired);
             var updatedResource = handleUpdate(actual, desired, primary, context);
@@ -108,6 +123,11 @@ protected ReconcileResult<R> reconcileWithIndex(P primary, int i, Context<P> con
     return ReconcileResult.noOperation(maybeActual.orElse(null));
   }
 
+  private R desiredIndexAware(P primary, int i, Context<P> context) {
+    return isBulkResourceCreation(primary, context) ? desired(primary, i, context)
+        : desired(primary, context);
+  }
+
   // todo check
   protected Optional<R> getSecondaryResource(P primary, Context<P> context) {
     if (resourceDiscriminator.isEmpty()) {
@@ -117,7 +137,7 @@ protected Optional<R> getSecondaryResource(P primary, Context<P> context) {
     }
   }
 
-  protected Optional<R> getSecondaryResource(P primary, int index, Context<P> context) {
+  protected Optional<R> getSecondaryResourceIndexAware(P primary, int index, Context<P> context) {
     if (index > 0 && resourceDiscriminator.isEmpty()) {
       throw new IllegalStateException(
           "Handling resources in bulk bot no resource discriminators set.");

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

@@ -137,11 +137,20 @@ public Result<R> match(R actualResource, P primary, Context<P> context) {
     return matcher.match(actualResource, primary, context);
   }
 
+  public Result<R> match(R actualResource, P primary, int index, Context<P> context) {
+    return matcher.match(actualResource, primary, index, context);
+  }
+
   public void delete(P primary, Context<P> context) {
     var resource = getSecondaryResource(primary, context);
     resource.ifPresent(r -> client.resource(r).delete());
   }
 
+  @Override
+  protected void deleteBulkResourceWithIndex(P primary, R resource, int i, Context<P> context) {
+    client.resource(resource).delete();
+  }
+
   @SuppressWarnings("unchecked")
   protected NonNamespaceOperation<R, KubernetesResourceList<R>, Resource<R>> prepare(R desired,
       P primary, String actionName) {

operator-framework/src/test/java/io/javaoperatorsdk/operator/StandaloneBulkDependentIT.java

@@ -27,15 +27,33 @@ class StandaloneBulkDependentIT {
   @Test
   void managesBulkConfigMaps() {
     operator.create(testResource());
+    assertNumberOfConfigMaps(3);
 
+    updateSpecWithNumber(1);
+    assertNumberOfConfigMaps(1);
+
+    updateSpecWithNumber(5);
+    assertNumberOfConfigMaps(5);
+
+    operator.delete(testResource());
+    assertNumberOfConfigMaps(0);
+  }
+
+  void assertNumberOfConfigMaps(int n) {
     await().untilAsserted(() -> {
       var cms = operator.getKubernetesClient().configMaps().inNamespace(operator.getNamespace())
           .withLabel(LABEL_KEY, LABEL_VALUE)
           .list().getItems();
-      assertThat(cms).hasSize(NUMBER_OF_CONFIG_MAPS);
+      assertThat(cms).hasSize(n);
     });
   }
 
+  private void updateSpecWithNumber(int n) {
+    var resource = testResource();
+    resource.getSpec().setNumberOfResources(n);
+    operator.replace(resource);
+  }
+
   private StandaloneBulkDependentTestCustomResource testResource() {
     StandaloneBulkDependentTestCustomResource cr = new StandaloneBulkDependentTestCustomResource();
     cr.setMetadata(new ObjectMeta());

operator-framework/src/test/java/io/javaoperatorsdk/operator/sample/standalonebulkdependent/ConfigMapBulkDependentResource.java

@@ -4,6 +4,9 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import io.fabric8.kubernetes.api.model.ConfigMap;
 import io.fabric8.kubernetes.api.model.ObjectMetaBuilder;
 import io.javaoperatorsdk.operator.api.reconciler.Context;
@@ -12,6 +15,8 @@
 public class ConfigMapBulkDependentResource
     extends CRUDKubernetesDependentResource<ConfigMap, StandaloneBulkDependentTestCustomResource> {
 
+  private final static Logger log = LoggerFactory.getLogger(ConfigMapBulkDependentResource.class);
+
   public static final String LABEL_KEY = "bulk";
   public static final String LABEL_VALUE = "true";