diff --git a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/Informer.java b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/Informer.java index c8da5c0c7c..7f0d266684 100644 --- a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/Informer.java +++ b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/Informer.java @@ -27,7 +27,6 @@ import io.javaoperatorsdk.operator.processing.event.source.filter.OnAddFilter; import io.javaoperatorsdk.operator.processing.event.source.filter.OnDeleteFilter; import io.javaoperatorsdk.operator.processing.event.source.filter.OnUpdateFilter; -import io.javaoperatorsdk.operator.processing.event.source.informer.TemporaryResourceCache; import static io.javaoperatorsdk.operator.api.reconciler.Constants.DEFAULT_COMPARABLE_RESOURCE_VERSION; import static io.javaoperatorsdk.operator.api.reconciler.Constants.DEFAULT_FOLLOW_CONTROLLER_NAMESPACE_CHANGES; @@ -143,11 +142,9 @@ boolean comparableResourceVersions() default DEFAULT_COMPARABLE_RESOURCE_VERSION; /** - * For read-cache-after-write consistency there are some corner cases where we need to check the - * caches see {@link TemporaryResourceCache} periodically. This is the period in milliseconds. - * Applicable only if {@link #comparableResourceVersions()} is true. - * - * @since 5.3.0 + * @deprecated Ghost resource checking is now triggered by the informer's onList callback. This + * setting is no longer used. */ + @Deprecated(forRemoval = true) long ghostResourceCacheCheckInterval() default DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL_MILLIS; } diff --git a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerConfiguration.java b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerConfiguration.java index a3637b6929..aab7fad4ff 100644 --- a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerConfiguration.java +++ b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerConfiguration.java @@ -55,7 +55,6 @@ public class InformerConfiguration { private Long informerListLimit; private FieldSelector fieldSelector; private Boolean comparableResourceVersions; - private Duration ghostResourceCacheCheckInterval; protected InformerConfiguration( Class resourceClass, @@ -70,8 +69,7 @@ protected InformerConfiguration( ItemStore itemStore, Long informerListLimit, FieldSelector fieldSelector, - Boolean comparableResourceVersions, - Duration ghostResourceCacheCheckInterval) { + Boolean comparableResourceVersions) { this(resourceClass); this.name = name; this.namespaces = namespaces; @@ -85,7 +83,6 @@ protected InformerConfiguration( this.informerListLimit = informerListLimit; this.fieldSelector = fieldSelector; this.comparableResourceVersions = comparableResourceVersions; - this.ghostResourceCacheCheckInterval = ghostResourceCacheCheckInterval; } private InformerConfiguration(Class resourceClass) { @@ -121,8 +118,7 @@ public static InformerConfiguration.Builder builder( original.itemStore, original.informerListLimit, original.fieldSelector, - original.comparableResourceVersions, - original.ghostResourceCacheCheckInterval) + original.comparableResourceVersions) .builder; } @@ -301,10 +297,6 @@ public boolean isComparableResourceVersions() { return comparableResourceVersions; } - public Duration getGhostResourceCacheCheckInterval() { - return ghostResourceCacheCheckInterval; - } - @SuppressWarnings("UnusedReturnValue") public class Builder { @@ -323,9 +315,6 @@ public InformerConfiguration buildForController() { comparableResourceVersions = DEFAULT_COMPARABLE_RESOURCE_VERSION; } - if (ghostResourceCacheCheckInterval == null) { - ghostResourceCacheCheckInterval = DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL; - } return InformerConfiguration.this; } @@ -341,10 +330,6 @@ public InformerConfiguration build() { comparableResourceVersions = DEFAULT_COMPARABLE_RESOURCE_VERSION; } - if (ghostResourceCacheCheckInterval == null) { - ghostResourceCacheCheckInterval = DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL; - } - return InformerConfiguration.this; } @@ -392,8 +377,6 @@ public InformerConfiguration.Builder initFromAnnotation( .map(f -> new FieldSelector.Field(f.path(), f.value(), f.negated())) .toList())); withComparableResourceVersions(informerConfig.comparableResourceVersions()); - withGhostResourceCacheCheckInterval( - Duration.ofMillis(informerConfig.ghostResourceCacheCheckInterval())); } return this; } @@ -500,8 +483,8 @@ public Builder withComparableResourceVersions(boolean comparableResourceVersions return this; } + @Deprecated(forRemoval = true) public Builder withGhostResourceCacheCheckInterval(Duration ghostResourceCacheCheckInterval) { - InformerConfiguration.this.ghostResourceCacheCheckInterval = ghostResourceCacheCheckInterval; return this; } } diff --git a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerEventSourceConfiguration.java b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerEventSourceConfiguration.java index 31851044d9..1a1d8956fc 100644 --- a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerEventSourceConfiguration.java +++ b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/config/informer/InformerEventSourceConfiguration.java @@ -291,9 +291,9 @@ public Builder withComparableResourceVersion(boolean comparableResourceVersio return this; } + @Deprecated(forRemoval = true) public Builder withGhostResourceCacheCheckInterval( Duration ghostResourceCacheCheckInterval) { - config.withGhostResourceCacheCheckInterval(ghostResourceCacheCheckInterval); return this; } diff --git a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Constants.java b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Constants.java index 5d5f7a70cb..fad19d2021 100644 --- a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Constants.java +++ b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Constants.java @@ -44,7 +44,10 @@ public final class Constants { public static final boolean DEFAULT_FOLLOW_CONTROLLER_NAMESPACE_CHANGES = true; public static final boolean DEFAULT_COMPARABLE_RESOURCE_VERSION = true; + @Deprecated(forRemoval = true) public static final long DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL_MILLIS = 3 * 60 * 1000; + + @Deprecated(forRemoval = true) public static final Duration DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL = Duration.ofMillis(DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL_MILLIS); diff --git a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/ManagedInformerEventSource.java b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/ManagedInformerEventSource.java index 26543e8322..3b9898b133 100644 --- a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/ManagedInformerEventSource.java +++ b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/ManagedInformerEventSource.java @@ -153,15 +153,7 @@ public synchronized void start() { if (isRunning()) { return; } - temporaryResourceCache = - new TemporaryResourceCache<>( - comparableResourceVersions, - configuration.getInformerConfig().getGhostResourceCacheCheckInterval().toMillis(), - controllerConfiguration - .getConfigurationService() - .getExecutorServiceManager() - .scheduledExecutorService(), - this); + temporaryResourceCache = new TemporaryResourceCache<>(comparableResourceVersions, this); this.cache = new InformerManager<>(client, configuration, this); cache.setControllerConfiguration(controllerConfiguration); cache.addIndexers(indexers); @@ -178,6 +170,11 @@ public synchronized void stop() { manager().stop(); } + @Override + public void onList(String resourceVersion, boolean remainedEmpty) { + temporaryResourceCache.checkGhostResources(); + } + @Override public void handleRecentResourceUpdate( ResourceID resourceID, R resource, R previousVersionOfResource) { diff --git a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCache.java b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCache.java index 5a4486f756..d5a39f785b 100644 --- a/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCache.java +++ b/operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCache.java @@ -19,8 +19,6 @@ import java.util.Map; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -71,18 +69,9 @@ public enum EventHandling { public TemporaryResourceCache( boolean comparableResourceVersions, - long ghostResourceCheckInterval, - ScheduledExecutorService ghostCheckExecutor, ManagedInformerEventSource managedInformerEventSource) { this.comparableResourceVersions = comparableResourceVersions; this.managedInformerEventSource = managedInformerEventSource; - if (comparableResourceVersions) { - ghostCheckExecutor.scheduleWithFixedDelay( - this::checkGhostResources, - ghostResourceCheckInterval, - ghostResourceCheckInterval, - TimeUnit.MILLISECONDS); - } } public synchronized void startEventFilteringModify(ResourceID resourceID) { @@ -238,9 +227,10 @@ private String getLastSyncResourceVersion(String namespace) { * resources: when we create a resource that is deleted right after by third party and the related * informer have a disconnected watch and this watch needs to do a re-list when connected again. * In this case neither the ADD nor DELETE event will be propagated to the informer, but we - * explicitly add resources to this cache. Those are cleaned up by this check. + * explicitly add resources to this cache. Those are cleaned up by this check, which is triggered + * by the informer's onList callback. */ - private void checkGhostResources() { + public void checkGhostResources() { log.debug("Checking for ghost resources."); var iterator = cache.entrySet().iterator(); while (iterator.hasNext()) { diff --git a/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/controller/ControllerEventSourceTest.java b/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/controller/ControllerEventSourceTest.java index 820768d6a2..4528fa8a83 100644 --- a/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/controller/ControllerEventSourceTest.java +++ b/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/controller/ControllerEventSourceTest.java @@ -30,7 +30,6 @@ import io.javaoperatorsdk.operator.api.config.ControllerConfiguration; import io.javaoperatorsdk.operator.api.config.ResolvedControllerConfiguration; import io.javaoperatorsdk.operator.api.config.informer.InformerConfiguration; -import io.javaoperatorsdk.operator.api.reconciler.Constants; import io.javaoperatorsdk.operator.api.reconciler.Reconciler; import io.javaoperatorsdk.operator.api.reconciler.UpdateControl; import io.javaoperatorsdk.operator.processing.Controller; @@ -64,8 +63,6 @@ public void setup() { when(controllerConfig.getConfigurationService()).thenReturn(new BaseConfigurationService()); var ic = mock(InformerConfiguration.class); when(controllerConfig.getInformerConfig()).thenReturn(ic); - when(ic.getGhostResourceCacheCheckInterval()) - .thenReturn(Constants.DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL); setUpSource(new ControllerEventSource<>(testController), true, controllerConfig); } @@ -329,7 +326,6 @@ public TestConfiguration( .withOnUpdateFilter(onUpdateFilter) .withGenericFilter(genericFilter) .withComparableResourceVersions(true) - .withGhostResourceCacheCheckInterval(Constants.DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL) .buildForController(), false); } diff --git a/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/InformerEventSourceTest.java b/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/InformerEventSourceTest.java index e60ac02280..87119c86c6 100644 --- a/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/InformerEventSourceTest.java +++ b/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/InformerEventSourceTest.java @@ -19,8 +19,6 @@ import java.util.Optional; import java.util.Set; import java.util.concurrent.CountDownLatch; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -38,7 +36,6 @@ import io.javaoperatorsdk.operator.api.config.InformerStoppedHandler; import io.javaoperatorsdk.operator.api.config.informer.InformerConfiguration; import io.javaoperatorsdk.operator.api.config.informer.InformerEventSourceConfiguration; -import io.javaoperatorsdk.operator.api.reconciler.Constants; import io.javaoperatorsdk.operator.processing.event.EventHandler; import io.javaoperatorsdk.operator.processing.event.ResourceID; import io.javaoperatorsdk.operator.processing.event.source.EventFilterTestUtils; @@ -89,8 +86,6 @@ void setup() { when(informerEventSourceConfiguration.getInformerConfig()).thenReturn(informerConfig); when(informerConfig.getEffectiveNamespaces(any())).thenReturn(DEFAULT_NAMESPACES_SET); when(informerEventSourceConfiguration.getResourceClass()).thenReturn(Deployment.class); - when(informerConfig.getGhostResourceCacheCheckInterval()) - .thenReturn(Constants.DEFAULT_GHOST_RESOURCE_CHECK_INTERVAL); informerEventSource = spy( new InformerEventSource<>(informerEventSourceConfiguration, clientMock) { @@ -349,8 +344,7 @@ void ghostCheckRemovesCachedResourceDuringFilteringUpdate() { when(mim.lastSyncResourceVersion(any())).thenReturn("1"); when(mim.get(any())).thenReturn(Optional.empty()); - var ghostCheckExecutor = Executors.newScheduledThreadPool(1); - temporaryResourceCache = spy(new TemporaryResourceCache<>(true, 50, ghostCheckExecutor, mes)); + temporaryResourceCache = spy(new TemporaryResourceCache<>(true, mes)); informerEventSource.setTemporalResourceCache(temporaryResourceCache); // put resource in cache and start a filtering update @@ -363,15 +357,12 @@ void ghostCheckRemovesCachedResourceDuringFilteringUpdate() { when(mim.lastSyncResourceVersion(any())).thenReturn("3"); // ghost check should remove the cached resource - await() - .untilAsserted( - () -> assertThat(temporaryResourceCache.getResourceFromCache(resourceId)).isEmpty()); + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(resourceId)).isEmpty(); // complete the filtering update - the resource should not reappear temporaryResourceCache.doneEventFilterModify(resourceId, "2"); assertThat(temporaryResourceCache.getResourceFromCache(resourceId)).isEmpty(); - - ghostCheckExecutor.shutdownNow(); } @Test @@ -383,8 +374,7 @@ void ghostCheckRunsConcurrentlyWithPutResource() { when(mim.lastSyncResourceVersion(any())).thenReturn("1"); when(mim.get(any())).thenReturn(Optional.empty()); - var ghostCheckExecutor = Executors.newScheduledThreadPool(1); - temporaryResourceCache = spy(new TemporaryResourceCache<>(true, 50, ghostCheckExecutor, mes)); + temporaryResourceCache = spy(new TemporaryResourceCache<>(true, mes)); informerEventSource.setTemporalResourceCache(temporaryResourceCache); // put a resource that will become a ghost @@ -394,13 +384,9 @@ void ghostCheckRunsConcurrentlyWithPutResource() { // advance sync version so ghost check removes it when(mim.lastSyncResourceVersion(any())).thenReturn("3"); - await() - .untilAsserted( - () -> - assertThat( - temporaryResourceCache.getResourceFromCache( - ResourceID.fromResource(deployment))) - .isEmpty()); + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(deployment))) + .isEmpty(); // now put a newer resource - should succeed even after ghost removal var newerDeployment = deploymentWithResourceVersion(4); @@ -408,8 +394,6 @@ void ghostCheckRunsConcurrentlyWithPutResource() { assertThat( temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(newerDeployment))) .isPresent(); - - ghostCheckExecutor.shutdownNow(); } @Test @@ -421,8 +405,7 @@ void filteringUpdateAndGhostCheckWithNamespaceChange() { when(mim.lastSyncResourceVersion(any())).thenReturn("1"); when(mim.get(any())).thenReturn(Optional.empty()); - var ghostCheckExecutor = Executors.newScheduledThreadPool(1); - temporaryResourceCache = spy(new TemporaryResourceCache<>(true, 50, ghostCheckExecutor, mes)); + temporaryResourceCache = spy(new TemporaryResourceCache<>(true, mes)); informerEventSource.setTemporalResourceCache(temporaryResourceCache); // start filtering update and put resource @@ -434,9 +417,8 @@ void filteringUpdateAndGhostCheckWithNamespaceChange() { // namespace becomes unwatched - ghost check should clean up when(mim.isWatchingNamespace(any())).thenReturn(false); - await() - .untilAsserted( - () -> assertThat(temporaryResourceCache.getResourceFromCache(resourceId)).isEmpty()); + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(resourceId)).isEmpty(); // complete the filtering update var doneResult = temporaryResourceCache.doneEventFilterModify(resourceId, "2"); @@ -446,8 +428,6 @@ void filteringUpdateAndGhostCheckWithNamespaceChange() { // put should be rejected since namespace is no longer watched temporaryResourceCache.putResource(deploymentWithResourceVersion(3)); assertThat(temporaryResourceCache.getResourceFromCache(resourceId)).isEmpty(); - - ghostCheckExecutor.shutdownNow(); } private void assertNoEventProduced() { @@ -496,8 +476,7 @@ private void withRealTemporaryResourceCache() { when(mes.manager()).thenReturn(mim); when(mim.lastSyncResourceVersion(any())).thenReturn("1"); - temporaryResourceCache = - spy(new TemporaryResourceCache<>(true, 100, mock(ScheduledExecutorService.class), mes)); + temporaryResourceCache = spy(new TemporaryResourceCache<>(true, mes)); informerEventSource.setTemporalResourceCache(temporaryResourceCache); } diff --git a/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCacheTest.java b/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCacheTest.java index f50063ccde..9a58b83f88 100644 --- a/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCacheTest.java +++ b/operator-framework-core/src/test/java/io/javaoperatorsdk/operator/processing/event/source/informer/TemporaryResourceCacheTest.java @@ -15,10 +15,7 @@ */ package io.javaoperatorsdk.operator.processing.event.source.informer; -import java.time.Duration; import java.util.Map; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -31,7 +28,6 @@ import io.javaoperatorsdk.operator.processing.event.source.informer.TemporaryResourceCache.EventHandling; import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; @@ -45,7 +41,6 @@ class TemporaryResourceCacheTest { public static final String RESOURCE_VERSION = "2"; - public static final int GHOST_RESOURCE_CHECK_INTERVAL = 100; private TemporaryResourceCache temporaryResourceCache; private volatile String latestSyncVersion; @@ -60,9 +55,7 @@ void setup() { when(managedInformerEventSource.manager()).thenReturn(mim); when(mim.isWatchingNamespace(any())).thenReturn(true); when(mim.lastSyncResourceVersion(any())).then(a -> latestSyncVersion); - temporaryResourceCache = - new TemporaryResourceCache<>( - true, 0, mock(ScheduledExecutorService.class), managedInformerEventSource); + temporaryResourceCache = new TemporaryResourceCache<>(true, managedInformerEventSource); } @Test @@ -139,8 +132,7 @@ void removesResourceFromCache() { @Test void nonComparableResourceVersionsDisables() { this.temporaryResourceCache = - new TemporaryResourceCache<>( - false, 0, mock(ScheduledExecutorService.class), mock(ManagedInformerEventSource.class)); + new TemporaryResourceCache<>(false, mock(ManagedInformerEventSource.class)); this.temporaryResourceCache.putResource(testResource()); @@ -323,72 +315,34 @@ void rapidDeletion() { @Test void removalOfGhostResources() { - withTemporaryResourceCacheForGhostHandling(); - var tr = testResource(); this.temporaryResourceCache.putResource(tr); - await() - .pollDelay(Duration.ofMillis(2 * GHOST_RESOURCE_CHECK_INTERVAL)) - .untilAsserted( - () -> - assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))) - .isPresent()); + // ghost check should not remove when latestSyncVersion is not ahead + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))) + .isPresent(); latestSyncVersion = "3"; - await() - .untilAsserted( - () -> - assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))) - .isEmpty()); + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))).isEmpty(); verify(managedInformerEventSource, times(1)) .handleEvent(eq(ResourceAction.DELETED), eq(tr), isNull(), eq(true)); } - @Test - void checksGhostOnlyWithCertainDelay() { - withTemporaryResourceCacheForGhostHandling(); - this.temporaryResourceCache.putResource(testResource()); - latestSyncVersion = "3"; - await() - .pollDelay(Duration.ofMillis(GHOST_RESOURCE_CHECK_INTERVAL / 5)) - .untilAsserted( - () -> - assertThat( - temporaryResourceCache.getResourceFromCache( - ResourceID.fromResource(testResource()))) - .isPresent()); - - await() - .untilAsserted( - () -> - assertThat( - temporaryResourceCache.getResourceFromCache( - ResourceID.fromResource(testResource()))) - .isEmpty()); - } - @Test void ghostResourceIsNotRemovedIfLatestSyncVersionIsOlder() { - withTemporaryResourceCacheForGhostHandling(); this.temporaryResourceCache.putResource(testResource()); latestSyncVersion = "1"; - await() - .pollDelay(Duration.ofMillis(GHOST_RESOURCE_CHECK_INTERVAL * 2)) - .untilAsserted( - () -> - assertThat( - temporaryResourceCache.getResourceFromCache( - ResourceID.fromResource(testResource()))) - .isPresent()); + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(testResource()))) + .isPresent(); } @Test void ghostRemovalRemovesResourcesOnNotFollowedNamespaces() { - withTemporaryResourceCacheForGhostHandling(); - var tr = testResource(); temporaryResourceCache.putResource(tr); @@ -399,11 +353,8 @@ void ghostRemovalRemovesResourcesOnNotFollowedNamespaces() { var mim = managedInformerEventSource.manager(); when(mim.isWatchingNamespace(tr.getMetadata().getNamespace())).thenReturn(false); - await() - .untilAsserted( - () -> - assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))) - .isEmpty()); + temporaryResourceCache.checkGhostResources(); + assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))).isEmpty(); // no delete event should be fired for resources removed due to namespace change verify(managedInformerEventSource, times(0)) @@ -421,15 +372,6 @@ void doNotCacheResourceOnPutIfNamespaceIsNotFollowedAnymore() { assertThat(temporaryResourceCache.getResourceFromCache(ResourceID.fromResource(tr))).isEmpty(); } - private void withTemporaryResourceCacheForGhostHandling() { - this.temporaryResourceCache = - new TemporaryResourceCache<>( - true, - GHOST_RESOURCE_CHECK_INTERVAL, - Executors.newScheduledThreadPool(1), - managedInformerEventSource); - } - private ConfigMap propagateTestResourceToCache() { var testResource = testResource(); temporaryResourceCache.putResource(testResource);