org.keycloak.quarkus.runtime.configuration.mappers.PropertyMapper Maven / Gradle / Ivy
/*
* Copyright 2021 Red Hat, Inc. and/or its affiliates
* and other contributors as indicated by the @author tags.
*
* 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 org.keycloak.quarkus.runtime.configuration.mappers;
import static java.util.Optional.ofNullable;
import static org.keycloak.quarkus.runtime.Environment.isRebuild;
import static org.keycloak.quarkus.runtime.configuration.Configuration.OPTION_PART_SEPARATOR;
import static org.keycloak.quarkus.runtime.configuration.Configuration.OPTION_PART_SEPARATOR_CHAR;
import static org.keycloak.quarkus.runtime.configuration.Configuration.toCliFormat;
import static org.keycloak.quarkus.runtime.configuration.Configuration.toEnvVarFormat;
import java.util.List;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import io.smallrye.config.ConfigSourceInterceptorContext;
import io.smallrye.config.ConfigValue;
import org.keycloak.config.DeprecatedMetadata;
import org.keycloak.config.Option;
import org.keycloak.config.OptionBuilder;
import org.keycloak.config.OptionCategory;
import org.keycloak.quarkus.runtime.cli.PropertyException;
import org.keycloak.quarkus.runtime.cli.PropertyMapperParameterConsumer;
import org.keycloak.quarkus.runtime.configuration.ConfigArgsConfigSource;
import org.keycloak.quarkus.runtime.Environment;
import org.keycloak.quarkus.runtime.configuration.MicroProfileConfigProvider;
public class PropertyMapper {
static PropertyMapper IDENTITY = new PropertyMapper<>(
new OptionBuilder<>(null, String.class).build(),
null,
null,
null,
null,
false,
null) {
@Override
public ConfigValue getConfigValue(String name, ConfigSourceInterceptorContext context) {
return context.proceed(name);
}
};
private final Option option;
private final String to;
private final BiFunction, ConfigSourceInterceptorContext, Optional> mapper;
private final String mapFrom;
private final boolean mask;
private final String paramLabel;
private final String envVarFormat;
private String cliFormat;
private BiConsumer, ConfigValue> validator;
PropertyMapper(Option option, String to, BiFunction, ConfigSourceInterceptorContext, Optional> mapper,
String mapFrom, String paramLabel, boolean mask, BiConsumer, ConfigValue> validator) {
this.option = option;
this.to = to == null ? getFrom() : to;
this.mapper = mapper == null ? PropertyMapper::defaultTransformer : mapper;
this.mapFrom = mapFrom;
this.paramLabel = paramLabel;
this.mask = mask;
this.cliFormat = toCliFormat(option.getKey());
this.envVarFormat = toEnvVarFormat(getFrom());
this.validator = validator;
}
private static Optional defaultTransformer(Optional value, ConfigSourceInterceptorContext context) {
return value;
}
ConfigValue getConfigValue(ConfigSourceInterceptorContext context) {
return getConfigValue(to, context);
}
ConfigValue getConfigValue(String name, ConfigSourceInterceptorContext context) {
String from = getFrom();
if (to != null && to.endsWith(OPTION_PART_SEPARATOR)) {
// in case mapping is based on prefixes instead of full property names
from = name.replace(to.substring(0, to.lastIndexOf('.')), from.substring(0, from.lastIndexOf(OPTION_PART_SEPARATOR_CHAR)));
}
if ((isRebuild() || Environment.isRebuildCheck()) && isRunTime()) {
// during re-aug do not resolve the server runtime properties and avoid they included by quarkus in the default value config source
return ConfigValue.builder().withName(name).build();
}
// try to obtain the value for the property we want to map first
ConfigValue config = convertValue(context.proceed(from));
if (config == null) {
if (mapFrom != null) {
// if the property we want to map depends on another one, we use the value from the other property to call the mapper
String parentKey = MicroProfileConfigProvider.NS_KEYCLOAK_PREFIX + mapFrom;
ConfigValue parentValue = convertValue(context.proceed(parentKey));
if (parentValue == null) {
// parent value not explicitly set, try to resolve the default value set to the parent property
PropertyMapper parentMapper = PropertyMappers.getMapper(parentKey);
if (parentMapper != null && parentMapper.getDefaultValue().isPresent()) {
parentValue = ConfigValue.builder().withValue(Option.getDefaultValueString(parentMapper.getDefaultValue().get())).build();
}
}
return transformValue(name, ofNullable(parentValue == null ? null : parentValue.getValue()), context, null);
}
ConfigValue defaultValue = transformValue(name, this.option.getDefaultValue().map(Option::getDefaultValueString), context, null);
if (defaultValue != null) {
return defaultValue;
}
// now tries any defaults from quarkus
ConfigValue current = context.proceed(name);
if (current != null) {
return transformValue(name, ofNullable(current.getValue()), context, current.getConfigSourceName());
}
return current;
}
ConfigValue transformedValue = transformValue(name, ofNullable(config.getValue()), context, config.getConfigSourceName());
// we always fallback to the current value from the property we are mapping
if (transformedValue == null) {
return context.proceed(name);
}
return transformedValue;
}
public Option getOption() { return this.option; }
public Class getType() { return this.option.getType(); }
public String getFrom() {
return MicroProfileConfigProvider.NS_KEYCLOAK_PREFIX + this.option.getKey();
}
public String getDescription() { return this.option.getDescription(); }
public List getExpectedValues() {
return this.option.getExpectedValues();
}
public Optional getDefaultValue() { return this.option.getDefaultValue(); }
public OptionCategory getCategory() {
return this.option.getCategory();
}
public boolean isHidden() { return this.option.isHidden(); }
public boolean isBuildTime() {
return this.option.isBuildTime();
}
public boolean isRunTime() {
return !this.option.isBuildTime();
}
public String getTo() {
return to;
}
public String getParamLabel() {
return paramLabel;
}
public String getCliFormat() {
return cliFormat;
}
public String getEnvVarFormat() {
return envVarFormat;
}
boolean isMask() {
return mask;
}
public Optional getDeprecatedMetadata() {
return option.getDeprecatedMetadata();
}
private ConfigValue transformValue(String name, Optional value, ConfigSourceInterceptorContext context, String configSourceName) {
if (value == null) {
return null;
}
if (mapper == null || (mapFrom == null && name.equals(getFrom()))) {
// no mapper set or requesting a property that does not depend on other property, just return the value from the config source
return ConfigValue.builder().withName(name).withValue(value.orElse(null)).withConfigSourceName(configSourceName).build();
}
Optional mappedValue = mapper.apply(value, context);
if (mappedValue == null || mappedValue.isEmpty()) {
return null;
}
return ConfigValue.builder().withName(name).withValue(mappedValue.get()).withRawValue(value.orElse(null))
.withConfigSourceName(configSourceName).build();
}
private ConfigValue convertValue(ConfigValue configValue) {
if (configValue == null) {
return null;
}
return configValue.withValue(ofNullable(configValue.getValue()).map(String::trim).orElse(null));
}
public static class Builder {
private final Option option;
private String to;
private BiFunction, ConfigSourceInterceptorContext, Optional> mapper;
private String mapFrom = null;
private boolean isMasked = false;
private String paramLabel;
private BiConsumer, ConfigValue> validator = (mapper, value) -> mapper.validateExpectedValues(value, (c, v) -> mapper.validateSingleValue(c, v));
public Builder(Option option) {
this.option = option;
}
public Builder to(String to) {
this.to = to;
return this;
}
public Builder transformer(BiFunction, ConfigSourceInterceptorContext, Optional> mapper) {
this.mapper = mapper;
return this;
}
public Builder paramLabel(String label) {
this.paramLabel = label;
return this;
}
public Builder mapFrom(String mapFrom) {
this.mapFrom = mapFrom;
return this;
}
public Builder isMasked(boolean isMasked) {
this.isMasked = isMasked;
return this;
}
public Builder validator(BiConsumer, ConfigValue> validator) {
this.validator = validator;
return this;
}
public PropertyMapper build() {
if (paramLabel == null && Boolean.class.equals(option.getType())) {
paramLabel = Boolean.TRUE + "|" + Boolean.FALSE;
}
return new PropertyMapper(option, to, mapper, mapFrom, paramLabel, isMasked, validator);
}
}
public static PropertyMapper.Builder fromOption(Option opt) {
return new PropertyMapper.Builder<>(opt);
}
public void validate(ConfigValue value) {
if (validator != null) {
validator.accept(this, value);
}
}
public void validateExpectedValues(ConfigValue configValue, BiConsumer singleValidator) {
String value = configValue.getValue();
boolean multiValued = getOption().getType() == java.util.List.class;
String[] values = multiValued ? value.split(",") : new String[] { value };
for (String v : values) {
boolean cli = isCliOption(configValue);
if (multiValued && !v.trim().equals(v)) {
throw new PropertyException("Invalid value for multivalued option '" + (cli ? this.getCliFormat() : getFrom())
+ "': list value '" + v + "' should not have leading nor trailing whitespace"
+ getConfigSourceMessage(configValue, cli));
}
singleValidator.accept(configValue, v);
}
}
private boolean isCliOption(ConfigValue configValue) {
return Optional.ofNullable(configValue.getConfigSourceName()).filter(name -> name.contains(ConfigArgsConfigSource.NAME)).isPresent();
}
void validateSingleValue(ConfigValue configValue, String v) {
List expectedValues = getExpectedValues();
if (!expectedValues.isEmpty() && !expectedValues.contains(v)) {
boolean cli = isCliOption(configValue);
throw new PropertyException(
PropertyMapperParameterConsumer.getErrorMessage(cli ? this.getCliFormat() : getFrom(), v,
expectedValues) + getConfigSourceMessage(configValue, cli));
}
}
String getConfigSourceMessage(ConfigValue configValue, boolean cli) {
return cli ? "" : ". From ConfigSource " + configValue.getConfigSourceName();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy