4.x: Global instance handling change (and relevant changes to testing)

all/pom.xml

@@ -443,6 +443,10 @@
             <groupId>io.helidon.common.processor</groupId>
             <artifactId>helidon-common-processor-class-model</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.testing</groupId>
+            <artifactId>helidon-testing</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.common.testing</groupId>
             <artifactId>helidon-common-testing-junit5</artifactId>
@@ -924,6 +928,10 @@
             <groupId>io.helidon.http.media</groupId>
             <artifactId>helidon-http-media-multipart</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.testing</groupId>
+            <artifactId>helidon-testing-junit5</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.helidon.webserver</groupId>
             <artifactId>helidon-webserver</artifactId>

bom/pom.xml

@@ -1213,6 +1213,16 @@
                 <artifactId>helidon-http-media-multipart</artifactId>
                 <version>${helidon.version}</version>
             </dependency>
+            <dependency>
+                <groupId>io.helidon.testing</groupId>
+                <artifactId>helidon-testing</artifactId>
+                <version>${helidon.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.helidon.testing</groupId>
+                <artifactId>helidon-testing-junit5</artifactId>
+                <version>${helidon.version}</version>
+            </dependency>
             <dependency>
                 <groupId>io.helidon.webserver</groupId>
                 <artifactId>helidon-webserver</artifactId>

common/config/pom.xml

@@ -37,6 +37,10 @@
             <groupId>io.helidon.common</groupId>
             <artifactId>helidon-common-mapper</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.helidon.common</groupId>
+            <artifactId>helidon-common-context</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>

common/config/src/main/java/io/helidon/common/config/Config.java

@@ -35,6 +35,17 @@ static Config empty() {
         return EmptyConfig.EMPTY;
     }
 
+    /**
+     * Create a new instance of configuration from the default configuration sources.
+     * In case there is no {@link io.helidon.common.config.spi.ConfigProvider} available, returns
+     * {@link #empty()}.
+     *
+     * @return a new configuration
+     */
+    static Config create() {
+        return GlobalConfig.create();
+    }
+
     /**
      * Returns the fully-qualified key of the {@code Config} node.
      * <p>

common/config/src/main/java/io/helidon/common/config/GlobalConfig.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 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.
@@ -19,12 +19,12 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.ServiceLoader;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 
 import io.helidon.common.HelidonServiceLoader;
 import io.helidon.common.LazyValue;
 import io.helidon.common.config.spi.ConfigProvider;
+import io.helidon.common.context.ContextSingleton;
 
 /**
  * Global configuration can be set by a user before any Helidon code is invoked, to override default discovery
@@ -37,18 +37,9 @@
  */
 public final class GlobalConfig {
     private static final Config EMPTY = Config.empty();
-    private static final LazyValue<Config> DEFAULT_CONFIG = LazyValue.create(() -> {
-        List<ConfigProvider> providers = HelidonServiceLoader.create(ServiceLoader.load(ConfigProvider.class))
-                .asList();
-        // no implementations available, use empty configuration
-        if (providers.isEmpty()) {
-            return EMPTY;
-        }
-        // there is a valid provider, let's use its default configuration
-        return providers.get(0)
-                .create();
-    });
-    private static final AtomicReference<Config> CONFIG = new AtomicReference<>();
+    private static final LazyValue<Config> DEFAULT_CONFIG = LazyValue.create(GlobalConfig::create);
+    private static final ContextSingleton<Config> CONTEXT_VALUE = ContextSingleton.create(GlobalConfig.class,
+                                                                                          Config.class);
 
     private GlobalConfig() {
     }
@@ -59,7 +50,7 @@ private GlobalConfig() {
      * @return {@code true} if there is a global configuration set already, {@code false} otherwise
      */
     public static boolean configured() {
-        return CONFIG.get() != null;
+        return CONTEXT_VALUE.isPresent();
     }
 
     /**
@@ -70,7 +61,7 @@ public static boolean configured() {
      * @see #config(java.util.function.Supplier, boolean)
      */
     public static Config config() {
-        return configured() ? CONFIG.get() : DEFAULT_CONFIG.get();
+        return CONTEXT_VALUE.value().orElseGet(DEFAULT_CONFIG);
     }
 
     /**
@@ -86,7 +77,7 @@ public static Config config(Supplier<Config> config) {
     /**
      * Set global configuration.
      *
-     * @param config configuration to use
+     * @param config    configuration to use
      * @param overwrite whether to overwrite an existing configured value
      * @return current global config
      */
@@ -96,8 +87,22 @@ public static Config config(Supplier<Config> config, boolean overwrite) {
         if (overwrite || !configured()) {
             // there is a certain risk we may do this twice, if two components try to set global config in parallel.
             // as the result was already unclear (as order matters), we do not need to be 100% thread safe here
-            CONFIG.set(config.get());
+            CONTEXT_VALUE.set(config.get());
+            return config();
+        } else {
+            return CONTEXT_VALUE.get(config);
         }
-        return CONFIG.get();
+    }
+
+    static Config create() {
+        List<ConfigProvider> providers = HelidonServiceLoader.create(ServiceLoader.load(ConfigProvider.class))
+                .asList();
+        // no implementations available, use empty configuration
+        if (providers.isEmpty()) {
+            return EMPTY;
+    }
+        // there is a valid provider, let's use its default configuration
+        return providers.getFirst()
+                .create();
     }
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023 Oracle and/or its affiliates.
+ * Copyright (c) 2022, 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.
@@ -19,6 +19,7 @@
  */
 module io.helidon.common.config {
 
+    requires io.helidon.common.context;
     requires transitive io.helidon.common;
     requires transitive io.helidon.common.mapper;
 

common/context/src/main/java/io/helidon/common/context/ContextSingleton.java

@@ -0,0 +1,189 @@
+/*
+ * 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.common.context;
+
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Supplier;
+
+/**
+ * This is similar to {@link java.lang.ThreadLocal}, except it uses {@code static} context to store a value.
+ * Static context is either a context available under special classifier {@value #STATIC_CONTEXT_CLASSIFIER}, or the
+ * {@link io.helidon.common.context.Contexts#globalContext()} (if the qualifier is not registered).
+ * <p>
+ * The intention of this type is to have singletons for production runtime, while maintaining a separation during
+ * testing, where Helidon test extensions run each part of the test class in a test context.
+ * <p>
+ * Note that the instance is not simply registered in the context, but it uses this class, and the "owner type" as a classifier
+ * to avoid conflicts.
+ *
+ * @param <T> type of the value stored in context
+ */
+public final class ContextSingleton<T> {
+    /**
+     * Classifier used to register a context that is to serve as the static context.
+     */
+    public static final String STATIC_CONTEXT_CLASSIFIER = "helidon-static-context";
+
+    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+    private final ContextSingletonClassifier<T> classifier;
+    private final Supplier<T> supplier;
+
+    private ContextSingleton(ContextSingletonClassifier<T> qualifier, Supplier<T> supplier) {
+        this.classifier = qualifier;
+        this.supplier = supplier;
+    }
+
+    /**
+     * Create a new context value.
+     *
+     * @param ownerClass type owning this context singleton
+     * @param clazz      type of the value
+     * @param <T>        type of the value
+     * @return a new context value with nothing set.
+     */
+    public static <T> ContextSingleton<T> create(Class<?> ownerClass, Class<T> clazz) {
+        Objects.requireNonNull(ownerClass);
+        Objects.requireNonNull(clazz);
+
+        return new ContextSingleton<>(new ContextSingletonClassifier<>(ownerClass, clazz), null);
+    }
+
+    /**
+     * Create a new context value with a supplier of instances for each context.
+     *
+     * @param ownerClass type owning this context singleton
+     * @param clazz type of the value
+     * @param value value supplier
+     * @param <T>   type of the value
+     * @return a new context value
+     */
+    public static <T> ContextSingleton<T> create(Class<?> ownerClass, Class<T> clazz, Supplier<T> value) {
+        Objects.requireNonNull(ownerClass);
+        Objects.requireNonNull(clazz);
+        Objects.requireNonNull(value);
+
+        return new ContextSingleton<>(new ContextSingletonClassifier<>(ownerClass, clazz), value);
+    }
+
+    /**
+     * Set the value in current context.
+     *
+     * @param value value to use
+     */
+    public void set(T value) {
+        lock.writeLock().lock();
+        try {
+            context().register(classifier, value);
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    /**
+     * Get the current value in this context, or call the provided supplier to get the value and register
+     * it, if not yet registered.
+     *
+     * @return current value (or the new one obtained from supplier)
+     * @throws NoSuchElementException in case there is no value, and no supplier
+     * @see #set(Object)
+     */
+    public T get() throws NoSuchElementException {
+        return get(this.supplier);
+    }
+
+    /**
+     * Get the current value in this context, or call the provided supplier to get the value and register
+     * it, if not yet registered.
+     *
+     * @param supplier supplier to call if the current value is not present
+     * @return current value (or the new one obtained from supplier)
+     * @throws NoSuchElementException in case there is no value, and the supplier returned {@code null}
+     * @see #set(Object)
+     */
+    public T get(Supplier<T> supplier) {
+        var current = current();
+        if (current.isPresent()) {
+            return current.get();
+        }
+        lock.writeLock().lock();
+        try {
+            current = current();
+            if (current.isPresent()) {
+                return current.get();
+            }
+            if (supplier != null) {
+                var value = supplier.get();
+                set(value);
+                return value;
+            }
+            throw new NoSuchElementException("There is no value available in the current context, "
+                                                     + "and supplier was not provided when creating this instance for: "
+                                                     + " " + classifier);
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    /**
+     * Current value as an {@link java.util.Optional}.
+     *
+     * @return current value, or empty if not configured
+     */
+    public Optional<T> value() {
+        return current();
+    }
+
+    /**
+     * Whether there is a value in current context.
+     *
+     * @return {@code true} if there is a value
+     */
+    public boolean isPresent() {
+        return current().isPresent();
+    }
+
+    private static Context context() {
+        Context globalContext = Contexts.globalContext();
+
+        // this is the context we expect to get (and set global instances)
+        return Contexts.context()
+                .orElse(globalContext)
+                .get(STATIC_CONTEXT_CLASSIFIER, Context.class)
+                .orElse(globalContext);
+    }
+
+    private Optional<T> current() {
+        lock.readLock().lock();
+        try {
+            return context().get(classifier, classifier.valueType());
+        } finally {
+            lock.readLock().unlock();
+        }
+    }
+
+    @SuppressWarnings("rawtypes")
+    private record ContextSingletonClassifier<T>(Class<ContextSingleton> contextSingleton,
+                                                 Class<?> ownerClass,
+                                                 Class<T> valueType) {
+        private ContextSingletonClassifier(Class<?> ownerClass, Class<T> valueType) {
+            this(ContextSingleton.class, ownerClass, valueType);
+        }
+    }
+}

common/context/src/main/java/io/helidon/common/context/Contexts.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 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.

common/context/src/main/java/io/helidon/common/context/ListContext.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2021 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 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.
@@ -108,6 +108,11 @@ public <T> Optional<T> get(Object classifier, Class<T> type) {
         }
     }
 
+    @Override
+    public String toString() {
+        return contextId;
+    }
+
     long nextChildId() {
         return contextCounter.getAndUpdate(operand -> (operand == Long.MAX_VALUE) ? 1 : (operand + 1));
     }