Meta config can now use config sources provided via service registry (#10842)

* Meta config can now use config sources provided via service registry (Helidon declarative).
* A workaround for test profile config source in testing extension.
* Docs update

Author: tomas-langer

config/config/src/main/java/io/helidon/config/ConfigProvider.java

@@ -53,37 +53,32 @@ class ConfigProvider implements Supplier<Config> {
                    Supplier<List<ConfigMapperProvider>> configMappers) {
         if (io.helidon.common.config.GlobalConfig.configured()) {
             config = wrapCommon(io.helidon.common.config.GlobalConfig.config());
-        } else {
-            Optional<MetaConfig> metaConfig = metaConfigSupplier.get();
-            config = Config.builder()
-                    .update(it -> metaConfig.ifPresent(metaConfigInstance ->
-                                                                     it.config(metaConfigInstance.metaConfiguration())))
-                    .update(it -> configSources.get()
-                            .forEach(it::addSource))
-                    .update(it -> {
-                        if (metaConfig.isEmpty()) {
-                            defaultConfigSources(it, configParsers);
-                        }
-                    })
-                    .disableParserServices()
-                    .update(it -> configParsers.get()
-                            .forEach(it::addParser))
-                    .disableFilterServices()
-                    .update(it -> configFilters.get()
-                            .forEach(it::addFilter))
-                    //.disableMapperServices()
-                    // cannot do this for now, removed ConfigMapperProvider from service loaded services, config does it on its
-                    // own
-                    // ObjectConfigMapper is before EnumMapper, and both are before essential and built-in
-                    .update(it -> configMappers.get()
-                            .forEach(it::addMapper))
-                    .build();
+            return;
         }
-    }
+        Optional<MetaConfig> metaConfig = metaConfigSupplier.get();
+        Config.Builder builder = Config.builder();
 
-    @Override
-    public Config get() {
-        return config;
+        if (metaConfig.isPresent()) {
+            builder.config(metaConfig.get().metaConfiguration());
+        } else {
+            builder.update(it -> configSources.get()
+                    .forEach(it::addSource))
+                    .update(it -> defaultConfigSources(it, configParsers));
+        }
+        builder.disableParserServices()
+                .update(it -> configParsers.get()
+                        .forEach(it::addParser))
+                .disableFilterServices()
+                .update(it -> configFilters.get()
+                        .forEach(it::addFilter))
+                //.disableMapperServices()
+                // cannot do this for now, removed ConfigMapperProvider from service loaded services, config does it on its
+                // own
+                // ObjectConfigMapper is before EnumMapper, and both are before essential and built-in
+                .update(it -> configMappers.get()
+                        .forEach(it::addMapper));
+
+        this.config = builder.build();
     }
 
     static Config wrapCommon(io.helidon.common.config.Config config) {
@@ -93,6 +88,11 @@ static Config wrapCommon(io.helidon.common.config.Config config) {
         return new CommonConfigWrapper(Config.empty(), config);
     }
 
+    @Override
+    public Config get() {
+        return config;
+    }
+
     private void defaultConfigSources(io.helidon.config.Config.Builder configBuilder,
                                       Supplier<List<ConfigParser>> configParsers) {
 

config/config/src/main/java/io/helidon/config/MetaConfig.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2025 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.
@@ -89,8 +89,8 @@ public final class MetaConfig {
 
     private final Config metaConfig;
 
-    MetaConfig() {
-        this.metaConfig = metaConfig().orElseGet(Config::empty);
+    MetaConfig(Config metaConfig) {
+        this.metaConfig = metaConfig;
     }
 
     /**

config/config/src/main/java/io/helidon/config/MetaConfigFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2024, 2025 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.
@@ -16,19 +16,73 @@
 
 package io.helidon.config;
 
-import java.util.Optional;
-import java.util.function.Supplier;
+import java.lang.System.Logger.Level;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+import io.helidon.service.registry.Qualifier;
 import io.helidon.service.registry.Service;
 
 /**
  * A ServiceRegistry factory that creates the meta config only if it is defined.
  */
 @Service.Singleton
-class MetaConfigFactory implements Supplier<Optional<MetaConfig>> {
+class MetaConfigFactory implements Service.ServicesFactory<MetaConfig> {
+    private static final System.Logger LOGGER = System.getLogger(MetaConfigFactory.class.getName());
+
     @Override
-    public Optional<MetaConfig> get() {
-        return MetaConfig.metaConfig()
-                .map(it -> new MetaConfig());
+    public List<Service.QualifiedInstance<MetaConfig>> services() {
+        var foundMetaConfig = MetaConfig.metaConfig();
+        if (foundMetaConfig.isEmpty()) {
+            return List.of();
+        }
+
+        var metaConfig = foundMetaConfig.get();
+
+        List<Service.QualifiedInstance<MetaConfig>> instances = new ArrayList<>();
+
+        // add the main meta config
+        instances.add(Service.QualifiedInstance.create(new MetaConfig(metaConfig)));
+
+        // now for each config source type defined add a named instance
+        var sources = metaConfig.get("sources")
+                .asNodeList()
+                .orElse(List.of());
+
+        Map<String, List<NameAndConfig>> byType = new HashMap<>();
+        for (Config source : sources) {
+            String type = source.get("type").asString()
+                    .orElseThrow(() -> new ConfigException("Missing type of a config source in config-profile sources."));
+            String name = source.get("name").asString().orElse(type);
+            byType.computeIfAbsent(type, k -> new ArrayList<>()).add(new NameAndConfig(name, source.get("properties")));
+        }
+
+        byType.forEach((type, configs) -> {
+            if (configs.size() == 1) {
+                // only add if exactly one for this type, otherwise we cannot create an instance from registry
+                instances.add(Service.QualifiedInstance.create(new MetaConfig(configs.getFirst().config()),
+                                                               Qualifier.createNamed(type)));
+                if (LOGGER.isLoggable(Level.DEBUG)) {
+                    LOGGER.log(Level.DEBUG,
+                               "Adding config source meta-configuration for type {0} to service registry.",
+                               type);
+                }
+            } else {
+                if (LOGGER.isLoggable(Level.DEBUG)) {
+                    LOGGER.log(Level.DEBUG,
+                               "There are {0} sources of type {1} defined in config-profile sources, "
+                                       + "but only one is allowed for service registry. Ignoring this type",
+                               configs.size(), type);
+                }
+            }
+        });
+
+        return instances;
+    }
+
+    private record NameAndConfig(String name, Config config) {
+
     }
 }

config/config/src/main/java/io/helidon/config/MetaConfigFinder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2025 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.
@@ -34,6 +34,9 @@
 import io.helidon.config.spi.ConfigNode.ListNode;
 import io.helidon.config.spi.ConfigNode.ObjectNode;
 import io.helidon.config.spi.ConfigSource;
+import io.helidon.service.registry.GlobalServiceRegistry;
+import io.helidon.service.registry.Service;
+import io.helidon.service.registry.ServiceInfo;
 
 /**
  * Utility class that locates the meta configuration source.
@@ -220,6 +223,25 @@ private static ConfigSource profileSource(Function<MediaType, Boolean> supported
         sourceListBuilder.addObject(ObjectNode.builder().addValue("type", "environment-variables").build())
                 .addObject(ObjectNode.builder().addValue("type", "system-properties").build());
 
+        // all types from service registry
+        Set<String> namedSources = GlobalServiceRegistry.registry()
+                .allServices(ConfigSource.class)
+                .stream()
+                .map(ServiceInfo::qualifiers)
+                .flatMap(Set::stream)
+                .filter(it -> it.typeName().equals(Service.Named.TYPE))
+                .flatMap(it -> it.value().stream())
+                .collect(Collectors.toSet());
+
+        for (String namedSource : namedSources) {
+            sourceListBuilder.addObject(ObjectNode.builder()
+                                                .addValue("type", namedSource)
+                                                .addObject("properties", ObjectNode.builder()
+                                                        .addValue("enabled", "false") // this is a default, use an explicit one
+                                                        .build())
+                                                .build());
+        }
+
         // all profile files
         for (String supportedSuffix : supportedSuffixes) {
             addFile(sourceListBuilder, "application-" + profileName, supportedSuffix);

config/config/src/main/java/io/helidon/config/MetaProviders.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2024 Oracle and/or its affiliates.
+ * Copyright (c) 2019, 2025 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.
@@ -15,13 +15,16 @@
  */
 package io.helidon.config;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import io.helidon.common.HelidonServiceLoader;
 import io.helidon.common.Weight;
@@ -35,34 +38,23 @@
 import io.helidon.config.spi.PollingStrategyProvider;
 import io.helidon.config.spi.RetryPolicy;
 import io.helidon.config.spi.RetryPolicyProvider;
+import io.helidon.service.registry.Services;
 
 /**
  * Access to Java service loaders for config sources, retry policies and polling strategies.
  */
 final class MetaProviders {
-    private static final List<ConfigSourceProvider> CONFIG_SOURCE_PROVIDERS;
     private static final List<RetryPolicyProvider> RETRY_POLICY_PROVIDERS;
     private static final List<PollingStrategyProvider> POLLING_STRATEGY_PROVIDERS;
     private static final List<ChangeWatcherProvider> CHANGE_WATCHER_PROVIDERS;
     private static final List<OverrideSourceProvider> OVERRIDE_SOURCE_PROVIDERS;
 
-    private static final Set<String> SUPPORTED_CONFIG_SOURCES = new HashSet<>();
     private static final Set<String> SUPPORTED_RETRY_POLICIES = new HashSet<>();
     private static final Set<String> SUPPORTED_POLLING_STRATEGIES = new HashSet<>();
     private static final Set<String> SUPPORTED_CHANGE_WATCHERS = new HashSet<>();
     private static final Set<String> SUPPORTED_OVERRIDE_SOURCES = new HashSet<>();
 
     static {
-        CONFIG_SOURCE_PROVIDERS = HelidonServiceLoader
-                .builder(ServiceLoader.load(ConfigSourceProvider.class))
-                .addService(new BuiltInConfigSourcesProvider())
-                .build()
-                .asList();
-
-        CONFIG_SOURCE_PROVIDERS.stream()
-                .map(ConfigSourceProvider::supported)
-                .forEach(SUPPORTED_CONFIG_SOURCES::addAll);
-
         RETRY_POLICY_PROVIDERS = HelidonServiceLoader
                 .builder(ServiceLoader.load(RetryPolicyProvider.class))
                 .addService(new BuiltInRetryPolicyProvider())
@@ -93,7 +85,6 @@ final class MetaProviders {
                 .map(ChangeWatcherProvider::supported)
                 .forEach(SUPPORTED_CHANGE_WATCHERS::addAll);
 
-
         OVERRIDE_SOURCE_PROVIDERS = HelidonServiceLoader
                 .builder(ServiceLoader.load(OverrideSourceProvider.class))
                 .addService(new BuiltinOverrideSourceProvider())
@@ -108,22 +99,43 @@ final class MetaProviders {
     private MetaProviders() {
     }
 
+    public static ChangeWatcher<?> changeWatcher(String type, Config config) {
+        return CHANGE_WATCHER_PROVIDERS.stream()
+                .filter(provider -> provider.supports(type))
+                .findFirst()
+                .map(provider -> provider.create(type, config))
+                .orElseThrow(() -> new MetaConfigException("Change watcher of type " + type + " is not supported."
+                                                                   + " Supported types: " + SUPPORTED_CHANGE_WATCHERS));
+    }
+
     static ConfigSource configSource(String type, Config config) {
-        return CONFIG_SOURCE_PROVIDERS.stream()
+        var all = allProviders();
+        var supported = all.stream()
+                .map(ConfigSourceProvider::supported)
+                .flatMap(Set::stream)
+                .collect(Collectors.toUnmodifiableSet());
+
+        return all.stream()
                 .filter(provider -> provider.supports(type))
                 .findFirst()
                 .map(provider -> provider.create(type, config))
+                .or(() -> findSourceFromRegistry(type))
                 .orElseThrow(() -> new MetaConfigException("Config source of type " + type + " is not supported."
-                                                                        + " Supported types: " + SUPPORTED_CONFIG_SOURCES));
+                                                                   + " Supported types: " + supported));
     }
 
     static List<ConfigSource> configSources(String type, Config sourceProperties) {
-        return CONFIG_SOURCE_PROVIDERS.stream()
+        var all = allProviders();
+        var supported = all.stream()
+                .map(ConfigSourceProvider::supported)
+                .flatMap(Set::stream)
+                .collect(Collectors.toUnmodifiableSet());
+        return all.stream()
                 .filter(provider -> provider.supports(type))
                 .findFirst()
                 .map(provider -> provider.createMulti(type, sourceProperties))
                 .orElseThrow(() -> new MetaConfigException("Config source of type " + type + " is not supported."
-                                                                        + " Supported types: " + SUPPORTED_CONFIG_SOURCES));
+                                                                   + " Supported types: " + supported));
     }
 
     static OverrideSource overrideSource(String type, Config config) {
@@ -132,7 +144,7 @@ static OverrideSource overrideSource(String type, Config config) {
                 .findFirst()
                 .map(provider -> provider.create(type, config))
                 .orElseThrow(() -> new MetaConfigException("Config source of type " + type + " is not supported."
-                                                                        + " Supported types: " + SUPPORTED_OVERRIDE_SOURCES));
+                                                                   + " Supported types: " + SUPPORTED_OVERRIDE_SOURCES));
     }
 
     static PollingStrategy pollingStrategy(String type, Config config) {
@@ -141,7 +153,7 @@ static PollingStrategy pollingStrategy(String type, Config config) {
                 .findFirst()
                 .map(provider -> provider.create(type, config))
                 .orElseThrow(() -> new MetaConfigException("Polling strategy of type " + type + " is not supported."
-                                                                        + " Supported types: " + SUPPORTED_POLLING_STRATEGIES));
+                                                                   + " Supported types: " + SUPPORTED_POLLING_STRATEGIES));
     }
 
     static RetryPolicy retryPolicy(String type, Config config) {
@@ -150,16 +162,17 @@ static RetryPolicy retryPolicy(String type, Config config) {
                 .findFirst()
                 .map(provider -> provider.create(type, config))
                 .orElseThrow(() -> new MetaConfigException("Retry policy of type " + type + " is not supported."
-                                                                        + " Supported types: " + SUPPORTED_RETRY_POLICIES));
+                                                                   + " Supported types: " + SUPPORTED_RETRY_POLICIES));
     }
 
-    public static ChangeWatcher<?> changeWatcher(String type, Config config) {
-        return CHANGE_WATCHER_PROVIDERS.stream()
-                .filter(provider -> provider.supports(type))
-                .findFirst()
-                .map(provider -> provider.create(type, config))
-                .orElseThrow(() -> new MetaConfigException("Change watcher of type " + type + " is not supported."
-                                                                + " Supported types: " + SUPPORTED_CHANGE_WATCHERS));
+    private static Optional<ConfigSource> findSourceFromRegistry(String type) {
+        return Services.firstNamed(ConfigSource.class, type);
+    }
+
+    private static List<ConfigSourceProvider> allProviders() {
+        var result = new ArrayList<>(Services.all(ConfigSourceProvider.class));
+        result.add(new BuiltInConfigSourcesProvider());
+        return result;
     }
 
     @Weight(0)

config/config/src/main/resources/META-INF/helidon/io.helidon.config/service.loader

@@ -4,3 +4,4 @@ io.helidon.config.spi.ConfigFilter
 # This cannot be done for now, as ObjectConfigMapper ends up before built-ins when
 # we disable mapper services
 # io.helidon.config.spi.ConfigMapperProvider
+io.helidon.config.spi.ConfigSourceProvider

config/tests/pom.xml

@@ -62,6 +62,7 @@
         <module>test-meta-source-fail</module>
         <module>test-parsers-1-complex</module>
         <module>service-registry</module>
+        <module>service-registry-metaconfig</module>
         <module>config-metadata-meta-api</module>
         <module>config-metadata-builder-api</module>
         <module>test-lazy-source</module>