Intermediate commit #4159

- introduced pre-cache
- refactored self cleaning cache
- added new fields

Author: de-jcup

sechub-commons-core/src/main/java/com/mercedesbenz/sechub/commons/core/cache/CacheData.java

@@ -0,0 +1,47 @@
+package com.mercedesbenz.sechub.commons.core.cache;
+
+import static java.util.Objects.*;
+
+import java.io.Serializable;
+import java.time.Duration;
+import java.time.Instant;
+
+import javax.crypto.SealedObject;
+
+import com.mercedesbenz.sechub.commons.core.security.CryptoAccess;
+import com.mercedesbenz.sechub.commons.core.security.CryptoAccessProvider;
+
+/**
+ * Represents the data stored in the cache under a specific key.
+ *
+ * <p>
+ * The cached data can be any serializable object. It is securely sealed using a
+ * {@link CryptoAccess} instance of type <code>T</code>.
+ * </p>
+ */
+class CacheData<T extends Serializable> {
+
+    private final CryptoAccessProvider<T> cryptoAccessProvider;
+    private final SealedObject sealedValue;
+    private final Duration duration;
+    private final Instant createdAt = Instant.now();
+
+    public CacheData(CryptoAccessProvider<T> cryptoAccessProvider, T value, Duration duration) {
+        this.cryptoAccessProvider = requireNonNull(cryptoAccessProvider);
+        requireNonNull(value, "Property 'value' must not be null");
+        this.sealedValue = cryptoAccessProvider.getCryptoAccess().seal(value);
+        this.duration = requireNonNull(duration, "Property 'duration' must not be null");
+    }
+
+    public T getValue() {
+        return cryptoAccessProvider.getCryptoAccess().unseal(sealedValue);
+    }
+
+    public Duration getDuration() {
+        return duration;
+    }
+
+    public Instant getCreatedAt() {
+        return createdAt;
+    }
+}

sechub-commons-core/src/main/java/com/mercedesbenz/sechub/commons/core/cache/CachePersistence.java

@@ -0,0 +1,16 @@
+package com.mercedesbenz.sechub.commons.core.cache;
+
+import java.io.Serializable;
+import java.util.function.BiConsumer;
+
+public interface CachePersistence<T extends Serializable> {
+
+    void forEach(BiConsumer<String, CacheData<T>> action);
+
+    void remove(String key);
+
+    void put(String key, CacheData<T> cacheData);
+
+    CacheData<T> get(String key);
+
+}

sechub-commons-core/src/main/java/com/mercedesbenz/sechub/commons/core/cache/InMemoryCachePersistence.java

@@ -0,0 +1,40 @@
+package com.mercedesbenz.sechub.commons.core.cache;
+
+import java.io.Serializable;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
+
+/**
+ * <b>Note:</b> This cache persistence is local to a single application instance
+ * and is not shared across multiple instances. Avoid using it in scenarios
+ * where a distributed caching mechanism is required.
+ * 
+ * @param <T>
+ */
+public class InMemoryCachePersistence<T extends Serializable> implements CachePersistence<T> {
+
+    private final Map<String, CacheData<T>> cacheMap = new ConcurrentHashMap<>();
+
+    @Override
+    public void remove(String key) {
+        cacheMap.remove(key);
+    }
+
+    @Override
+    public void put(String key, CacheData<T> cacheData) {
+        cacheMap.put(key, cacheData);
+    }
+
+    @Override
+    public void forEach(BiConsumer<String, CacheData<T>> action) {
+        cacheMap.forEach(action);
+
+    }
+
+    @Override
+    public CacheData<T> get(String key) {
+        return cacheMap.get(key);
+    }
+
+}

sechub-commons-core/src/main/java/com/mercedesbenz/sechub/commons/core/cache/SelfCleaningCache.java

@@ -1,20 +1,18 @@
 // SPDX-License-Identifier: MIT
 package com.mercedesbenz.sechub.commons.core.cache;
 
-import static java.util.Objects.requireNonNull;
+import static java.util.Objects.*;
 
 import java.io.Serializable;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
-import javax.crypto.SealedObject;
-
 import com.mercedesbenz.sechub.commons.core.security.CryptoAccess;
+import com.mercedesbenz.sechub.commons.core.security.CryptoAccessProvider;
 import com.mercedesbenz.sechub.commons.core.shutdown.ApplicationShutdownHandler;
 import com.mercedesbenz.sechub.commons.core.shutdown.ShutdownListener;
 
@@ -23,47 +21,45 @@
  * caching mechanism for generic data.
  *
  * <p>
- * It uses a {@link ConcurrentHashMap} to store data and a scheduled task to
+ * It uses a {@link CachePersistence} to store data and a scheduled task to
  * clear expired entries periodically. By default, the cache cleanup runs every
  * minute with an initial delay of 1 minute. These values can be customized via
  * the constructor.
  * </p>
  *
- * <p>
- * <b>Note:</b> This cache is local to a single application instance and is not
- * shared across multiple instances. Avoid using it in scenarios where a
- * distributed caching mechanism is required.
- * </p>
- *
  * @param <T> the type of data stored in the cache (must be of type
  *            {@link Serializable})
  *
- * @author hamidonos
+ * @author hamidonos, de-jcup
  */
