Switched implementation of MpEnvironmentVariablesSource to use an LRU cache

config/config-mp/pom.xml

@@ -50,6 +50,10 @@
             <groupId>org.eclipse.microprofile.config</groupId>
             <artifactId>microprofile-config-api</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.common</groupId>
+            <artifactId>helidon-common-configurable</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.config</groupId>
             <artifactId>helidon-config-metadata</artifactId>

config/config-mp/src/main/java/io/helidon/config/mp/MpEnvironmentVariablesSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2021 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,23 +17,40 @@
 package io.helidon.config.mp;
 
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.regex.Pattern;
 
+import io.helidon.common.configurable.LruCache;
+
 import jakarta.annotation.Priority;
 import org.eclipse.microprofile.config.spi.ConfigSource;
 
 @Priority(300)
 class MpEnvironmentVariablesSource implements ConfigSource {
     private static final Pattern DISALLOWED_CHARS = Pattern.compile("[^a-zA-Z0-9_]");
     private static final String UNDERSCORE = "_";
+    private static final int MAX_CACHE_SIZE = 10000;
 
     private final Map<String, String> env;
-    private final Map<String, Cached> cache = new ConcurrentHashMap<>();
+    private final LruCache<String, Cached> cache;
 
     MpEnvironmentVariablesSource() {
+        this(MAX_CACHE_SIZE);
+    }
+
+    MpEnvironmentVariablesSource(int cacheSize) {
         this.env = Map.copyOf(System.getenv());
+        this.cache = LruCache.<String, Cached>builder().capacity(cacheSize).build();
+    }
+
+    /**
+     * Access internal cache, used for testing.
+     *
+     * @return internal cache
+     */
+    LruCache<String, Cached> cache() {
+        return cache;
     }
 
     @Override
@@ -50,24 +67,24 @@ public Map<String, String> getProperties() {
     public String getValue(String propertyName) {
         // environment variable config source is immutable - we can safely cache all requested keys, so we
         // do not execute the regular expression on every get
-        return cache.computeIfAbsent(propertyName, theKey -> {
+        return cache.computeValue(propertyName, () -> {
             // According to the spec, we have three ways of looking for a property
             // 1. Exact match
             String result = env.get(propertyName);
             if (null != result) {
-                return new Cached(result);
+                return Optional.of(new Cached(result));
             }
             // 2. replace non alphanumeric characters with _
             String rule2 = rule2(propertyName);
             result = env.get(rule2);
             if (null != result) {
-                return new Cached(result);
+                return Optional.of(new Cached(result));
             }
             // 3. replace same as above, but uppercase
             String rule3 = rule2.toUpperCase();
             result = env.get(rule3);
-            return new Cached(result);
-        }).value;
+            return Optional.of(new Cached(result));
+        }).map(cached -> cached.value).orElse(null);
     }
 
     @Override

config/config-mp/src/main/java/module-info.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2020, 2024 Oracle and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@
     requires io.helidon.common;
     requires io.helidon.config;
     requires jakarta.annotation;
+    requires io.helidon.common.configurable;
 
     requires static io.helidon.config.metadata;
 

config/config-mp/src/test/java/io/helidon/config/mp/MpEnvironmentVariablesSourceTest.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.helidon.config.mp;
+
+import java.util.UUID;
+import java.util.stream.IntStream;
+
+import org.junit.jupiter.api.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+class MpEnvironmentVariablesSourceTest {
+
+    private static final int MAX_GROWTH = 10;
+
+    @Test
+    void testCacheMaxGrowth() {
+        MpEnvironmentVariablesSource source = new MpEnvironmentVariablesSource(MAX_GROWTH);
+        assertThat(source.cache().size(), is(0));
+        IntStream.range(0, 5 * MAX_GROWTH).forEach(i -> {
+            String random = UUID.randomUUID().toString().toLowerCase();
+            source.getValue(random);        // should cache and discard oldest after MAX_GROWTH
+        });
+        assertThat(source.cache().size(), is(MAX_GROWTH));
+    }
+}