Merge pull request #1361 from amvanbaren/caffeine-cache-fallback

Caffeine cache fallback

Author: amvanbaren

server/build.gradle

@@ -42,7 +42,7 @@ def versions = [
     jaxb_impl: '2.3.8',
     gatling: '3.9.5',
     loki4j: '1.4.2',
-    embedded_redis: '1.4.3'
+    jedis: '6.2.0'
 ]
 ext['junit-jupiter.version'] = versions.junit
 sourceCompatibility = versions.java
@@ -92,6 +92,8 @@ dependencies {
     implementation "org.springframework.retry:spring-retry"
     implementation "org.bouncycastle:bcpkix-jdk18on:${versions.bouncycastle}"
     implementation "com.github.ben-manes.caffeine:caffeine"
+    implementation 'com.github.ben-manes.caffeine:jcache'
+    implementation "redis.clients:jedis:${versions.jedis}"
     implementation "com.giffing.bucket4j.spring.boot.starter:bucket4j-spring-boot-starter:${versions.bucket4j}"
     implementation "com.bucket4j:bucket4j-redis:${versions.bucket4j_redis}"
     implementation "org.jobrunr:jobrunr-spring-boot-3-starter:${versions.jobrunr}"
@@ -115,7 +117,6 @@ dependencies {
     implementation "io.micrometer:micrometer-tracing"
     implementation "io.micrometer:micrometer-tracing-bridge-otel"
     implementation "io.opentelemetry:opentelemetry-exporter-zipkin"
-    implementation "com.github.codemonstur:embedded-redis:${versions.embedded_redis}"
     runtimeOnly "io.micrometer:micrometer-registry-prometheus"
     runtimeOnly "org.postgresql:postgresql"
     jooqGenerator "org.postgresql:postgresql"

server/src/dev/resources/application.yml

@@ -16,20 +16,17 @@ spring:
     exclude: org.springframework.boot.actuate.autoconfigure.tracing.zipkin.ZipkinAutoConfiguration
   profiles:
     include: ovsx
-  data:
-    redis:
-      # redis standalone configuration
-      host: localhost
-      port: 6379
-      # connect to redis cluster configured in docker-compose.yml
+# connect to redis cluster configured in docker-compose.yml
+#  data:
+#    redis:
 #      cluster:
 #        nodes: '127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005,127.0.0.1:7006'
 #      username: openvsx
 #      password: openvsx
   datasource:
     url: jdbc:postgresql://localhost:5432/postgres
-    username: gitpod
-    password: gitpod
+    username: openvsx
+    password: openvsx
   flyway:
     baseline-on-migrate: true
     baseline-version: 0.1.0
@@ -108,7 +105,7 @@ org:
 
 bucket4j:
   enabled: true
-  cache-to-use: redis-jedis # use redis-cluster-jedis when running redis cluster
+  cache-to-use: jcache # use redis-jedis for redis standalone or redis-cluster-jedis for redis cluster
   filters:
     - cache-name: buckets
       url: '/api/-/(namespace/create|publish)'
@@ -151,7 +148,7 @@ ovsx:
     enabled: true
     clear-on-start: true
   redis:
-    embedded: true
+    enabled: false
   eclipse:
     base-url: https://api.eclipse.org
     publisher-agreement:

server/src/main/java/org/eclipse/openvsx/cache/CacheConfig.java

@@ -12,21 +12,25 @@
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.json.JsonMapper;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.giffing.bucket4j.spring.boot.starter.context.properties.Bucket4JBootProperties;
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.Scheduler;
+import com.github.benmanes.caffeine.jcache.CacheManagerImpl;
+import com.github.benmanes.caffeine.jcache.configuration.CaffeineConfiguration;
+import com.github.benmanes.caffeine.jcache.spi.CaffeineCachingProvider;
 import io.micrometer.common.util.StringUtils;
 import org.eclipse.openvsx.entities.ExtensionVersion;
 import org.eclipse.openvsx.json.ExtensionJson;
 import org.eclipse.openvsx.json.NamespaceDetailsJson;
 import org.eclipse.openvsx.search.SearchResult;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.cache.jcache.JCacheCacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
@@ -39,7 +43,10 @@
 import redis.clients.jedis.JedisCluster;
 import redis.clients.jedis.JedisPool;
 
+import java.net.URI;
 import java.time.Duration;
+import java.util.OptionalLong;
+import java.util.Properties;
 import java.util.stream.Collectors;
 
 import static org.eclipse.openvsx.cache.CacheService.*;
@@ -103,13 +110,13 @@ public CacheManager fileCacheManager(
     }
 
     @Bean
-    @ConditionalOnProperty(prefix = Bucket4JBootProperties.PROPERTY_PREFIX, name = "cache-to-use", havingValue = "redis-jedis")
+    @ConditionalOnExpression("${bucket4j.enabled:false} && '${bucket4j.cache-to-use:}' == 'redis-jedis'")
     public JedisPool jedisPool(RedisProperties properties) {
         return new JedisPool(properties.getHost(), properties.getPort(), properties.getUsername(), properties.getPassword());
     }
 
     @Bean
-    @ConditionalOnProperty(prefix = Bucket4JBootProperties.PROPERTY_PREFIX, name = "cache-to-use", havingValue = "redis-cluster-jedis")
+    @ConditionalOnExpression("${bucket4j.enabled:false} && '${bucket4j.cache-to-use:}' == 'redis-cluster-jedis'")
     public JedisCluster jedisCluster(RedisProperties properties) {
         var configBuilder = DefaultJedisClientConfig.builder();
         var username = properties.getUsername();
@@ -130,6 +137,69 @@ public JedisCluster jedisCluster(RedisProperties properties) {
 
     @Bean
     @Primary
+    @ConditionalOnProperty(value = "ovsx.redis.enabled", havingValue = "false", matchIfMissing = true)
+    public JCacheCacheManager caffeineCacheManager(
+            @Value("${ovsx.caching.average-review-rating.ttl:P3D}") Duration averageReviewRatingTtl,
+            @Value("${ovsx.caching.average-review-rating.max-size:1}") long averageReviewRatingMaxSize,
+            @Value("${ovsx.caching.namespace-details-json.ttl:PT1H}") Duration namespaceDetailsJsonTtl,
+            @Value("${ovsx.caching.namespace-details-json.max-size:1024}") long namespaceDetailsJsonMaxSize,
+            @Value("${ovsx.caching.database-search.ttl:PT1H}") Duration databaseSearchTtl,
+            @Value("${ovsx.caching.database-search.max-size:1024}") long databaseSearchMaxSize,
+            @Value("${ovsx.caching.extension-json.ttl:PT1H}") Duration extensionJsonTtl,
+            @Value("${ovsx.caching.extension-json.max-size:1024}") long extensionJsonMaxSize,
+            @Value("${ovsx.caching.latest-extension-version.ttl:PT1H}") Duration latestExtensionVersionTtl,
+            @Value("${ovsx.caching.latest-extension-version.max-size:1024}") long latestExtensionVersionMaxSize,
+            @Value("${ovsx.caching.sitemap.ttl:PT1H}") Duration sitemapTtl,
+            @Value("${ovsx.caching.sitemap.max-size:1}") long sitemapMaxSize,
+            @Value("${ovsx.caching.malicious-extensions.ttl:P3D}") Duration maliciousExtensionsTtl,
+            @Value("${ovsx.caching.malicious-extensions.max-size:1}") long maliciousExtensionsMaxSize,
+            @Value("${ovsx.caching.rate-limiting.name:buckets}") String rateLimitingCacheName,
+            @Value("${ovsx.caching.rate-limiting.tti:PT1H}") Duration rateLimitingTti,
+            @Value("${ovsx.caching.rate-limiting.max-size:1024}") long rateLimitingMaxSize
+    ) {
+        var averageReviewRatingCache = createCaffeineConfiguration(averageReviewRatingTtl, averageReviewRatingMaxSize, false);
+        var namespaceDetailsJsonCache = createCaffeineConfiguration(namespaceDetailsJsonTtl, namespaceDetailsJsonMaxSize, false);
+        var databaseSearchCache = createCaffeineConfiguration(databaseSearchTtl, databaseSearchMaxSize, false);
+        var extensionJsonCache = createCaffeineConfiguration(extensionJsonTtl, extensionJsonMaxSize, false);
+        var latestExtensionVersionCache = createCaffeineConfiguration(latestExtensionVersionTtl, latestExtensionVersionMaxSize, false);
+        var sitemapCache = createCaffeineConfiguration(sitemapTtl, sitemapMaxSize, false);
+        var maliciousExtensionsCache = createCaffeineConfiguration(maliciousExtensionsTtl, maliciousExtensionsMaxSize, false);
+        var rateLimitingCache = createCaffeineConfiguration(rateLimitingTti, rateLimitingMaxSize, true);
+
+        var cacheManager = new CacheManagerImpl(
+                new CaffeineCachingProvider(),
+                false,
+                URI.create("com.github.benmanes.caffeine.jcache.spi.CaffeineCachingProvider"),
+                Thread.currentThread().getContextClassLoader(),
+                new Properties()
+        );
+
+        cacheManager.createCache(CACHE_AVERAGE_REVIEW_RATING, averageReviewRatingCache);
+        cacheManager.createCache(CACHE_NAMESPACE_DETAILS_JSON, namespaceDetailsJsonCache);
+        cacheManager.createCache(CACHE_DATABASE_SEARCH, databaseSearchCache);
+        cacheManager.createCache(CACHE_EXTENSION_JSON, extensionJsonCache);
+        cacheManager.createCache(CACHE_LATEST_EXTENSION_VERSION, latestExtensionVersionCache);
+        cacheManager.createCache(CACHE_SITEMAP, sitemapCache);
+        cacheManager.createCache(CACHE_MALICIOUS_EXTENSIONS, maliciousExtensionsCache);
+        cacheManager.createCache(rateLimitingCacheName, rateLimitingCache);
+        return new JCacheCacheManager(cacheManager);
+    }
+
+    private CaffeineConfiguration<Object, Object> createCaffeineConfiguration(Duration duration, long maxSize, boolean tti) {
+        var configuration = new CaffeineConfiguration<>();
+        configuration.setMaximumSize(OptionalLong.of(maxSize));
+        if(tti) {
+            configuration.setExpireAfterAccess(OptionalLong.of(duration.toNanos()));
+        } else {
+            configuration.setExpireAfterWrite(OptionalLong.of(duration.toNanos()));
+        }
+
+        return configuration;
+    }
+
+    @Bean
+    @Primary
+    @ConditionalOnProperty(value = "ovsx.redis.enabled", havingValue = "true")
     public CacheManager redisCacheManager(
             RedisConnectionFactory redisConnectionFactory,
             @Value("${ovsx.caching.average-review-rating.ttl:P3D}") Duration averageReviewRatingTtl,

server/src/main/java/org/eclipse/openvsx/cache/EmbeddedRedisServer.java

@@ -0,0 +1,31 @@
+/** ******************************************************************************
+ * Copyright (c) 2025 Precies. Software OU and others
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ * ****************************************************************************** */
+package org.eclipse.openvsx.cache;
+
+import com.giffing.bucket4j.spring.boot.starter.config.cache.SyncCacheResolver;
+import com.giffing.bucket4j.spring.boot.starter.config.cache.jcache.JCacheCacheResolver;
+import com.giffing.bucket4j.spring.boot.starter.config.condition.ConditionalOnCache;
+import com.giffing.bucket4j.spring.boot.starter.config.condition.ConditionalOnSynchronousPropertyCondition;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.cache.jcache.JCacheCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConditionalOnSynchronousPropertyCondition
+@ConditionalOnCache("jcache")
+public class JCacheBucket4jConfiguration {
+
+    @Bean
+    @ConditionalOnMissingBean(SyncCacheResolver.class)
+    public SyncCacheResolver bucket4JCacheResolver(JCacheCacheManager cacheManager) {
+        return new JCacheCacheResolver(cacheManager.getCacheManager());
+    }
+}