-public class InMemoryCache<T extends Serializable> implements ShutdownListener {
+public class SelfCleaningCache<T extends Serializable> implements ShutdownListener, CryptoAccessProvider<T> {
 
     private static final Duration DEFAULT_CACHE_CLEAR_JOB_PERIOD = Duration.ofMinutes(1);
 
-    private final ConcurrentHashMap<String, CacheData> cacheMap = new ConcurrentHashMap<>();
     private final ScheduledExecutorService scheduledExecutorService;
     private final CryptoAccess<T> cryptoAccess = new CryptoAccess<>();
     private final ScheduledFuture<?> cacheClearJob;
     private final Duration cacheClearJobPeriod;
+    private final CachePersistence<T> cachePersistence;
 
-    public InMemoryCache(ScheduledExecutorService scheduledExecutorService, ApplicationShutdownHandler applicationShutdownHandler) {
-        this(DEFAULT_CACHE_CLEAR_JOB_PERIOD, scheduledExecutorService, applicationShutdownHandler);
+    public SelfCleaningCache(CachePersistence<T> cachePersistence, ScheduledExecutorService scheduledExecutorService, ApplicationShutdownHandler applicationShutdownHandler) {
+        this(cachePersistence, DEFAULT_CACHE_CLEAR_JOB_PERIOD, scheduledExecutorService, applicationShutdownHandler);
     }
 
     /* @formatter:off */
-    public InMemoryCache(Duration cacheClearJobPeriod,
+    public SelfCleaningCache(CachePersistence<T> cachePersistence, Duration cacheClearJobPeriod,
                          ScheduledExecutorService scheduledExecutorService,
                          ApplicationShutdownHandler applicationShutdownHandler) {
         /* @formatter:on */
+        this.cachePersistence= requireNonNull(cachePersistence, "Parameter 'cachePersistence' must not be null");
         this.scheduledExecutorService = requireNonNull(scheduledExecutorService, "Property 'scheduledExecutorService' must not be null");
         this.cacheClearJobPeriod = requireNonNull(cacheClearJobPeriod, "Property 'cacheClearJobPeriod' must not be null");
+        
         cacheClearJob = scheduleClearCacheJob();
+        
         requireNonNull(applicationShutdownHandler, "Property 'applicationShutdownHandler' must not be null");
         applicationShutdownHandler.register(this);
+        
     }
 
     /**
@@ -81,7 +77,7 @@ public InMemoryCache(Duration cacheClearJobPeriod,
      */
     public void put(String key, T value, Duration duration) {
         requireNonNull(key, "Argument 'key' must not be null");
-        cacheMap.put(key, new CacheData(value, duration));
+        cachePersistence.put(key, new CacheData<T>(this, value, duration));
     }
 
     /**
@@ -98,7 +94,7 @@ public void put(String key, T value, Duration duration) {
     public Optional<T> get(String key) {
         requireNonNull(key, "Argument 'key' must not be null");
 
-        CacheData cacheData = cacheMap.get(key);
+        CacheData<T> cacheData = cachePersistence.get(key);
 
         if (cacheData == null) {
             return Optional.empty();
@@ -115,7 +111,8 @@ public Optional<T> get(String key) {
      * @throws NullPointerException if the specified key is null
      */
     public void remove(String key) {
-        cacheMap.remove(key);
+        requireNonNull(key, "key must not be null!");
+        cachePersistence.remove(key);
     }
 
     public Duration getCacheClearJobPeriod() {
@@ -141,47 +138,19 @@ private ScheduledFuture<?> scheduleClearCacheJob() {
     private void clearCache() {
         Instant now = Instant.now();
 
-        cacheMap.forEach((key, value) -> {
+        cachePersistence.forEach((key, value) -> {
             Instant cacheDataCreatedAt = value.getCreatedAt();
             Duration cacheDataDuration = value.getDuration();
 
             if (cacheDataCreatedAt.plus(cacheDataDuration).isBefore(now)) {
-                cacheMap.remove(key);
+                cachePersistence.remove(key);
             }
         });
     }
 
-    /**
-     * Represents the data stored in the cache under a specific key.
-     *
-     * <p>
-     * The cached data can be any serializable object. It is securely sealed using a
-     * {@link CryptoAccess} instance of type <code>T</code>.
-     * </p>
-     */
-    private class CacheData {
-
-        private final SealedObject sealedValue;
-        private final Duration duration;
-        private final Instant createdAt = Instant.now();
-
-        public CacheData(T value, Duration duration) {
-            requireNonNull(value, "Property 'value' must not be null");
-            this.sealedValue = InMemoryCache.this.cryptoAccess.seal(value);
-            this.duration = requireNonNull(duration, "Property 'duration' must not be null");
-        }
-
-        public T getValue() {
-            return cryptoAccess.unseal(sealedValue);
-        }
-
-        public Duration getDuration() {
-            return duration;
-        }
-
-        public Instant getCreatedAt() {
-            return createdAt;
-        }
+    @Override
+    public CryptoAccess<T> getCryptoAccess() {
+        return cryptoAccess;
     }
 
 }

sechub-commons-core/src/main/java/com/mercedesbenz/sechub/commons/core/security/CryptoAccessProvider.java

@@ -0,0 +1,8 @@
+package com.mercedesbenz.sechub.commons.core.security;
+
+import java.io.Serializable;
+
+public interface CryptoAccessProvider<T extends Serializable> {
+
+    public CryptoAccess<T> getCryptoAccess();
+}