Examples with ConfigProvider org.apache.kafka.common.config.provider.ConfigProvider used on opensource projects

Example 1 with ConfigProvider

use of org.apache.kafka.common.config.provider.ConfigProvider in project kafka by apache.

the class Plugins method newConfigProvider.

public ConfigProvider newConfigProvider(AbstractConfig config, String providerPrefix, ClassLoaderUsage classLoaderUsage) {
    String classPropertyName = providerPrefix + ".class";
    Map<String, String> originalConfig = config.originalsStrings();
    if (!originalConfig.containsKey(classPropertyName)) {
        // This configuration does not define the config provider via the specified property name
        return null;
    }
    Class<? extends ConfigProvider> klass = null;
    switch(classLoaderUsage) {
        case CURRENT_CLASSLOADER:
            // Attempt to load first with the current classloader, and plugins as a fallback.
            klass = pluginClassFromConfig(config, classPropertyName, ConfigProvider.class, delegatingLoader.configProviders());
            break;
        case PLUGINS:
            // Attempt to load with the plugin class loader, which uses the current classloader as a fallback
            String configProviderClassOrAlias = originalConfig.get(classPropertyName);
            try {
                klass = pluginClass(delegatingLoader, configProviderClassOrAlias, ConfigProvider.class);
            } catch (ClassNotFoundException e) {
                throw new ConnectException("Failed to find any class that implements ConfigProvider and which name matches " + configProviderClassOrAlias + ", available ConfigProviders are: " + pluginNames(delegatingLoader.configProviders()));
            }
            break;
    }
    if (klass == null) {
        throw new ConnectException("Unable to initialize the ConfigProvider specified in '" + classPropertyName + "'");
    }
    // Configure the ConfigProvider
    String configPrefix = providerPrefix + ".param.";
    Map<String, Object> configProviderConfig = config.originalsWithPrefix(configPrefix);
    ConfigProvider plugin;
    ClassLoader savedLoader = compareAndSwapLoaders(klass.getClassLoader());
    try {
        plugin = newPlugin(klass);
        plugin.configure(configProviderConfig);
    } finally {
        compareAndSwapLoaders(savedLoader);
    }
    return plugin;
}

Example 2 with ConfigProvider

use of org.apache.kafka.common.config.provider.ConfigProvider in project kafka by apache.

the class AbstractConfig method instantiateConfigProviders.

/**
 * Instantiates and configures the ConfigProviders. The config providers configs are defined as follows:
 * config.providers : A comma-separated list of names for providers.
 * config.providers.{name}.class : The Java class name for a provider.
 * config.providers.{name}.param.{param-name} : A parameter to be passed to the above Java class on initialization.
 * returns a map of config provider name and its instance.
 * @param indirectConfigs The map of potential variable configs
 * @param providerConfigProperties The map of config provider configs
 * @return map map of config provider name and its instance.
 */
private Map<String, ConfigProvider> instantiateConfigProviders(Map<String, String> indirectConfigs, Map<String, ?> providerConfigProperties) {
    final String configProviders = indirectConfigs.get(CONFIG_PROVIDERS_CONFIG);
    if (configProviders == null || configProviders.isEmpty()) {
        return Collections.emptyMap();
    }
    Map<String, String> providerMap = new HashMap<>();
    for (String provider : configProviders.split(",")) {
        String providerClass = providerClassProperty(provider);
        if (indirectConfigs.containsKey(providerClass))
            providerMap.put(provider, indirectConfigs.get(providerClass));
    }
    // Instantiate Config Providers
    Map<String, ConfigProvider> configProviderInstances = new HashMap<>();
    for (Map.Entry<String, String> entry : providerMap.entrySet()) {
        try {
            String prefix = CONFIG_PROVIDERS_CONFIG + "." + entry.getKey() + CONFIG_PROVIDERS_PARAM;
            Map<String, ?> configProperties = configProviderProperties(prefix, providerConfigProperties);
            ConfigProvider provider = Utils.newInstance(entry.getValue(), ConfigProvider.class);
            provider.configure(configProperties);
            configProviderInstances.put(entry.getKey(), provider);
        } catch (ClassNotFoundException e) {
            log.error("Could not load config provider class " + entry.getValue(), e);
            throw new ConfigException(providerClassProperty(entry.getKey()), entry.getValue(), "Could not load config provider class or one of its dependencies");
        }
    }
    return configProviderInstances;
}

Example 3 with ConfigProvider

use of org.apache.kafka.common.config.provider.ConfigProvider in project kafka by apache.

the class ConfigTransformer method transform.

