expiration improvements

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

Author: csviri

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

@@ -3,6 +3,8 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import io.javaoperatorsdk.operator.processing.expiration.Expiration;
+import io.javaoperatorsdk.operator.processing.expiration.RetryExpiration;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -12,30 +14,31 @@
 import io.javaoperatorsdk.operator.api.reconciler.Context;
 import io.javaoperatorsdk.operator.api.reconciler.dependent.DependentResource;
 import io.javaoperatorsdk.operator.processing.GroupVersionKind;
-import io.javaoperatorsdk.operator.processing.event.source.informer.InformerEventSource;
-import io.javaoperatorsdk.operator.processing.expiration.Expiration;
-import io.javaoperatorsdk.operator.processing.expiration.RetryExpiration;
+import io.javaoperatorsdk.operator.processing.expiration.ExpirationExecution;
 import io.javaoperatorsdk.operator.processing.retry.GenericRetry;
 import io.javaoperatorsdk.operator.processing.retry.Retry;
 
 public class CRDPresentActivationCondition implements Condition<HasMetadata, HasMetadata> {
 
-  public static Retry DEFAULT_EXPIRATION_RETRY = new GenericRetry().setInitialInterval(2000)
-      .setMaxInterval(1000 * 60 * 60)
-      .setIntervalMultiplier(2);
-
   private static final Logger log = LoggerFactory.getLogger(CRDPresentActivationCondition.class);
 
+  /**
+   *
+   * */
+  public static Retry DEFAULT_EXPIRATION_RETRY = new GenericRetry().setInitialInterval(2000)
+      .setIntervalMultiplier(2)
+      .setMaxAttempts(10);
+
   private final Map<GroupVersionKind, CRDCheckState> crdPresenceCache = new ConcurrentHashMap<>();
 
-  private final Retry expirationRetry;
+  private final Expiration expiration;
 
   public CRDPresentActivationCondition() {
-    this(DEFAULT_EXPIRATION_RETRY);
+    this(new RetryExpiration(DEFAULT_EXPIRATION_RETRY));
   }
 
-  public CRDPresentActivationCondition(Retry expirationRetry) {
-    this.expirationRetry = expirationRetry;
+  public CRDPresentActivationCondition(Expiration expiration) {
+    this.expiration = expiration;
   }
 
   @Override
@@ -47,60 +50,43 @@ public boolean isMet(DependentResource<HasMetadata, HasMetadata> dependentResour
     var kind = HasMetadata.getKind(resourceClass);
     var gvk = new GroupVersionKind(apiVersion, kind);
 
-    InformerEventSource<CustomResourceDefinition, HasMetadata> crdInformer = null;
-    try {
-      crdInformer = (InformerEventSource<CustomResourceDefinition, HasMetadata>) context
-          .eventSourceRetriever().getResourceEventSourceFor(CustomResourceDefinition.class);
-    } catch (IllegalArgumentException e) {
-      log.trace("Error when finding event source for CustomResourceDefinitions", e);
-    }
-
-    if (crdInformer != null) {
-      return crdInformer
-          .list(crd -> crd.getSpec().getNames().getKind().equals(kind)
-              && crd.getSpec().getGroup().equals(gvk.getGroup()))
-          .findAny().isPresent();
-    } else {
-      var crdCheckState = crdPresenceCache.computeIfAbsent(gvk,
-          g -> new CRDCheckState(new RetryExpiration(expirationRetry.initExecution())));
-      // in case of parallel execution it is only refreshed once
-      synchronized (crdCheckState) {
-        if (crdCheckState.getExpiration().isExpired()) {
-          refreshCache(gvk, context.getClient());
-        }
+    var crdCheckState = crdPresenceCache.computeIfAbsent(gvk,
+        g -> new CRDCheckState(expiration.initExecution()));
+    // in case of parallel execution it is only refreshed once
+    synchronized (crdCheckState) {
+      if (crdCheckState.getExpiration().isExpired()) {
+        refreshCache(crdCheckState,gvk, context.getClient());
       }
-      return crdPresenceCache.get(gvk).getCrdPresent();
     }
+    return crdPresenceCache.get(gvk).getCrdPresent();
   }
 
-  private void refreshCache(GroupVersionKind gvk, KubernetesClient client) {
-    var state = crdPresenceCache.computeIfAbsent(gvk,
-        g -> new CRDCheckState(new RetryExpiration(expirationRetry.initExecution())));
+  private void refreshCache(CRDCheckState crdCheckState, GroupVersionKind gvk, KubernetesClient client) {
 
     boolean found = client.resources(CustomResourceDefinition.class).list().getItems()
         .stream().anyMatch(crd -> crd.getSpec().getNames().getKind().equals(gvk.getKind())
             && crd.getSpec().getGroup().equals(gvk.getGroup()));
 
-    state.setCrdPresent(found);
-    state.getExpiration().refreshed();
+    crdCheckState.setCrdPresent(found);
+    crdCheckState.getExpiration().refreshed();
   }
 
   static class CRDCheckState {
 
-    public CRDCheckState(Expiration expiration) {
-      this.expiration = expiration;
+    public CRDCheckState(ExpirationExecution expirationExecution) {
+      this.expirationExecution = expirationExecution;
     }
 
-    private Expiration expiration;
+    private ExpirationExecution expirationExecution;
 
     private Boolean crdPresent;
 
-    public Expiration getExpiration() {
-      return expiration;
+    public ExpirationExecution getExpiration() {
+      return expirationExecution;
     }
 
-    public void setExpiration(Expiration expiration) {
-      this.expiration = expiration;
+    public void setExpiration(ExpirationExecution expirationExecution) {
+      this.expirationExecution = expirationExecution;
     }
 
     public Boolean getCrdPresent() {

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expiration/Expiration.java

@@ -1,9 +1,8 @@
 package io.javaoperatorsdk.operator.processing.expiration;
 
-public interface Expiration {
 
-  boolean isExpired();
+public interface Expiration {
 
-  void refreshed();
+    ExpirationExecution initExecution();
 
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expiration/ExpirationExecution.java

@@ -0,0 +1,9 @@
+package io.javaoperatorsdk.operator.processing.expiration;
+
+public interface ExpirationExecution {
+
+  boolean isExpired();
+
+  void refreshed();
+
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expiration/RetryExpiration.java

@@ -1,39 +1,17 @@
 package io.javaoperatorsdk.operator.processing.expiration;
 
-import java.time.LocalDateTime;
-import java.time.temporal.ChronoUnit;
-import java.util.Objects;
-
-import io.javaoperatorsdk.operator.processing.retry.RetryExecution;
+import io.javaoperatorsdk.operator.processing.retry.Retry;
 
 public class RetryExpiration implements Expiration {
 
-  public static final long NO_MORE_EXPIRATION = -1L;
-
-  private LocalDateTime lastRefreshTime;
-  private Long delayUntilExpiration;
-  private final RetryExecution retryExecution;
-
-  public RetryExpiration(RetryExecution retryExecution) {
-    this.retryExecution = retryExecution;
-  }
+    private final Retry retry;
 
-  @Override
-  public boolean isExpired() {
-    if (lastRefreshTime == null) {
-      return true;
+    public RetryExpiration(Retry retry) {
+        this.retry = retry;
     }
-    if (Objects.equals(delayUntilExpiration, NO_MORE_EXPIRATION)) {
-      return false;
-    } else {
-      return LocalDateTime.now()
-          .isAfter(lastRefreshTime.plus(delayUntilExpiration, ChronoUnit.MILLIS));
-    }
-  }
 
-  @Override
-  public void refreshed() {
-    lastRefreshTime = LocalDateTime.now();
-    delayUntilExpiration = retryExecution.nextDelay().orElse(NO_MORE_EXPIRATION);
-  }
+    @Override
+    public ExpirationExecution initExecution() {
+        return new RetryExpirationExecution(retry.initExecution());
+    }
 }

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/expiration/RetryExpirationExecution.java

@@ -0,0 +1,39 @@
+package io.javaoperatorsdk.operator.processing.expiration;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.Objects;
+
+import io.javaoperatorsdk.operator.processing.retry.RetryExecution;
+
+public class RetryExpirationExecution implements ExpirationExecution {
+
+  public static final long NO_MORE_EXPIRATION = -1L;
+
+  private LocalDateTime lastRefreshTime;
+  private Long delayUntilExpiration;
+  private final RetryExecution retryExecution;
+
+  public RetryExpirationExecution(RetryExecution retryExecution) {
+    this.retryExecution = retryExecution;
+  }
+
+  @Override
+  public boolean isExpired() {
+    if (lastRefreshTime == null) {
+      return true;
+    }
+    if (Objects.equals(delayUntilExpiration, NO_MORE_EXPIRATION)) {
+      return false;
+    } else {
+      return LocalDateTime.now()
+          .isAfter(lastRefreshTime.plus(delayUntilExpiration, ChronoUnit.MILLIS));
+    }
+  }
+
+  @Override
+  public void refreshed() {
+    lastRefreshTime = LocalDateTime.now();
+    delayUntilExpiration = retryExecution.nextDelay().orElse(NO_MORE_EXPIRATION);
+  }
+}

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/expiration/RetryExpirationTest.java renamed to operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/expiration/RetryExpirationTestExecution.java

@@ -6,12 +6,12 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class RetryExpirationTest {
+public class RetryExpirationTestExecution {
 
   public static final int INITIAL_INTERVAL = 25;
   public static final int INITIAL_INTERVAL_PLUS_SLACK = INITIAL_INTERVAL + 10;
 
-  RetryExpiration expiration = new RetryExpiration(new GenericRetry()
+  RetryExpirationExecution expiration = new RetryExpirationExecution(new GenericRetry()
       .setInitialInterval(INITIAL_INTERVAL)
       .setMaxAttempts(2)
       .initExecution());