feat: bounded cache (variant 2)

Author: csviri

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/cache/BoundedCache.java

@@ -0,0 +1,18 @@
+package io.javaoperatorsdk.operator.processing.event.source.cache;
+
+import java.util.Set;
+
+// todo: rename to cache?
+public interface BoundedCache<K, R> {
+
+  R get(K key);
+
+  R remove(K key);
+
+  R put(K key, R object);
+
+  Set<K> keys();
+
+  Set<R> values();
+
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/cache/BoundedItemStore.java

@@ -0,0 +1,46 @@
+package io.javaoperatorsdk.operator.processing.event.source.cache;
+
+import java.util.HashSet;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.fabric8.kubernetes.client.informers.cache.ItemStore;
+
+public class BoundedItemStore<R extends HasMetadata> extends BoundedStore<String, R>
+    implements ItemStore<R> {
+
+  private final Function<R, String> keyFunction;
+
+  public BoundedItemStore(KubernetesResourceFetcher<R> resourceFetcher,
+      BoundedCache<String, R> cache, Function<R, String> keyFunction) {
+    super(resourceFetcher, cache);
+    this.keyFunction = keyFunction;
+  }
+
+  @Override
+  public String getKey(R obj) {
+    return keyFunction.apply(obj);
+  }
+
+  @Override
+  public Stream<String> keySet() {
+    return super.keys();
+  }
+
+  /** This is very inefficient but should not be called by the Informer or just */
+  @Override
+  public Stream<R> values() {
+    var keys = cache.keys();
+    var values = cache.values();
+    var notPresentValueKeys = new HashSet<>(existingResources);
+    notPresentValueKeys.retainAll(keys);
+    var fetchedValues = notPresentValueKeys.stream().map(k -> fetchAndCacheResource(k));
+    return Stream.concat(values.stream(), fetchedValues);
+  }
+
+  @Override
+  public int size() {
+    return existingResources.size();
+  }
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/cache/BoundedStore.java

@@ -0,0 +1,52 @@
+package io.javaoperatorsdk.operator.processing.event.source.cache;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class BoundedStore<K, R> {
+
+  protected final ResourceFetcher<K, R> resourceFetcher;
+  protected final BoundedCache<K, R> cache;
+  protected Set<K> existingResources = Collections.synchronizedSet(new HashSet<>());;
+
+  public BoundedStore(ResourceFetcher<K, R> resourceFetcher, BoundedCache<K, R> cache) {
+    this.resourceFetcher = resourceFetcher;
+    this.cache = cache;
+  }
+
+  public R get(K key) {
+    var res = cache.get(key);
+    if (res != null) {
+      return res;
+    }
+    if (!existingResources.contains(key)) {
+      return null;
+    } else {
+      return fetchAndCacheResource(key);
+    }
+  }
+
+  public R remove(K key) {
+    existingResources.remove(key);
+    return cache.remove(key);
+  }
+
+  public R put(K key, R object) {
+    var res = cache.put(key, object);
+    existingResources.add(key);
+    return res;
+  }
+
+  public Stream<K> keys() {
+    return existingResources.stream();
+  }
+
+  protected R fetchAndCacheResource(K key) {
+    var newRes = resourceFetcher.fetchResource(key);
+    cache.put(key, newRes);
+    return newRes;
+  }
+
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/cache/KubernetesResourceFetcher.java

@@ -0,0 +1,32 @@
+package io.javaoperatorsdk.operator.processing.event.source.cache;
+
+import java.util.function.Function;
+
+import io.fabric8.kubernetes.api.model.HasMetadata;
+import io.fabric8.kubernetes.client.KubernetesClient;
+import io.javaoperatorsdk.operator.processing.event.ResourceID;
+
+public class KubernetesResourceFetcher<R extends HasMetadata>
+    implements ResourceFetcher<String, R> {
+
+  private final Class<R> rClass;
+  private final KubernetesClient client;
+  private final Function<String, ResourceID> resourceIDFunction;
+
+  public KubernetesResourceFetcher(Class<R> rClass,
+      KubernetesClient client,
+      Function<String, ResourceID> resourceIDFunction) {
+    this.rClass = rClass;
+    this.client = client;
+    this.resourceIDFunction = resourceIDFunction;
+  }
+
+  @Override
+  public R fetchResource(String key) {
+    var resourceId = resourceIDFunction.apply(key);
+    return resourceId.getNamespace().map(ns -> client.resources(rClass).inNamespace(ns)
+        .withName(resourceId.getName()).get())
+        .orElse(client.resources(rClass).withName(resourceId.getName()).get());
+
+  }
+}

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/cache/ResourceFetcher.java

@@ -0,0 +1,7 @@
+package io.javaoperatorsdk.operator.processing.event.source.cache;
+
+public interface ResourceFetcher<K, R> {
+
+  R fetchResource(K key);
+
+}

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/cache/BoundedStoreTest.java

@@ -0,0 +1,61 @@
+package io.javaoperatorsdk.operator.processing.event.source.cache;
+
+import org.junit.jupiter.api.Test;
+
+import io.fabric8.kubernetes.api.model.ConfigMap;
+import io.fabric8.kubernetes.api.model.ObjectMetaBuilder;
+import io.javaoperatorsdk.operator.processing.event.ResourceID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+class BoundedStoreTest {
+
+  ResourceFetcher<ResourceID, ConfigMap> resourceFetcher = mock(ResourceFetcher.class);
+  BoundedCache<ResourceID, ConfigMap> boundedCache = mock(BoundedCache.class);
+
+  BoundedStore<ResourceID, ConfigMap> boundedStore =
+      new BoundedStore<>(resourceFetcher, boundedCache);
+
+  @Test
+  void storesValue() {
+    boundedStore.put(ResourceID.fromResource(testValue1()), testValue1());
+
+    verify(boundedCache, times(1)).put(any(), any());
+  }
+
+
+  @Test
+  void fetchesResourceIfNotPresentInCache() {
+
+  }
+
+  @Test
+  void removesValueFromCache() {
+
+  }
+
+  @Test
+  void listKeys() {
+
+  }
+
+
+  ConfigMap testValue1() {
+    return testValue("test1");
+  }
+
+  ConfigMap testValue2() {
+    return testValue("test2");
+  }
+
+  ConfigMap testValue(String name) {
+    var cm = new ConfigMap();
+    cm.setMetadata(new ObjectMetaBuilder()
+        .withName(name)
+        .withNamespace("default")
+        .build());
+    return cm;
+  }
+}

operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCacheTest.java renamed to operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceBoundedCacheTest.java

@@ -14,7 +14,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-class TemporaryResourceCacheTest {
+class TemporaryResourceBoundedCacheTest {
 
   public static final String RESOURCE_VERSION = "1";
   @SuppressWarnings("unchecked")