/**
 * Transforms the given configuration data by using the {@link ConfigProvider} instances to
 * look up values to replace the variables in the pattern.
 *
 * @param configs the configuration values to be transformed
 * @return an instance of {@link ConfigTransformerResult}
 */
public ConfigTransformerResult transform(Map<String, String> configs) {
    Map<String, Map<String, Set<String>>> keysByProvider = new HashMap<>();
    Map<String, Map<String, Map<String, String>>> lookupsByProvider = new HashMap<>();
    // Collect the variables from the given configs that need transformation
    for (Map.Entry<String, String> config : configs.entrySet()) {
        if (config.getValue() != null) {
            List<ConfigVariable> vars = getVars(config.getValue(), DEFAULT_PATTERN);
            for (ConfigVariable var : vars) {
                Map<String, Set<String>> keysByPath = keysByProvider.computeIfAbsent(var.providerName, k -> new HashMap<>());
                Set<String> keys = keysByPath.computeIfAbsent(var.path, k -> new HashSet<>());
                keys.add(var.variable);
            }
        }
    }
    // Retrieve requested variables from the ConfigProviders
    Map<String, Long> ttls = new HashMap<>();
    for (Map.Entry<String, Map<String, Set<String>>> entry : keysByProvider.entrySet()) {
        String providerName = entry.getKey();
        ConfigProvider provider = configProviders.get(providerName);
        Map<String, Set<String>> keysByPath = entry.getValue();
        if (provider != null && keysByPath != null) {
            for (Map.Entry<String, Set<String>> pathWithKeys : keysByPath.entrySet()) {
                String path = pathWithKeys.getKey();
                Set<String> keys = new HashSet<>(pathWithKeys.getValue());
                ConfigData configData = provider.get(path, keys);
                Map<String, String> data = configData.data();
                Long ttl = configData.ttl();
                if (ttl != null && ttl >= 0) {
                    ttls.put(path, ttl);
                }
                Map<String, Map<String, String>> keyValuesByPath = lookupsByProvider.computeIfAbsent(providerName, k -> new HashMap<>());
                keyValuesByPath.put(path, data);
            }
        }
    }
    // Perform the transformations by performing variable replacements
    Map<String, String> data = new HashMap<>(configs);
    for (Map.Entry<String, String> config : configs.entrySet()) {
        data.put(config.getKey(), replace(lookupsByProvider, config.getValue(), DEFAULT_PATTERN));
    }
    return new ConfigTransformerResult(data, ttls);
}

Example 4 with ConfigProvider

use of org.apache.kafka.common.config.provider.ConfigProvider in project kafka by apache.

the class MirrorMakerConfig method transform.

Map<String, String> transform(Map<String, String> props) {
    // transform worker config according to config.providers
    List<String> providerNames = configProviders();
    Map<String, ConfigProvider> providers = new HashMap<>();
    for (String name : providerNames) {
        ConfigProvider configProvider = plugins.newConfigProvider(this, CONFIG_PROVIDERS_CONFIG + "." + name, Plugins.ClassLoaderUsage.PLUGINS);
        providers.put(name, configProvider);
    }
    ConfigTransformer transformer = new ConfigTransformer(providers);
    Map<String, String> transformed = transformer.transform(props).data();
    providers.values().forEach(x -> Utils.closeQuietly(x, "config provider"));
    return transformed;
}

Example 5 with ConfigProvider

use of org.apache.kafka.common.config.provider.ConfigProvider in project kafka by apache.

the class PluginsTest method newConfigProviderShouldConfigureWithPluginClassLoader.

@Test
public void newConfigProviderShouldConfigureWithPluginClassLoader() {
    TestPlugins.assertAvailable();
    String providerPrefix = "some.provider";
    props.put(providerPrefix + ".class", TestPlugins.SAMPLING_CONFIG_PROVIDER);
    PluginClassLoader classLoader = plugins.delegatingLoader().pluginClassLoader(TestPlugins.SAMPLING_CONFIG_PROVIDER);
    assertNotNull(classLoader);
    ClassLoader savedLoader = Plugins.compareAndSwapLoaders(classLoader);
    createConfig();
    Plugins.compareAndSwapLoaders(savedLoader);
    ConfigProvider plugin = plugins.newConfigProvider(config, providerPrefix, ClassLoaderUsage.PLUGINS);
    assertInstanceOf(SamplingTestPlugin.class, plugin, "Cannot collect samples");
    Map<String, SamplingTestPlugin> samples = ((SamplingTestPlugin) plugin).flatten();
    assertTrue(samples.containsKey("configure"));
    assertPluginClassLoaderAlwaysActive(samples);
}