io.streamthoughts.kafka.specs.config.JikkouParams Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2021 StreamThoughts.
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.streamthoughts.kafka.specs.config;

import io.streamthoughts.kafka.specs.internal.PropertiesUtils;
import io.vavr.Tuple2;
import org.apache.kafka.clients.admin.AdminClientConfig;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * The list of configuration parameters.
 */
public final class JikkouParams {

    public static final String ADMIN_CLIENT_CONFIG_NAME = "adminClient";

    public static final ConfigParam ADMIN_CLIENT_CONFIG = ConfigParam
            .ofMap(ADMIN_CLIENT_CONFIG_NAME)
            .orElse(HashMap::new)
            .map(JikkouParams::getAdminClientConfigs)
            .map(PropertiesUtils::fromMap);

    public static final ConfigParam> TEMPLATING_VARS_CONFIG = ConfigParam
            .ofMap("templating.vars").orElse(HashMap::new);

    public static final ConfigParam VALIDATION_TOPIC_MIN_REPLICATION_FACTOR_CONFIG = ConfigParam
            .ofInt("topic-min-replication-factor");

    public static final ConfigParam VALIDATION_TOPIC_MIN_NUM_PARTITIONS_CONFIG = ConfigParam
            .ofInt("topic-min-num-partitions");

    public static final ConfigParam VALIDATION_TOPIC_NAME_REGEX_CONFIG = ConfigParam
            .ofString("topic-name-regex");

    public static final ConfigParam> VALIDATION_TOPIC_NAME_PREFIXES_CONFIG = ConfigParam
            .ofList("topic-name-prefixes-allowed");

    public static final ConfigParam> VALIDATION_TOPIC_NAME_SUFFIXES_CONFIG = ConfigParam
            .ofList("topic-name-suffixes-allowed");

    public static final ConfigParam>> VALIDATIONS_CONFIG = ConfigParam
            .ofConfigs("validations")
            .map(configs -> configs.stream()
                       .map(o -> new JikkouConfig(o, false))
                       .map(config ->  new Tuple2<>(
                               config.getString("type"),
                               config.findConfig("config").getOrElse(JikkouConfig.empty())
                       ))
                       .collect(Collectors.toList())
            );

    public static final ConfigParam>> TRANSFORMATIONS_CONFIG = ConfigParam
            .ofConfigs("transforms")
            .map(configs -> configs.stream()
                    .map(o -> new JikkouConfig(o, false))
                    .map(config ->  new Tuple2<>(
                            config.getString("type"),
                            config.findConfig("config").getOrElse(JikkouConfig.empty())
                    ))
                    .collect(Collectors.toList())
            );
    public static final ConfigParam> EXTENSION_PATHS = ConfigParam
            .ofList("extension.paths");

    public static final ConfigParam INCLUDE_RESOURCES = ConfigParam
            .ofList("include-resources")
            .map(l -> l.stream().map(Pattern::compile).collect(Collectors.toList()))
            .orElse(Collections::emptyList)
            .map(l -> l.toArray(Pattern[]::new));

    public static final ConfigParam EXCLUDE_RESOURCES = ConfigParam
            .ofList("exclude-resources")
            .map(l -> l.stream().map(Pattern::compile).collect(Collectors.toList()))
            .orElse(Collections::emptyList)
            .map(l -> l.toArray(Pattern[]::new));

    public static final ConfigParam KAFKA_BROKERS_WAIT_FOR_ENABLED = ConfigParam
            .ofBoolean("kafka.brokers.wait-for-enabled");

    public static final ConfigParam KAFKA_BROKERS_WAIT_FOR_MIN_AVAILABLE = ConfigParam
            .ofInt("kafka.brokers.wait-for-min-available");

    public static final ConfigParam KAFKA_BROKERS_WAIT_FOR_RETRY_BACKOFF_MS = ConfigParam
            .ofLong("kafka.brokers.wait-for-retry-backoff-ms");

    public static final ConfigParam KAFKA_BROKERS_WAIT_FOR_TIMEOUT_MS = ConfigParam
            .ofLong("kafka.brokers.wait-for-timeout-ms");

    private static Map getAdminClientConfigs(final Map configs) {
        return getConfigsForKeys(configs, AdminClientConfig.configNames());
    }

    private static Map getConfigsForKeys(final Map configs,
                                                         final Set keys) {
        final Map parsed = new HashMap<>();
        for (final String configName : keys) {
            if (configs.containsKey(configName)) {
                parsed.put(configName, configs.get(configName));
            }
        }
        return parsed;
    }
}