feat: ignore list support for kubernetes dependent matchers

Author: csviri

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

@@ -1,16 +1,17 @@
 package io.javaoperatorsdk.operator.processing.dependent.kubernetes;
 
-import java.util.Objects;
+import java.util.*;
 
 import io.fabric8.kubernetes.api.model.ConfigMap;
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.fabric8.kubernetes.api.model.Secret;
 import io.fabric8.zjsonpatch.JsonDiff;
-import io.javaoperatorsdk.operator.ReconcilerUtils;
 import io.javaoperatorsdk.operator.api.config.ConfigurationServiceProvider;
 import io.javaoperatorsdk.operator.api.reconciler.Context;
 import io.javaoperatorsdk.operator.processing.dependent.Matcher;
 
+import com.fasterxml.jackson.databind.JsonNode;
+
 public class GenericKubernetesResourceMatcher<R extends HasMetadata, P extends HasMetadata>
     implements Matcher<R, P> {
 
@@ -63,17 +64,50 @@ public static <R extends HasMetadata> Result<R> match(R desired, R actualResourc
    */
   public static <R extends HasMetadata> Result<R> match(R desired, R actualResource,
       boolean considerMetadata, boolean equality) {
+    return match(desired, actualResource, considerMetadata, equality, Collections.emptyList());
+  }
+
+  public static <R extends HasMetadata> Result<R> match(R desired, R actualResource,
+      boolean considerMetadata, String... ignoreList) {
+    return match(desired, actualResource, considerMetadata, false, Arrays.asList(ignoreList));
+  }
+
+
+  private static <R extends HasMetadata> Result<R> match(R desired, R actualResource,
+      boolean considerMetadata, boolean equality, List<String> ignoreList) {
+    if (equality && !ignoreList.isEmpty()) {
+      throw new IllegalArgumentException(
+          "Equality should be false in case of ignore list provided");
+    }
+
+    final var objectMapper = ConfigurationServiceProvider.instance().getObjectMapper();
+
+    var desiredNode = objectMapper.valueToTree(desired);
+    var actualNode = objectMapper.valueToTree(actualResource);
+    var wholeDiffJsonPatch = JsonDiff.asJson(desiredNode, actualNode);
+
+    var considerIgnoreList = !equality && !ignoreList.isEmpty();
+
     if (considerMetadata) {
-      final var desiredMetadata = desired.getMetadata();
-      final var actualMetadata = actualResource.getMetadata();
-      final var matched =
-          Objects.equals(desiredMetadata.getAnnotations(), actualMetadata.getAnnotations()) &&
-              Objects.equals(desiredMetadata.getLabels(), actualMetadata.getLabels());
-      if (!matched) {
-        return Result.computed(false, desired);
+      if (equality) {
+        final var desiredMetadata = desired.getMetadata();
+        final var actualMetadata = actualResource.getMetadata();
+
+        final var matched =
+            Objects.equals(desiredMetadata.getAnnotations(), actualMetadata.getAnnotations()) &&
+                Objects.equals(desiredMetadata.getLabels(), actualMetadata.getLabels());
+        if (!matched) {
+          return Result.computed(false, desired);
+        }
+      } else {
+        var metadataJSonDiffs = getDiffsWithPathSuffix(wholeDiffJsonPatch,
+            "/metadata/labels",
+            "/metadata/annotations");
+        if (!allDiffsAreAddOps(metadataJSonDiffs)) {
+          return Result.computed(false, desired);
+        }
       }
     }
-
     if (desired instanceof ConfigMap) {
       return Result.computed(
           ResourceComparators.compareConfigMapData((ConfigMap) desired, (ConfigMap) actualResource),
@@ -83,29 +117,60 @@ public static <R extends HasMetadata> Result<R> match(R desired, R actualResourc
           ResourceComparators.compareSecretData((Secret) desired, (Secret) actualResource),
           desired);
     } else {
-      final var objectMapper = ConfigurationServiceProvider.instance().getObjectMapper();
-
       // reflection will be replaced by this:
       // https://github.com/fabric8io/kubernetes-client/issues/3816
-      var desiredSpecNode = objectMapper.valueToTree(ReconcilerUtils.getSpec(desired));
-      var actualSpecNode = objectMapper.valueToTree(ReconcilerUtils.getSpec(actualResource));
-      var diffJsonPatch = JsonDiff.asJson(desiredSpecNode, actualSpecNode);
+      var specDiffJsonPatch = getDiffsWithPathSuffix(wholeDiffJsonPatch, "/spec");
       // In case of equality is set to true, no diffs are allowed, so we return early if diffs exist
       // On contrary (if equality is false), "add" is allowed for cases when for some
       // resources Kubernetes fills-in values into spec.
-      if (equality && diffJsonPatch.size() > 0) {
+      if (equality && !specDiffJsonPatch.isEmpty()) {
         return Result.computed(false, desired);
       }
-      for (int i = 0; i < diffJsonPatch.size(); i++) {
-        String operation = diffJsonPatch.get(i).get("op").asText();
-        if (!operation.equals("add")) {
+      if (considerIgnoreList) {
+        if (!allDiffsOnIgnoreList(specDiffJsonPatch, ignoreList)) {
+          return Result.computed(false, desired);
+        }
+      } else {
+        if (!allDiffsAreAddOps(specDiffJsonPatch)) {
           return Result.computed(false, desired);
         }
       }
       return Result.computed(true, desired);
     }
   }
 
+  private static boolean allDiffsAreAddOps(List<JsonNode> metadataJSonDiffs) {
+    if (metadataJSonDiffs.isEmpty()) {
+      return true;
+    }
+    return metadataJSonDiffs.stream().allMatch(n -> "add".equals(n.get("op").asText()));
+  }
+
+  private static boolean allDiffsOnIgnoreList(List<JsonNode> metadataJSonDiffs,
+      List<String> ignoreList) {
+    if (metadataJSonDiffs.isEmpty()) {
+      return true;
+    }
+    return metadataJSonDiffs.stream().allMatch(n -> {
+      var path = n.get("path").asText();
+      return ignoreList.stream().anyMatch(path::startsWith);
+    });
+  }
+
+  private static List<JsonNode> getDiffsWithPathSuffix(JsonNode diffJsonPatch,
+      String... ignorePaths) {
+    var res = new ArrayList<JsonNode>();
+    var prefixList = Arrays.asList(ignorePaths);
+    for (int i = 0; i < diffJsonPatch.size(); i++) {
+      var node = diffJsonPatch.get(i);
+      String path = diffJsonPatch.get(i).get("path").asText();
+      if (prefixList.stream().anyMatch(path::startsWith)) {
+        res.add(node);
+      }
+    }
+    return res;
+  }
+
   /**
    * Determines whether the specified actual resource matches the desired state defined by the
    * specified {@link KubernetesDependentResource} based on the observed state of the associated
@@ -133,6 +198,34 @@ public static <R extends HasMetadata, P extends HasMetadata> Result<R> match(
     return match(desired, actualResource, considerMetadata, strongEquality);
   }
 
+  /**
+   * Determines whether the specified actual resource matches the desired state defined by the
+   * specified {@link KubernetesDependentResource} based on the observed state of the associated
+   * specified primary resource.
+   *
+   * @param dependentResource the {@link KubernetesDependentResource} implementation used to compute
+   *        the desired state associated with the specified primary resource
+   * @param actualResource the observed dependent resource for which we want to determine whether it
+   *        matches the desired state or not
+   * @param primary the primary resource from which we want to compute the desired state
+   * @param context the {@link Context} instance within which this method is called
+   * @param considerMetadata {@code true} to consider the metadata of the actual resource when
+   *        determining if it matches the desired state, {@code false} if matching should occur only
+   *        considering the spec of the resources
+   * @return a {@link io.javaoperatorsdk.operator.processing.dependent.Matcher.Result} object
+   * @param <R> the type of resource we want to determine whether they match or not
+   * @param <P> the type of primary resources associated with the secondary resources we want to
+   *        match
+   * @param ignorePaths are paths in the resource that are ignored on matching. Anny related change
+   *        on a calculated JSON Patch between actual and desired will be ignored.
+   */
+  public static <R extends HasMetadata, P extends HasMetadata> Result<R> match(
+      KubernetesDependentResource<R, P> dependentResource, R actualResource, P primary,
+      Context<P> context, boolean considerMetadata, String... ignorePaths) {
+    final var desired = dependentResource.desired(primary, context);
+    return match(desired, actualResource, considerMetadata, ignorePaths);
+  }
+
   public static <R extends HasMetadata, P extends HasMetadata> Result<R> match(
       KubernetesDependentResource<R, P> dependentResource, R actualResource, P primary,
       Context<P> context, boolean considerMetadata) {

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

@@ -35,8 +35,8 @@ void checksIfDesiredValuesAreTheSame() {
     final var matcher =
         GenericKubernetesResourceMatcher.matcherFor(Deployment.class, dependentResource);
     assertThat(matcher.match(actual, null, context).matched()).isTrue();
-    assertThat(matcher.match(actual, null, context).computedDesired().isPresent()).isTrue();
-    assertThat(matcher.match(actual, null, context).computedDesired().get()).isEqualTo(desired);
+    assertThat(matcher.match(actual, null, context).computedDesired()).isPresent();
+    assertThat(matcher.match(actual, null, context).computedDesired()).contains(desired);
 
     actual.getSpec().getTemplate().getMetadata().getLabels().put("new-key", "val");
     assertThat(matcher.match(actual, null, context).matched())
@@ -59,6 +59,11 @@ void checksIfDesiredValuesAreTheSame() {
         .withFailMessage("Changed values are not ok")
         .isFalse();
 
+    assertThat(GenericKubernetesResourceMatcher
+        .match(dependentResource, actual, null, context, false, "/spec/replicas").matched())
+        .withFailMessage("Ignored paths are not matched")
+        .isTrue();
+
     actual = new DeploymentBuilder(createDeployment())
         .editOrNewMetadata()
         .addToAnnotations("test", "value")
@@ -70,9 +75,15 @@ void checksIfDesiredValuesAreTheSame() {
         .isTrue();
 
     assertThat(GenericKubernetesResourceMatcher
-        .match(dependentResource, actual, null, context, true).matched())
+        .match(dependentResource, actual, null, context, true, true).matched())
         .withFailMessage("Annotations should matter when metadata is considered")
         .isFalse();
+
+    assertThat(GenericKubernetesResourceMatcher
+        .match(dependentResource, actual, null, context, true, false).matched())
+        .withFailMessage("Non strong equality on labels and annotations")
+        .isTrue();
+
   }
 
   Deployment createDeployment() {