improve: move compare resource version methods to internal utils (#3137)

This should not be user facing. At least not in any obvious scenerio.

Signed-off-by: Attila Mészáros <a_meszaros@apple.com>

Author: csviri

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/ReconcilerUtilsInternal.java

@@ -31,6 +31,7 @@
 import io.fabric8.kubernetes.client.utils.Serialization;
 import io.javaoperatorsdk.operator.api.reconciler.Constants;
 import io.javaoperatorsdk.operator.api.reconciler.ControllerConfiguration;
+import io.javaoperatorsdk.operator.api.reconciler.NonComparableResourceVersionException;
 import io.javaoperatorsdk.operator.api.reconciler.Reconciler;
 
 @SuppressWarnings("rawtypes")
@@ -241,4 +242,123 @@ private static boolean matchesResourceType(
     }
     return false;
   }
+
+  /**
+   * Compares resource versions of two resources. This is a convenience method that extracts the
+   * resource versions from the metadata and delegates to {@link
+   * #validateAndCompareResourceVersions(String, String)}.
+   *
+   * @param h1 first resource
+   * @param h2 second resource
+   * @return negative if h1 is older, zero if equal, positive if h1 is newer
+   * @throws NonComparableResourceVersionException if either resource version is invalid
+   */
+  public static int validateAndCompareResourceVersions(HasMetadata h1, HasMetadata h2) {
+    return validateAndCompareResourceVersions(
+        h1.getMetadata().getResourceVersion(), h2.getMetadata().getResourceVersion());
+  }
+
+  /**
+   * Compares the resource versions of two Kubernetes resources.
+   *
+   * <p>This method extracts the resource versions from the metadata of both resources and delegates
+   * to {@link #compareResourceVersions(String, String)} for the actual comparison.
+   *
+   * @param h1 the first resource to compare
+   * @param h2 the second resource to compare
+   * @return a negative integer if h1's version is less than h2's version, zero if they are equal,
+   *     or a positive integer if h1's version is greater than h2's version
+   * @see #compareResourceVersions(String, String)
+   */
+  public static int compareResourceVersions(HasMetadata h1, HasMetadata h2) {
+    return compareResourceVersions(
+        h1.getMetadata().getResourceVersion(), h2.getMetadata().getResourceVersion());
+  }
+
+  /**
+   * Compares two resource version strings using a length-first, then lexicographic comparison
+   * algorithm.
+   *
+   * <p>The comparison is performed in two steps:
+   *
+   * <ol>
+   *   <li>First, compare the lengths of the version strings. A longer version string is considered
+   *       greater than a shorter one. This works correctly for numeric versions because larger
+   *       numbers have more digits (e.g., "100" > "99").
+   *   <li>If the lengths are equal, perform a character-by-character lexicographic comparison until
+   *       a difference is found.
+   * </ol>
+   *
+   * <p>This algorithm is more efficient than parsing the versions as numbers, especially for
+   * Kubernetes resource versions which are typically monotonically increasing numeric strings.
+   *
+   * <p><strong>Note:</strong> This method does not validate that the input strings are numeric. For
+   * validated numeric comparison, use {@link #validateAndCompareResourceVersions(String, String)}.
+   *
+   * @param v1 the first resource version string
+   * @param v2 the second resource version string
+   * @return a negative integer if v1 is less than v2, zero if they are equal, or a positive integer
+   *     if v1 is greater than v2
+   * @see #validateAndCompareResourceVersions(String, String)
+   */
+  public static int compareResourceVersions(String v1, String v2) {
+    int comparison = v1.length() - v2.length();
+    if (comparison != 0) {
+      return comparison;
+    }
+    for (int i = 0; i < v2.length(); i++) {
+      int comp = v1.charAt(i) - v2.charAt(i);
+      if (comp != 0) {
+        return comp;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * Compares two Kubernetes resource versions numerically. Kubernetes resource versions are
+   * expected to be numeric strings that increase monotonically. This method assumes both versions
+   * are valid numeric strings without leading zeros.
+   *
+   * @param v1 first resource version
+   * @param v2 second resource version
+   * @return negative if v1 is older, zero if equal, positive if v1 is newer
+   * @throws NonComparableResourceVersionException if either resource version is empty, has leading
+   *     zeros, or contains non-numeric characters
+   */
+  public static int validateAndCompareResourceVersions(String v1, String v2) {
+    int v1Length = validateResourceVersion(v1);
+    int v2Length = validateResourceVersion(v2);
+    int comparison = v1Length - v2Length;
+    if (comparison != 0) {
+      return comparison;
+    }
+    for (int i = 0; i < v2Length; i++) {
+      int comp = v1.charAt(i) - v2.charAt(i);
+      if (comp != 0) {
+        return comp;
+      }
+    }
+    return 0;
+  }
+
+  private static int validateResourceVersion(String v1) {
+    int v1Length = v1.length();
+    if (v1Length == 0) {
+      throw new NonComparableResourceVersionException("Resource version is empty");
+    }
+    for (int i = 0; i < v1Length; i++) {
+      char char1 = v1.charAt(i);
+      if (char1 == '0') {
+        if (i == 0) {
+          throw new NonComparableResourceVersionException(
+              "Resource version cannot begin with 0: " + v1);
+        }
+      } else if (char1 < '0' || char1 > '9') {
+        throw new NonComparableResourceVersionException(
+            "Non numeric characters in resource version: " + v1);
+      }
+    }
+    return v1Length;
+  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/ReconcileUtils.java

@@ -595,123 +595,4 @@ public static <P extends HasMetadata> P addFinalizerWithSSA(
           e);
     }
   }
-
-  /**
-   * Compares resource versions of two resources. This is a convenience method that extracts the
-   * resource versions from the metadata and delegates to {@link
-   * #validateAndCompareResourceVersions(String, String)}.
-   *
-   * @param h1 first resource
-   * @param h2 second resource
-   * @return negative if h1 is older, zero if equal, positive if h1 is newer
-   * @throws NonComparableResourceVersionException if either resource version is invalid
-   */
-  public static int validateAndCompareResourceVersions(HasMetadata h1, HasMetadata h2) {
-    return validateAndCompareResourceVersions(
-        h1.getMetadata().getResourceVersion(), h2.getMetadata().getResourceVersion());
-  }
-
-  /**
-   * Compares the resource versions of two Kubernetes resources.
-   *
-   * <p>This method extracts the resource versions from the metadata of both resources and delegates
-   * to {@link #compareResourceVersions(String, String)} for the actual comparison.
-   *
-   * @param h1 the first resource to compare
-   * @param h2 the second resource to compare
-   * @return a negative integer if h1's version is less than h2's version, zero if they are equal,
-   *     or a positive integer if h1's version is greater than h2's version
-   * @see #compareResourceVersions(String, String)
-   */
-  public static int compareResourceVersions(HasMetadata h1, HasMetadata h2) {
-    return compareResourceVersions(
-        h1.getMetadata().getResourceVersion(), h2.getMetadata().getResourceVersion());
-  }
-
-  /**
-   * Compares two resource version strings using a length-first, then lexicographic comparison
-   * algorithm.
-   *
-   * <p>The comparison is performed in two steps:
-   *
-   * <ol>
-   *   <li>First, compare the lengths of the version strings. A longer version string is considered
-   *       greater than a shorter one. This works correctly for numeric versions because larger
-   *       numbers have more digits (e.g., "100" > "99").
-   *   <li>If the lengths are equal, perform a character-by-character lexicographic comparison until
-   *       a difference is found.
-   * </ol>
-   *
-   * <p>This algorithm is more efficient than parsing the versions as numbers, especially for
-   * Kubernetes resource versions which are typically monotonically increasing numeric strings.
-   *
-   * <p><strong>Note:</strong> This method does not validate that the input strings are numeric. For
-   * validated numeric comparison, use {@link #validateAndCompareResourceVersions(String, String)}.
-   *
-   * @param v1 the first resource version string
-   * @param v2 the second resource version string
-   * @return a negative integer if v1 is less than v2, zero if they are equal, or a positive integer
-   *     if v1 is greater than v2
-   * @see #validateAndCompareResourceVersions(String, String)
-   */
-  public static int compareResourceVersions(String v1, String v2) {
-    int comparison = v1.length() - v2.length();
-    if (comparison != 0) {
-      return comparison;
-    }
-    for (int i = 0; i < v2.length(); i++) {
-      int comp = v1.charAt(i) - v2.charAt(i);
-      if (comp != 0) {
-        return comp;
-      }
-    }
-    return 0;
-  }
-
-  /**
-   * Compares two Kubernetes resource versions numerically. Kubernetes resource versions are
-   * expected to be numeric strings that increase monotonically. This method assumes both versions
-   * are valid numeric strings without leading zeros.
-   *
-   * @param v1 first resource version
-   * @param v2 second resource version
-   * @return negative if v1 is older, zero if equal, positive if v1 is newer
-   * @throws NonComparableResourceVersionException if either resource version is empty, has leading
-   *     zeros, or contains non-numeric characters
-   */
-  public static int validateAndCompareResourceVersions(String v1, String v2) {
-    int v1Length = validateResourceVersion(v1);
-    int v2Length = validateResourceVersion(v2);
-    int comparison = v1Length - v2Length;
-    if (comparison != 0) {
-      return comparison;
-    }
-    for (int i = 0; i < v2Length; i++) {
-      int comp = v1.charAt(i) - v2.charAt(i);
-      if (comp != 0) {
-        return comp;
-      }
-    }
-    return 0;
-  }
-
-  private static int validateResourceVersion(String v1) {
-    int v1Length = v1.length();
-    if (v1Length == 0) {
-      throw new NonComparableResourceVersionException("Resource version is empty");
-    }
-    for (int i = 0; i < v1Length; i++) {
-      char char1 = v1.charAt(i);
-      if (char1 == '0') {
-        if (i == 0) {
-          throw new NonComparableResourceVersionException(
-              "Resource version cannot begin with 0: " + v1);
-        }
-      } else if (char1 < '0' || char1 > '9') {
-        throw new NonComparableResourceVersionException(
-            "Non numeric characters in resource version: " + v1);
-      }
-    }
-    return v1Length;
-  }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/EventFilterDetails.java

@@ -17,7 +17,7 @@
 
 import java.util.Optional;
 
-import io.javaoperatorsdk.operator.api.reconciler.ReconcileUtils;
+import io.javaoperatorsdk.operator.ReconcilerUtilsInternal;
 import io.javaoperatorsdk.operator.processing.event.source.controller.ResourceEvent;
 
 class EventFilterDetails {
@@ -41,7 +41,7 @@ public void setLastEvent(ResourceEvent event) {
   public Optional<ResourceEvent> getLatestEventAfterLastUpdateEvent(String updatedResourceVersion) {
     if (lastEvent != null
         && (updatedResourceVersion == null
-            || ReconcileUtils.compareResourceVersions(
+            || ReconcilerUtilsInternal.compareResourceVersions(
                     lastEvent.getResource().orElseThrow().getMetadata().getResourceVersion(),
                     updatedResourceVersion)
                 > 0)) {

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/ManagedInformerEventSource.java

@@ -32,10 +32,10 @@
 import io.fabric8.kubernetes.client.dsl.MixedOperation;
 import io.fabric8.kubernetes.client.informers.ResourceEventHandler;
 import io.javaoperatorsdk.operator.OperatorException;
+import io.javaoperatorsdk.operator.ReconcilerUtilsInternal;
 import io.javaoperatorsdk.operator.api.config.ControllerConfiguration;
 import io.javaoperatorsdk.operator.api.config.Informable;
 import io.javaoperatorsdk.operator.api.config.NamespaceChangeable;
-import io.javaoperatorsdk.operator.api.reconciler.ReconcileUtils;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.RecentOperationCacheFiller;
 import io.javaoperatorsdk.operator.health.InformerHealthIndicator;
 import io.javaoperatorsdk.operator.health.InformerWrappingEventSourceHealthIndicator;
@@ -181,7 +181,8 @@ public Optional<R> get(ResourceID resourceID) {
     Optional<R> resource = temporaryResourceCache.getResourceFromCache(resourceID);
     if (comparableResourceVersions
         && resource.isPresent()
-        && res.filter(r -> ReconcileUtils.compareResourceVersions(r, resource.orElseThrow()) > 0)
+        && res.filter(
+                r -> ReconcilerUtilsInternal.compareResourceVersions(r, resource.orElseThrow()) > 0)
             .isEmpty()) {
       log.debug("Latest resource found in temporary cache for Resource ID: {}", resourceID);
       return resource;

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCache.java

@@ -24,7 +24,7 @@
 import org.slf4j.LoggerFactory;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
-import io.javaoperatorsdk.operator.api.reconciler.ReconcileUtils;
+import io.javaoperatorsdk.operator.ReconcilerUtilsInternal;
 import io.javaoperatorsdk.operator.processing.dependent.kubernetes.KubernetesDependentResource;
 import io.javaoperatorsdk.operator.processing.event.ResourceID;
 import io.javaoperatorsdk.operator.processing.event.source.ResourceAction;
@@ -128,7 +128,7 @@ private synchronized EventHandling onEvent(
     var cached = cache.get(resourceId);
     EventHandling result = EventHandling.NEW;
     if (cached != null) {
-      int comp = ReconcileUtils.compareResourceVersions(resource, cached);
+      int comp = ReconcilerUtilsInternal.compareResourceVersions(resource, cached);
       if (comp >= 0 || unknownState) {
         cache.remove(resourceId);
         // we propagate event only for our update or newer other can be discarded since we know we
@@ -174,7 +174,7 @@ public synchronized void putResource(T newResource) {
     // this also prevents resurrecting recently deleted entities for which the delete event
     // has already been processed
     if (latestResourceVersion != null
-        && ReconcileUtils.compareResourceVersions(
+        && ReconcilerUtilsInternal.compareResourceVersions(
                 latestResourceVersion, newResource.getMetadata().getResourceVersion())
             > 0) {
       log.debug(
@@ -189,7 +189,7 @@ public synchronized void putResource(T newResource) {
     var cachedResource = getResourceFromCache(resourceId).orElse(null);
 
     if (cachedResource == null
-        || ReconcileUtils.compareResourceVersions(newResource, cachedResource) > 0) {
+        || ReconcilerUtilsInternal.compareResourceVersions(newResource, cachedResource) > 0) {
       log.debug(
           "Temporarily moving ahead to target version {} for resource id: {}",
           newResource.getMetadata().getResourceVersion(),