wip

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

Author: csviri

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

@@ -29,6 +29,11 @@
 @Retention(RetentionPolicy.SOURCE)
 @Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD, ElementType.PACKAGE})
 public @interface Experimental {
+  /**
+   * Message for experimental features that we intend to keep and maintain, but
+   * the API might change usually, based on user feedback.
+   * */
+  String API_MIGHT_CHANGE = "API might change, usually based on feedback";
 
   /**
    * Describes why the annotated element is experimental.

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expectation/Expectation.java

@@ -1,10 +1,27 @@
+/*
+ * Copyright Java Operator SDK Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.javaoperatorsdk.operator.processing.expectation;
 
 import java.util.function.BiPredicate;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.reconciler.Context;
+import io.javaoperatorsdk.operator.api.reconciler.Experimental;
 
+@Experimental("based on feedback the API might change")
 public interface Expectation<P extends HasMetadata> {
 
   String UNNAMED = "unnamed";

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expectation/ExpectationManager.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright Java Operator SDK Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.javaoperatorsdk.operator.processing.expectation;
 
 import java.time.Duration;
@@ -7,47 +22,87 @@
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
 import io.javaoperatorsdk.operator.api.reconciler.Context;
+import io.javaoperatorsdk.operator.api.reconciler.Experimental;
 import io.javaoperatorsdk.operator.processing.event.ResourceID;
 
+import static io.javaoperatorsdk.operator.api.reconciler.Experimental.API_MIGHT_CHANGE;
+
+@Experimental(API_MIGHT_CHANGE)
 public class ExpectationManager<P extends HasMetadata> {
 
   protected final ConcurrentHashMap<ResourceID, RegisteredExpectation<P>> registeredExpectations =
       new ConcurrentHashMap<>();
 
-  public void setExpectation(P primary, Expectation<P> expectation, Duration timeout) {
+  public void setExpectation(P primary, Duration timeout, Expectation<P> expectation) {
     registeredExpectations.put(
         ResourceID.fromResource(primary),
         new RegisteredExpectation<>(LocalDateTime.now(), timeout, expectation));
   }
 
   /**
-   * Checks if provided expectation is fulfilled. Return the expectation result. If the result of
-   * expectation is fulfilled or timed out, the expectation is automatically removed;
+   * Checks on expectation with provided name. Return the expectation result. If the result of
+   * expectation is fulfilled, the expectation is automatically removed;
    */
-  public Optional<ExpectationResult<P>> checkOnExpectation(P primary, Context<P> context) {
+  public ExpectationResult<P> checkExpectation(
+      String expectationName, P primary, Context<P> context) {
     var resourceID = ResourceID.fromResource(primary);
-    var regExp = registeredExpectations.get(ResourceID.fromResource(primary));
-    if (regExp == null) {
-      return Optional.empty();
+    var exp = registeredExpectations.get(ResourceID.fromResource(primary));
+    if (exp != null && expectationName.equals(exp.expectation().name())) {
+      return checkExpectation(exp, resourceID, primary, context);
+    } else {
+      return checkExpectation(null, resourceID, primary, context);
     }
-    if (regExp.expectation().isFulfilled(primary, context)) {
-      registeredExpectations.remove(resourceID);
-      return Optional.of(
-          new ExpectationResult<>(regExp.expectation(), ExpectationStatus.FULFILLED));
-    } else if (regExp.isTimedOut()) {
+  }
+
+  /**
+   * Checks if actual expectation is fulfilled. Return the expectation result. If the result of
+   * expectation is fulfilled, the expectation is automatically removed;
+   */
+  public ExpectationResult<P> checkExpectation(P primary, Context<P> context) {
+    var resourceID = ResourceID.fromResource(primary);
+    var exp = registeredExpectations.get(ResourceID.fromResource(primary));
+    return checkExpectation(exp, resourceID, primary, context);
+  }
+
+  private ExpectationResult<P> checkExpectation(
+      RegisteredExpectation<P> exp, ResourceID resourceID, P primary, Context<P> context) {
+    if (exp == null) {
+      return new ExpectationResult<>(null, null);
+    }
+    if (exp.expectation().isFulfilled(primary, context)) {
       registeredExpectations.remove(resourceID);
-      return Optional.of(
-          new ExpectationResult<>(regExp.expectation(), ExpectationStatus.TIMED_OUT));
+      return new ExpectationResult<>(exp.expectation(), ExpectationStatus.FULFILLED);
+    } else if (exp.isTimedOut()) {
+      // we don't remove the expectation so user knows about it's state
+      return new ExpectationResult<>(exp.expectation(), ExpectationStatus.TIMED_OUT);
     } else {
-      return Optional.of(
-          new ExpectationResult<>(regExp.expectation(), ExpectationStatus.NOT_FULFILLED));
+      return new ExpectationResult<>(exp.expectation(), ExpectationStatus.NOT_YET_FULFILLED);
+    }
+  }
+
+  /*
+   * Returns true if there is an expectation for the primary resource, but it is not yet fulfilled
+   * neither timed out.
+   * The intention behind is that you can exit reconciliation early with a simple check
+   * if true.
+   * */
+  public boolean ongoingExpectationPresent(P primary, Context<P> context) {
+    var exp = registeredExpectations.get(ResourceID.fromResource(primary));
+    if (exp == null) {
+      return false;
     }
+    return !exp.isTimedOut() && !exp.expectation().isFulfilled(primary, context);
   }
 
   public boolean isExpectationPresent(P primary) {
     return registeredExpectations.containsKey(ResourceID.fromResource(primary));
   }
 
+  public boolean isExpectationPresent(String name, P primary) {
+    var exp = registeredExpectations.get(ResourceID.fromResource(primary));
+    return exp != null && name.equals(exp.expectation().name());
+  }
+
   public Optional<Expectation<P>> getExpectation(P primary) {
     var regExp = registeredExpectations.get(ResourceID.fromResource(primary));
     return Optional.ofNullable(regExp).map(RegisteredExpectation::expectation);
@@ -57,6 +112,10 @@ public Optional<String> getExpectationName(P primary) {
     return getExpectation(primary).map(Expectation::name);
   }
 
+  public void removeExpectation(P primary) {
+    registeredExpectations.remove(ResourceID.fromResource(primary));
+  }
+
   public void cleanup(P primary) {
     registeredExpectations.remove(ResourceID.fromResource(primary));
   }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expectation/ExpectationResult.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright Java Operator SDK Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.javaoperatorsdk.operator.processing.expectation;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
@@ -13,6 +28,14 @@ public boolean isTimedOut() {
     return status == ExpectationStatus.TIMED_OUT;
   }
 
+  public boolean isExpectationPresent() {
+    return expectation != null;
+  }
+
+  public boolean isNotPresentOrFulfilled() {
+    return !isExpectationPresent() || isFulfilled();
+  }
+
   public String name() {
     return expectation.name();
   }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expectation/ExpectationStatus.java

@@ -1,7 +1,22 @@
+/*
+ * Copyright Java Operator SDK Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.javaoperatorsdk.operator.processing.expectation;
 
 public enum ExpectationStatus {
   FULFILLED,
-  NOT_FULFILLED,
+  NOT_YET_FULFILLED,
   TIMED_OUT
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expectation/PeriodicCleanerExpectationManager.java

@@ -1,17 +1,43 @@
+/*
+ * Copyright Java Operator SDK Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.javaoperatorsdk.operator.processing.expectation;
 
 import java.time.Duration;
-import java.time.LocalDateTime;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
 import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.javaoperatorsdk.operator.api.reconciler.ControllerConfiguration;
+import io.javaoperatorsdk.operator.api.reconciler.Experimental;
 import io.javaoperatorsdk.operator.api.reconciler.IndexedResourceCache;
 
+import static io.javaoperatorsdk.operator.api.reconciler.Experimental.API_MIGHT_CHANGE;
+
+/**
+ * Expectation manager implementation that works without enabling {@link
+ * ControllerConfiguration#triggerReconcilerOnAllEvent()}. Periodically checks and cleanups'
+ * expectations for primary resources which are no longer present in the cache.
+ */
+@Experimental(API_MIGHT_CHANGE)
 public class PeriodicCleanerExpectationManager<P extends HasMetadata>
     extends ExpectationManager<P> {
 
+  public static final Duration DEFAULT_CHECK_PERIOD = Duration.ofMinutes(1);
+
   private final ScheduledExecutorService scheduler =
       Executors.newScheduledThreadPool(
           1,
@@ -21,41 +47,20 @@ public class PeriodicCleanerExpectationManager<P extends HasMetadata>
             return thread;
           });
 
-  private final Duration cleanupDelayAfterExpiration;
   private final IndexedResourceCache<P> primaryCache;
 
-  public PeriodicCleanerExpectationManager(Duration period, Duration cleanupDelayAfterExpiration) {
-    this(period, cleanupDelayAfterExpiration, null);
+  public PeriodicCleanerExpectationManager(IndexedResourceCache<P> primaryCache) {
+    this(DEFAULT_CHECK_PERIOD, primaryCache);
   }
 
   public PeriodicCleanerExpectationManager(Duration period, IndexedResourceCache<P> primaryCache) {
-    this(period, null, primaryCache);
-  }
-
-  private PeriodicCleanerExpectationManager(
-      Duration period, Duration cleanupDelayAfterExpiration, IndexedResourceCache<P> primaryCache) {
-    this.cleanupDelayAfterExpiration = cleanupDelayAfterExpiration;
     this.primaryCache = primaryCache;
     scheduler.scheduleWithFixedDelay(
         this::clean, period.toMillis(), period.toMillis(), TimeUnit.MICROSECONDS);
   }
 
   public void clean() {
-    registeredExpectations
-        .entrySet()
-        .removeIf(
-            e -> {
-              if (cleanupDelayAfterExpiration != null) {
-                return LocalDateTime.now()
-                    .isAfter(
-                        e.getValue()
-                            .registeredAt()
-                            .plus(e.getValue().timeout())
-                            .plus(cleanupDelayAfterExpiration));
-              } else {
-                return primaryCache.get(e.getKey()).isEmpty();
-              }
-            });
+    registeredExpectations.entrySet().removeIf(e -> primaryCache.get(e.getKey()).isEmpty());
   }
 
   void stop() {

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expectation/RegisteredExpectation.java

@@ -1,3 +1,18 @@
+/*
+ * Copyright Java Operator SDK Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.javaoperatorsdk.operator.processing.expectation;
 
 import java.time.Duration;