From 88c46b4ad60ad6330d35477c706c9ea6bff83d39 Mon Sep 17 00:00:00 2001 From: Roberto Cortez Date: Thu, 13 Feb 2025 12:42:19 +0000 Subject: [PATCH] Update SmallRye Config to 3.12.0 --- bom/application/pom.xml | 2 +- .../builditem/ConfigMappingBuildItem.java | 2 +- .../configuration/ConfigMappingUtils.java | 3 +- .../RunTimeConfigurationGenerator.java | 4 +- .../steps/ConfigGenerationBuildStep.java | 131 ++++++++++++++++-- .../configuration/AbstractConfigBuilder.java | 38 ++++- .../QuarkusConfigBuilderCustomizer.java | 67 ++++++--- .../runtime/init/InitRuntimeConfig.java | 24 +--- devtools/gradle/gradle/libs.versions.toml | 2 +- .../arc/deployment/ConfigBuildStep.java | 2 +- 10 files changed, 211 insertions(+), 64 deletions(-) diff --git a/bom/application/pom.xml b/bom/application/pom.xml index e30f2746e0056..652afc6fd8ccc 100644 --- a/bom/application/pom.xml +++ b/bom/application/pom.xml @@ -47,7 +47,7 @@ 2.0 4.0.2 2.10.0 - 3.11.2 + 3.12.0 4.2.0 4.0.0 4.0.8 diff --git a/core/deployment/src/main/java/io/quarkus/deployment/builditem/ConfigMappingBuildItem.java b/core/deployment/src/main/java/io/quarkus/deployment/builditem/ConfigMappingBuildItem.java index 23ff2f5074385..cc5174baa1c60 100644 --- a/core/deployment/src/main/java/io/quarkus/deployment/builditem/ConfigMappingBuildItem.java +++ b/core/deployment/src/main/java/io/quarkus/deployment/builditem/ConfigMappingBuildItem.java @@ -28,7 +28,7 @@ public boolean isStaticInitSafe() { } public ConfigClass toConfigClass() { - return new ConfigClass(configClass, prefix); + return ConfigClass.configClass(configClass, prefix); } @Override diff --git a/core/deployment/src/main/java/io/quarkus/deployment/configuration/ConfigMappingUtils.java b/core/deployment/src/main/java/io/quarkus/deployment/configuration/ConfigMappingUtils.java index cc32fafb9e737..ee3ccb315d586 100644 --- a/core/deployment/src/main/java/io/quarkus/deployment/configuration/ConfigMappingUtils.java +++ b/core/deployment/src/main/java/io/quarkus/deployment/configuration/ConfigMappingUtils.java @@ -193,7 +193,8 @@ private static void registerImplicitConverter( public static Object newInstance(Class configClass) { if (configClass.isAnnotationPresent(ConfigMapping.class)) { - return ReflectUtil.newInstance(ConfigMappingLoader.getImplementationClass(configClass)); + // TODO - radcortez - mapping classes cannot be initialized like this. + return ReflectUtil.newInstance(ConfigMappingLoader.ensureLoaded(configClass).implementation()); } else { return ReflectUtil.newInstance(configClass); } diff --git a/core/deployment/src/main/java/io/quarkus/deployment/configuration/RunTimeConfigurationGenerator.java b/core/deployment/src/main/java/io/quarkus/deployment/configuration/RunTimeConfigurationGenerator.java index 9288e8f7127f0..627d2682e1311 100644 --- a/core/deployment/src/main/java/io/quarkus/deployment/configuration/RunTimeConfigurationGenerator.java +++ b/core/deployment/src/main/java/io/quarkus/deployment/configuration/RunTimeConfigurationGenerator.java @@ -3,6 +3,7 @@ import static io.quarkus.deployment.util.ReflectUtil.reportError; import static io.quarkus.runtime.annotations.ConfigPhase.BUILD_AND_RUN_TIME_FIXED; import static io.quarkus.runtime.annotations.ConfigPhase.RUN_TIME; +import static io.smallrye.config.common.utils.StringUtil.skewer; import java.lang.reflect.Field; import java.lang.reflect.Modifier; @@ -1231,7 +1232,8 @@ private void generateIsMapped(final String methodName, final ConfigPatternMap secretKeyHandlerFactories = discoverService(SecretKeysHandlerFactory.class, reflectiveClass); Set configCustomizers = discoverService(SmallRyeConfigBuilderCustomizer.class, reflectiveClass); + // TODO - introduce a way to ignore mappings that are only used for documentation or to prevent warnings + Set ignoreMappings = new HashSet<>(); + ignoreMappings.add(ConfigClass.configClass(BuildAnalyticsConfig.class, "quarkus.analytics")); + ignoreMappings.add(ConfigClass.configClass(BuilderConfig.class, "quarkus.builder")); + ignoreMappings.add(ConfigClass.configClass(CommandLineRuntimeConfig.class, "quarkus")); + ignoreMappings.add(ConfigClass.configClass(DebugRuntimeConfig.class, "quarkus.debug")); + + Set allMappings = new HashSet<>(); + allMappings.addAll(staticSafeConfigMappings(configMappings)); + allMappings.addAll(runtimeConfigMappings(configMappings)); + allMappings.addAll(configItem.getReadResult().getBuildTimeRunTimeMappings()); + allMappings.addAll(configItem.getReadResult().getRunTimeMappings()); + allMappings.removeAll(ignoreMappings); + + // Shared components + Map sharedFields = generateSharedConfig(generatedClass, converters, allMappings); + // For Static Init Config Set staticMappings = new HashSet<>(); staticMappings.addAll(staticSafeConfigMappings(configMappings)); staticMappings.addAll(configItem.getReadResult().getBuildTimeRunTimeMappings()); + staticMappings.removeAll(ignoreMappings); Set staticCustomizers = new HashSet<>(staticSafeServices(configCustomizers)); staticCustomizers.add(StaticInitConfigBuilder.class.getName()); generateConfigBuilder(generatedClass, reflectiveClass, CONFIG_STATIC_NAME, combinedIndex, + sharedFields, defaultValues, converters, interceptors, @@ -275,6 +300,7 @@ void generateBuilders( staticSafeServices(configSourceFactories), secretKeyHandlers, staticSafeServices(secretKeyHandlerFactories), + Set.of(), staticMappings, staticCustomizers, staticInitConfigBuilders.stream().map(StaticInitConfigBuilderBuildItem::getBuilderClassName).collect(toSet())); @@ -285,11 +311,13 @@ void generateBuilders( runTimeMappings.addAll(runtimeConfigMappings(configMappings)); runTimeMappings.addAll(configItem.getReadResult().getBuildTimeRunTimeMappings()); runTimeMappings.addAll(configItem.getReadResult().getRunTimeMappings()); + runTimeMappings.removeAll(ignoreMappings); Set runtimeCustomizers = new HashSet<>(configCustomizers); runtimeCustomizers.add(RuntimeConfigBuilder.class.getName()); generateConfigBuilder(generatedClass, reflectiveClass, CONFIG_RUNTIME_NAME, combinedIndex, + sharedFields, defaultValues, converters, interceptors, @@ -299,6 +327,7 @@ void generateBuilders( configSourceFactories, secretKeyHandlers, secretKeyHandlerFactories, + staticMappings, runTimeMappings, runtimeCustomizers, runTimeConfigBuilders.stream().map(RunTimeConfigBuilderBuildItem::getBuilderClassName).collect(toSet())); @@ -532,12 +561,12 @@ private static String getPathWithoutExtension(Path path) { private static final MethodDescriptor BUILDER_CUSTOMIZER = MethodDescriptor.ofMethod(SmallRyeConfigBuilderCustomizer.class, "configBuilder", void.class, SmallRyeConfigBuilder.class); - - private static final MethodDescriptor WITH_DEFAULT = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, - "withDefaultValue", - void.class, SmallRyeConfigBuilder.class, String.class, String.class); + private static final MethodDescriptor WITH_DEFAULTS = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, + "withDefaultValues", + void.class, SmallRyeConfigBuilder.class, Map.class); private static final MethodDescriptor WITH_CONVERTER = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, - "withConverter", void.class, SmallRyeConfigBuilder.class, String.class, int.class, Converter.class); + "withConverter", + void.class, SmallRyeConfigBuilder.class, String.class, int.class, Converter.class); private static final MethodDescriptor WITH_INTERCEPTOR = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, "withInterceptor", void.class, SmallRyeConfigBuilder.class, ConfigSourceInterceptor.class); @@ -554,27 +583,86 @@ private static String getPathWithoutExtension(Path path) { "withSource", void.class, SmallRyeConfigBuilder.class, ConfigSourceFactory.class); private static final MethodDescriptor WITH_SECRET_HANDLER = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, - "withSecretKeyHandler", void.class, SmallRyeConfigBuilder.class, SecretKeysHandler.class); + "withSecretKeyHandler", + void.class, SmallRyeConfigBuilder.class, SecretKeysHandler.class); private static final MethodDescriptor WITH_SECRET_HANDLER_FACTORY = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, - "withSecretKeyHandler", void.class, SmallRyeConfigBuilder.class, SecretKeysHandlerFactory.class); + "withSecretKeyHandler", + void.class, SmallRyeConfigBuilder.class, SecretKeysHandlerFactory.class); private static final MethodDescriptor WITH_MAPPING = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, "withMapping", - void.class, SmallRyeConfigBuilder.class, String.class, String.class); + void.class, SmallRyeConfigBuilder.class, ConfigClass.class); + private static final MethodDescriptor WITH_MAPPING_INSTANCE = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, + "withMappingInstance", + void.class, SmallRyeConfigBuilder.class, ConfigClass.class); private static final MethodDescriptor WITH_CUSTOMIZER = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, "withCustomizer", void.class, SmallRyeConfigBuilder.class, SmallRyeConfigBuilderCustomizer.class); private static final MethodDescriptor WITH_BUILDER = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, "withBuilder", void.class, SmallRyeConfigBuilder.class, ConfigBuilder.class); + private static final MethodDescriptor CONFIG_CLASS = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, + "configClass", + ConfigClass.class, String.class, String.class); + private static final MethodDescriptor ENSURE_LOADED = MethodDescriptor.ofMethod(AbstractConfigBuilder.class, + "ensureLoaded", + void.class, String.class); private static final DotName CONVERTER_NAME = DotName.createSimple(Converter.class.getName()); private static final DotName PRIORITY_NAME = DotName.createSimple(Priority.class.getName()); + private static Map generateSharedConfig( + BuildProducer generatedClass, + Set converters, + Set mappings) { + + Map fields = new HashMap<>(); + try (ClassCreator classCreator = ClassCreator.builder() + .classOutput(new GeneratedClassGizmoAdaptor(generatedClass, true)) + .className("io.quarkus.runtime.generated.SharedConfig") + .superClass(AbstractConfigBuilder.class) + .setFinal(true) + .build()) { + + MethodCreator clinit = classCreator.getMethodCreator("", void.class); + clinit.setModifiers(Opcodes.ACC_STATIC); + + int converterIndex = 0; + for (String converter : converters) { + String fieldName = "conv$" + converterIndex++; + FieldDescriptor converterField = classCreator.getFieldCreator(fieldName, Converter.class) + .setModifiers(Opcodes.ACC_STATIC).getFieldDescriptor(); + clinit.writeStaticField(converterField, clinit.newInstance(MethodDescriptor.ofConstructor(converter))); + fields.put(converter, converterField); + } + + int mappingIndex = 0; + for (ConfigClass mapping : mappings) { + FieldDescriptor mappingField = classCreator.getFieldCreator("mapping$" + mappingIndex++, ConfigClass.class) + .setModifiers(Opcodes.ACC_STATIC).getFieldDescriptor(); + clinit.writeStaticField(mappingField, clinit.invokeStaticMethod(CONFIG_CLASS, + clinit.load(mapping.getType().getName()), clinit.load(mapping.getPrefix()))); + + List configMappingsMetadata = ConfigMappingLoader + .getConfigMappingsMetadata(mapping.getType()); + for (ConfigMappingMetadata configMappingMetadata : configMappingsMetadata) { + clinit.invokeStaticMethod(ENSURE_LOADED, clinit.load(configMappingMetadata.getInterfaceType().getName())); + } + + fields.put(mapping, mappingField); + } + + clinit.returnVoid(); + } + + return fields; + } + private static void generateConfigBuilder( BuildProducer generatedClass, BuildProducer reflectiveClass, String className, CombinedIndexBuildItem combinedIndex, + Map sharedFields, Map defaultValues, Set converters, Set interceptors, @@ -584,6 +672,7 @@ private static void generateConfigBuilder( Set configSourceFactories, Set secretKeyHandlers, Set secretKeyHandlerFactories, + Set mappingsInstances, Set mappings, Set configCustomizers, Set configBuilders) { @@ -597,23 +686,33 @@ private static void generateConfigBuilder( .setFinal(true) .build()) { + MethodCreator clinit = classCreator.getMethodCreator("", void.class); + clinit.setModifiers(Opcodes.ACC_STATIC); + MethodCreator method = classCreator.getMethodCreator(BUILDER_CUSTOMIZER); ResultHandle configBuilder = method.getMethodParam(0); + FieldDescriptor defaultsField = classCreator.getFieldCreator("defaults", Map.class).setModifiers(Opcodes.ACC_STATIC) + .getFieldDescriptor(); + clinit.writeStaticField(defaultsField, clinit.newInstance(MethodDescriptor.ofConstructor(HashMap.class, int.class), + clinit.load((int) ((float) defaultValues.size() / 0.75f + 1.0f)))); + MethodDescriptor put = MethodDescriptor.ofMethod(HashMap.class, "put", Object.class, Object.class, Object.class); for (Map.Entry entry : defaultValues.entrySet()) { - method.invokeStaticMethod(WITH_DEFAULT, configBuilder, method.load(entry.getKey()), - method.load(entry.getValue())); + clinit.invokeVirtualMethod(put, clinit.readStaticField(defaultsField), clinit.load(entry.getKey()), + clinit.load(entry.getValue())); } + method.invokeStaticMethod(WITH_DEFAULTS, configBuilder, method.readStaticField(defaultsField)); for (String converter : converters) { ClassInfo converterClass = combinedIndex.getComputingIndex().getClassByName(converter); Type type = getConverterType(converterClass, combinedIndex); AnnotationInstance priorityAnnotation = converterClass.annotation(PRIORITY_NAME); int priority = priorityAnnotation != null ? priorityAnnotation.value().asInt() : 100; + method.invokeStaticMethod(WITH_CONVERTER, configBuilder, method.load(type.name().toString()), method.load(priority), - method.newInstance(MethodDescriptor.ofConstructor(converter))); + method.readStaticField(sharedFields.get(converter))); } for (String interceptor : interceptors) { @@ -651,11 +750,17 @@ private static void generateConfigBuilder( method.newInstance(MethodDescriptor.ofConstructor(secretKeyHandlerFactory))); } + for (ConfigClass mappingInstance : mappingsInstances) { + method.invokeStaticMethod(WITH_MAPPING_INSTANCE, configBuilder, + method.readStaticField(sharedFields.get(mappingInstance))); + } + + mappings.removeAll(mappingsInstances); for (ConfigClass mapping : mappings) { - method.invokeStaticMethod(WITH_MAPPING, configBuilder, method.load(mapping.getKlass().getName()), - method.load(mapping.getPrefix())); + method.invokeStaticMethod(WITH_MAPPING, configBuilder, method.readStaticField(sharedFields.get(mapping))); } + clinit.returnVoid(); method.returnVoid(); } diff --git a/core/runtime/src/main/java/io/quarkus/runtime/configuration/AbstractConfigBuilder.java b/core/runtime/src/main/java/io/quarkus/runtime/configuration/AbstractConfigBuilder.java index f63a755649386..96d85aab27f3d 100644 --- a/core/runtime/src/main/java/io/quarkus/runtime/configuration/AbstractConfigBuilder.java +++ b/core/runtime/src/main/java/io/quarkus/runtime/configuration/AbstractConfigBuilder.java @@ -1,14 +1,20 @@ package io.quarkus.runtime.configuration; +import java.util.Map; + +import org.eclipse.microprofile.config.ConfigProvider; import org.eclipse.microprofile.config.spi.ConfigSource; import org.eclipse.microprofile.config.spi.ConfigSourceProvider; import org.eclipse.microprofile.config.spi.Converter; +import io.smallrye.config.ConfigMappingLoader; +import io.smallrye.config.ConfigMappings.ConfigClass; import io.smallrye.config.ConfigSourceFactory; import io.smallrye.config.ConfigSourceInterceptor; import io.smallrye.config.ConfigSourceInterceptorFactory; import io.smallrye.config.SecretKeysHandler; import io.smallrye.config.SecretKeysHandlerFactory; +import io.smallrye.config.SmallRyeConfig; import io.smallrye.config.SmallRyeConfigBuilder; import io.smallrye.config.SmallRyeConfigBuilderCustomizer; @@ -17,8 +23,9 @@ * require varargs or collections as parameters. */ public abstract class AbstractConfigBuilder implements SmallRyeConfigBuilderCustomizer { - protected static void withDefaultValue(SmallRyeConfigBuilder builder, String name, String value) { - builder.withDefaultValue(name, value); + + protected static void withDefaultValues(SmallRyeConfigBuilder builder, Map values) { + builder.withDefaultValues(values); } @SuppressWarnings("unchecked") @@ -62,6 +69,10 @@ protected static void withSecretKeyHandler(SmallRyeConfigBuilder builder, builder.withSecretKeyHandlerFactories(secretKeysHandlerFactory); } + protected static void withMapping(SmallRyeConfigBuilder builder, ConfigClass mapping) { + builder.withMapping(mapping); + } + protected static void withMapping(SmallRyeConfigBuilder builder, String mappingClass, String prefix) { try { // To support mappings that are not public @@ -71,6 +82,11 @@ protected static void withMapping(SmallRyeConfigBuilder builder, String mappingC } } + protected static void withMappingInstance(SmallRyeConfigBuilder builder, ConfigClass mapping) { + SmallRyeConfig config = ConfigProvider.getConfig().unwrap(SmallRyeConfig.class); + builder.getMappingsBuilder().mappingInstance(mapping, config.getConfigMapping(mapping.getType())); + } + protected static void withBuilder(SmallRyeConfigBuilder builder, ConfigBuilder configBuilder) { builder.withCustomizers(new SmallRyeConfigBuilderCustomizer() { @Override @@ -99,4 +115,22 @@ public static void withCustomizer(SmallRyeConfigBuilder builder, String customiz throw new RuntimeException(e); } } + + public static ConfigClass configClass(final String mappingClass, final String prefix) { + try { + // To support mappings that are not public + return ConfigClass.configClass(Thread.currentThread().getContextClassLoader().loadClass(mappingClass), prefix); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + } + + public static void ensureLoaded(final String mappingClass) { + try { + // To support mappings that are not public + ConfigMappingLoader.ensureLoaded(Thread.currentThread().getContextClassLoader().loadClass(mappingClass)); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + } } diff --git a/core/runtime/src/main/java/io/quarkus/runtime/configuration/QuarkusConfigBuilderCustomizer.java b/core/runtime/src/main/java/io/quarkus/runtime/configuration/QuarkusConfigBuilderCustomizer.java index 34e982e1035f4..e901328e4fa8b 100644 --- a/core/runtime/src/main/java/io/quarkus/runtime/configuration/QuarkusConfigBuilderCustomizer.java +++ b/core/runtime/src/main/java/io/quarkus/runtime/configuration/QuarkusConfigBuilderCustomizer.java @@ -6,9 +6,7 @@ import static io.smallrye.config.SmallRyeConfig.SMALLRYE_CONFIG_PROFILE; import static io.smallrye.config.SmallRyeConfig.SMALLRYE_CONFIG_PROFILE_PARENT; -import java.util.HashMap; import java.util.Iterator; -import java.util.Map; import java.util.OptionalInt; import java.util.function.Function; @@ -24,6 +22,12 @@ import io.smallrye.config.SmallRyeConfigBuilderCustomizer; public class QuarkusConfigBuilderCustomizer implements SmallRyeConfigBuilderCustomizer { + public static final String QUARKUS_PROFILE = "quarkus.profile"; + public static final String QUARKUS_CONFIG_LOCATIONS = "quarkus.config.locations"; + public static final String QUARKUS_CONFIG_PROFILE_PARENT = "quarkus.config.profile.parent"; + public static final String QUARKUS_CONFIG_MAPPING_VALIDATE_UNKNOWN = "quarkus.config.mapping.validate-unknown"; + public static final String QUARKUS_CONFIG_LOG_VALUES = "quarkus.config.log.values"; + @Override public void configBuilder(final SmallRyeConfigBuilder builder) { LaunchMode launchMode = LaunchMode.current(); @@ -32,7 +36,12 @@ public void configBuilder(final SmallRyeConfigBuilder builder) { builder.withInterceptorFactories(new ConfigSourceInterceptorFactory() { @Override public ConfigSourceInterceptor getInterceptor(final ConfigSourceInterceptorContext context) { - return new RelocateConfigSourceInterceptor(Map.of(SMALLRYE_CONFIG_PROFILE, launchMode.getProfileKey())); + return new RelocateConfigSourceInterceptor(new Function() { + @Override + public String apply(final String name) { + return SMALLRYE_CONFIG_PROFILE.equals(name) ? launchMode.getProfileKey() : name; + }; + }); } @Override @@ -44,29 +53,31 @@ public OptionalInt getPriority() { builder.withInterceptorFactories(new ConfigSourceInterceptorFactory() { @Override public ConfigSourceInterceptor getInterceptor(final ConfigSourceInterceptorContext context) { - Map relocations = new HashMap<>(); - relocations.put(SMALLRYE_CONFIG_LOCATIONS, "quarkus.config.locations"); - relocations.put(SMALLRYE_CONFIG_PROFILE_PARENT, "quarkus.config.profile.parent"); - relocations.put(SMALLRYE_CONFIG_MAPPING_VALIDATE_UNKNOWN, "quarkus.config.mapping.validate-unknown"); - relocations.put(SMALLRYE_CONFIG_LOG_VALUES, "quarkus.config.log.values"); - // Also adds relocations to all profiles return new RelocateConfigSourceInterceptor(new Function() { @Override public String apply(final String name) { - String relocate = relocations.get(name); - if (relocate != null) { - return relocate; + if (SMALLRYE_CONFIG_LOCATIONS.equals(name)) { + return QUARKUS_CONFIG_LOCATIONS; + } + if (SMALLRYE_CONFIG_PROFILE_PARENT.equals(name)) { + return QUARKUS_CONFIG_PROFILE_PARENT; + } + if (SMALLRYE_CONFIG_MAPPING_VALIDATE_UNKNOWN.equals(name)) { + return QUARKUS_CONFIG_MAPPING_VALIDATE_UNKNOWN; + } + if (SMALLRYE_CONFIG_LOG_VALUES.equals(name)) { + return QUARKUS_CONFIG_LOG_VALUES; } if (name.startsWith("%") && name.endsWith(SMALLRYE_CONFIG_LOCATIONS)) { io.smallrye.config.NameIterator ni = new io.smallrye.config.NameIterator(name); - return ni.getNextSegment() + "." + "quarkus.config.locations"; + return ni.getNextSegment() + "." + QUARKUS_CONFIG_LOCATIONS; } if (name.startsWith("%") && name.endsWith(SMALLRYE_CONFIG_PROFILE_PARENT)) { io.smallrye.config.NameIterator ni = new NameIterator(name); - return ni.getNextSegment() + "." + "quarkus.config.profile.parent"; + return ni.getNextSegment() + "." + QUARKUS_CONFIG_PROFILE_PARENT; } return name; @@ -89,13 +100,27 @@ public OptionalInt getPriority() { builder.withInterceptorFactories(new ConfigSourceInterceptorFactory() { @Override public ConfigSourceInterceptor getInterceptor(final ConfigSourceInterceptorContext context) { - Map fallbacks = new HashMap<>(); - fallbacks.put("quarkus.profile", SMALLRYE_CONFIG_PROFILE); - fallbacks.put("quarkus.config.locations", SMALLRYE_CONFIG_LOCATIONS); - fallbacks.put("quarkus.config.profile.parent", SMALLRYE_CONFIG_PROFILE_PARENT); - fallbacks.put("quarkus.config.mapping.validate-unknown", SMALLRYE_CONFIG_MAPPING_VALIDATE_UNKNOWN); - fallbacks.put("quarkus.config.log.values", SMALLRYE_CONFIG_LOG_VALUES); - return new FallbackConfigSourceInterceptor(fallbacks) { + return new FallbackConfigSourceInterceptor(new Function() { + @Override + public String apply(final String name) { + if (QUARKUS_PROFILE.equals(name)) { + return SMALLRYE_CONFIG_PROFILE; + } + if (QUARKUS_CONFIG_LOCATIONS.equals(name)) { + return SMALLRYE_CONFIG_LOCATIONS; + } + if (QUARKUS_CONFIG_PROFILE_PARENT.equals(name)) { + return SMALLRYE_CONFIG_PROFILE_PARENT; + } + if (QUARKUS_CONFIG_MAPPING_VALIDATE_UNKNOWN.equals(name)) { + return SMALLRYE_CONFIG_MAPPING_VALIDATE_UNKNOWN; + } + if (QUARKUS_CONFIG_LOG_VALUES.equals(name)) { + return SMALLRYE_CONFIG_LOG_VALUES; + } + return name; + } + }) { @Override public Iterator iterateNames(final ConfigSourceInterceptorContext context) { return context.iterateNames(); diff --git a/core/runtime/src/main/java/io/quarkus/runtime/init/InitRuntimeConfig.java b/core/runtime/src/main/java/io/quarkus/runtime/init/InitRuntimeConfig.java index d4476355d108f..96eaf0a451855 100644 --- a/core/runtime/src/main/java/io/quarkus/runtime/init/InitRuntimeConfig.java +++ b/core/runtime/src/main/java/io/quarkus/runtime/init/InitRuntimeConfig.java @@ -1,7 +1,5 @@ package io.quarkus.runtime.init; -import static io.smallrye.config.Converters.newEmptyValueConverter; - import org.eclipse.microprofile.config.spi.Converter; import io.quarkus.runtime.annotations.ConfigDocPrefix; @@ -19,7 +17,6 @@ @ConfigRoot(phase = ConfigPhase.RUN_TIME) @ConfigDocPrefix("quarkus.init") public interface InitRuntimeConfig { - /** * true to quit exit right after the initialization. * The option is not meant be used directly by users. @@ -30,26 +27,9 @@ public interface InitRuntimeConfig { boolean initAndExit(); // Because of https://github.com/eclipse/microprofile-config/issues/708 - // TODO - radcortez - Make SR Config built-in converters public to be used directly - class BooleanConverter implements Converter { - static final Converter BOOLEAN_CONVERTER = Converters - .newTrimmingConverter(newEmptyValueConverter(new Converter() { - @Override - public Boolean convert(final String value) throws IllegalArgumentException, NullPointerException { - return Boolean.valueOf( - "TRUE".equalsIgnoreCase(value) - || "1".equalsIgnoreCase(value) - || "YES".equalsIgnoreCase(value) - || "Y".equalsIgnoreCase(value) - || "ON".equalsIgnoreCase(value) - || "JA".equalsIgnoreCase(value) - || "J".equalsIgnoreCase(value) - || "SI".equalsIgnoreCase(value) - || "SIM".equalsIgnoreCase(value) - || "OUI".equalsIgnoreCase(value)); - } - })); + Converter BOOLEAN_CONVERTER = Converters.getImplicitConverter(Boolean.class); + class BooleanConverter implements Converter { @Override public Boolean convert(final String value) throws IllegalArgumentException, NullPointerException { return BOOLEAN_CONVERTER.convert(value); diff --git a/devtools/gradle/gradle/libs.versions.toml b/devtools/gradle/gradle/libs.versions.toml index d5d736e288b29..cd636da4892f5 100644 --- a/devtools/gradle/gradle/libs.versions.toml +++ b/devtools/gradle/gradle/libs.versions.toml @@ -3,7 +3,7 @@ plugin-publish = "1.3.1" # updating Kotlin here makes QuarkusPluginTest > shouldNotFailOnProjectDependenciesWithoutMain(Path) fail kotlin = "2.0.21" -smallrye-config = "3.11.2" +smallrye-config = "3.11.3-SNAPSHOT" junit5 = "5.10.5" assertj = "3.27.3" diff --git a/extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/ConfigBuildStep.java b/extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/ConfigBuildStep.java index 1724044dd39e3..941e7d66b5736 100644 --- a/extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/ConfigBuildStep.java +++ b/extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/ConfigBuildStep.java @@ -502,7 +502,7 @@ void registerConfigClasses( // TODO - Register ConfigProperties during build time context.registerNonDefaultConstructor( ConfigClass.class.getDeclaredConstructor(Class.class, String.class), - configClass -> Stream.of(configClass.getKlass(), configClass.getPrefix()) + configClass -> Stream.of(configClass.getType(), configClass.getPrefix()) .collect(toList())); recorder.registerConfigProperties(