io.streamthoughts.kafka.specs.command.broker.subcommands.internal.DescribeBrokers Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jikkou Show documentation
A command-line tool to help you automate the management of the configurations that live on your Apache Kafka clusters.
There is a newer version: 0.30.0
/*
 * Copyright 2020 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.command.broker.subcommands.internal;

import io.streamthoughts.kafka.specs.internal.ConfigsBuilder;
import io.streamthoughts.kafka.specs.operation.DescribeOperationOptions;
import io.streamthoughts.kafka.specs.model.V1BrokerObject;
import io.streamthoughts.kafka.specs.resources.Configs;
import org.apache.kafka.clients.admin.AdminClient;
import org.apache.kafka.clients.admin.Config;
import org.apache.kafka.clients.admin.ConfigEntry;
import org.apache.kafka.clients.admin.DescribeClusterResult;
import org.apache.kafka.clients.admin.DescribeConfigsResult;
import org.apache.kafka.common.Node;
import org.apache.kafka.common.config.ConfigResource;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * Class that can be used to describe topic resources.
 */
public class DescribeBrokers {

    private final AdminClient client;

    private Predicate configEntryPredicate;

    public DescribeBrokers(final AdminClient client,
                           final DescribeOperationOptions options) {
        this.client = client;
        this.configEntryPredicate = entry -> !entry.isDefault() || options.describeDefaultConfigs();
    }

    public void addConfigEntryPredicate(final Predicate configEntryPredicate) {
        this.configEntryPredicate = this.configEntryPredicate.and(configEntryPredicate) ;
    }

    public List describe(final Collection brokerIds) {

        final CompletableFuture> futureTopicDesc = describeCluster();
        final CompletableFuture> futureTopicConfig = describeConfigs(brokerIds);

        try {
            return futureTopicDesc.thenCombine(futureTopicConfig, (descriptions, configs) -> {
                return descriptions.values().stream().map(desc -> {
                    return new V1BrokerObject(
                            desc.idString(),
                            desc.host(),
                            desc.port(),
                            desc.rack(),
                            Configs.of(configs.get(desc.idString()), configEntryPredicate)
                    );
                }).collect(Collectors.toList());
            }).get();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    private CompletableFuture> describeConfigs(final Collection brokerIds) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                final ConfigsBuilder builder = new ConfigsBuilder();
                brokerIds.forEach(idString ->
                        builder.newResourceConfig()
                                .setType(ConfigResource.Type.BROKER)
                                .setName(idString));
                DescribeConfigsResult rs = client.describeConfigs(builder.build().keySet());
                Map configs = rs.all().get();
                return configs.entrySet()
                        .stream()
                        .collect(Collectors.toMap(entry -> entry.getKey().name(), Map.Entry::getValue));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }

    private CompletableFuture> describeCluster() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                DescribeClusterResult describeClusterResult = client.describeCluster();
                final Collection nodes = describeClusterResult.nodes().get();
                return nodes.stream().collect(Collectors.toMap(Node::idString, n -> n));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }

}