Package io.vertx.mutiny.kafka.admin

Class KafkaAdminClient

  • public class KafkaAdminClient
extends Object
    Vert.x Kafka Admin client implementation

    NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

    • Constructor Detail

      • KafkaAdminClient

        public KafkaAdminClient​(io.vertx.kafka.admin.KafkaAdminClient delegate)

      • KafkaAdminClient

        public KafkaAdminClient​(Object delegate)

    • Method Detail

      • getDelegate

        public io.vertx.kafka.admin.KafkaAdminClient getDelegate()

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • create

        public static KafkaAdminClient create​(Vertx vertx,
                                      Map<String,​String> config)
        Parameters:
        vertx - Vert.x instance to use
        config - Kafka admin client configuration
        Returns:
        an instance of the KafkaAdminClient

      • listTopics

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Set<String>> listTopics()
        List the topics available in the cluster with the default options.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • listTopicsAndAwait

        public Set<String> listTopicsAndAwait()
        Blocking variant of listTopics().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Set instance produced by the operation.

      • listTopicsAndForget

        public void listTopicsAndForget()
        Variant of listTopics() that ignores the result of the operation.

        This method subscribes on the result of listTopics(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listTopics() but you don't need to compose it with other operations.

      • describeTopics

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Map<String,​io.vertx.kafka.admin.TopicDescription>> describeTopics​(List<String> topicNames)
        Describe some topics in the cluster, with the default options.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        topicNames - the names of the topics to describe
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeTopicsAndAwait

        public Map<String,​io.vertx.kafka.admin.TopicDescription> describeTopicsAndAwait​(List<String> topicNames)
        Blocking variant of describeTopics(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        topicNames - the names of the topics to describe
        Returns:
        the Map instance produced by the operation.

      • describeTopicsAndForget

        public void describeTopicsAndForget​(List<String> topicNames)
        Variant of describeTopics(List) that ignores the result of the operation.

        This method subscribes on the result of describeTopics(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from describeTopics(List) but you don't need to compose it with other operations.

        Parameters:
        topicNames - the names of the topics to describe

      • describeTopics

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Map<String,​io.vertx.kafka.admin.TopicDescription>> describeTopics​(List<String> topicNames,
                                                                                                      io.vertx.kafka.admin.DescribeTopicsOptions options)
        Like describeTopics(java.util.List<java.lang.String>) but allows for customised otions

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        topicNames -
        options -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeTopicsAndAwait

        public Map<String,​io.vertx.kafka.admin.TopicDescription> describeTopicsAndAwait​(List<String> topicNames,
                                                                                      io.vertx.kafka.admin.DescribeTopicsOptions options)
        Blocking variant of describeTopics(List,DescribeTopicsOptions).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        topicNames -
        options -
        Returns:
        the Map instance produced by the operation.

      • createTopics

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> createTopics​(List<io.vertx.kafka.admin.NewTopic> topics)
        Creates a batch of new Kafka topics

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        topics - topics to create
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • createTopicsAndAwait

        public Void createTopicsAndAwait​(List<io.vertx.kafka.admin.NewTopic> topics)
        Blocking variant of createTopics(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        topics - topics to create
        Returns:
        the Void instance produced by the operation.

      • createTopicsAndForget

        public void createTopicsAndForget​(List<io.vertx.kafka.admin.NewTopic> topics)
        Variant of createTopics(List) that ignores the result of the operation.

        This method subscribes on the result of createTopics(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createTopics(List) but you don't need to compose it with other operations.

        Parameters:
        topics - topics to create

      • deleteTopics

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> deleteTopics​(List<String> topicNames)
        Deletes a batch of Kafka topics

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        topicNames - the names of the topics to delete
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • deleteTopicsAndAwait

        public Void deleteTopicsAndAwait​(List<String> topicNames)
        Blocking variant of deleteTopics(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        topicNames - the names of the topics to delete
        Returns:
        the Void instance produced by the operation.

      • deleteTopicsAndForget

        public void deleteTopicsAndForget​(List<String> topicNames)
        Variant of deleteTopics(List) that ignores the result of the operation.

        This method subscribes on the result of deleteTopics(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deleteTopics(List) but you don't need to compose it with other operations.

        Parameters:
        topicNames - the names of the topics to delete

      • createPartitions

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> createPartitions​(Map<String,​io.vertx.kafka.admin.NewPartitions> partitions)
        Creates a batch of new partitions in the Kafka topic

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        partitions - partitions to create
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • createPartitionsAndAwait

        public Void createPartitionsAndAwait​(Map<String,​io.vertx.kafka.admin.NewPartitions> partitions)
        Blocking variant of createPartitions(Map).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        partitions - partitions to create
        Returns:
        the Void instance produced by the operation.

      • createPartitionsAndForget

        public void createPartitionsAndForget​(Map<String,​io.vertx.kafka.admin.NewPartitions> partitions)
        Variant of createPartitions(Map) that ignores the result of the operation.

        This method subscribes on the result of createPartitions(Map), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createPartitions(Map) but you don't need to compose it with other operations.

        Parameters:
        partitions - partitions to create

      • listConsumerGroups

        @CheckReturnValue
public io.smallrye.mutiny.Uni<List<io.vertx.kafka.admin.ConsumerGroupListing>> listConsumerGroups()
        Get the the consumer groups available in the cluster with the default options

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • listConsumerGroupsAndAwait

        public List<io.vertx.kafka.admin.ConsumerGroupListing> listConsumerGroupsAndAwait()
        Blocking variant of listConsumerGroups().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the List instance produced by the operation.

      • listConsumerGroupsAndForget

        public void listConsumerGroupsAndForget()
        Variant of listConsumerGroups() that ignores the result of the operation.

        This method subscribes on the result of listConsumerGroups(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from listConsumerGroups() but you don't need to compose it with other operations.

      • describeConsumerGroups

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Map<String,​io.vertx.kafka.admin.ConsumerGroupDescription>> describeConsumerGroups​(List<String> groupIds)
        Describe some group ids in the cluster, with the default options

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        groupIds - the ids of the groups to describe
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeConsumerGroupsAndAwait

        public Map<String,​io.vertx.kafka.admin.ConsumerGroupDescription> describeConsumerGroupsAndAwait​(List<String> groupIds)
        Blocking variant of describeConsumerGroups(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        groupIds - the ids of the groups to describe
        Returns:
        the Map instance produced by the operation.

      • describeConsumerGroupsAndForget

        public void describeConsumerGroupsAndForget​(List<String> groupIds)
        Variant of describeConsumerGroups(List) that ignores the result of the operation.

        This method subscribes on the result of describeConsumerGroups(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from describeConsumerGroups(List) but you don't need to compose it with other operations.

        Parameters:
        groupIds - the ids of the groups to describe

      • describeConsumerGroups

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Map<String,​io.vertx.kafka.admin.ConsumerGroupDescription>> describeConsumerGroups​(List<String> groupIds,
                                                                                                                      io.vertx.kafka.admin.DescribeConsumerGroupsOptions options)
        Like describeConsumerGroups(java.util.List<java.lang.String>) but allows customized options

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        groupIds -
        options -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeConsumerGroupsAndAwait

        public Map<String,​io.vertx.kafka.admin.ConsumerGroupDescription> describeConsumerGroupsAndAwait​(List<String> groupIds,
                                                                                                      io.vertx.kafka.admin.DescribeConsumerGroupsOptions options)
        Blocking variant of describeConsumerGroups(List,DescribeConsumerGroupsOptions).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        groupIds -
        options -
        Returns:
        the Map instance produced by the operation.

      • describeCluster

        @CheckReturnValue
public io.smallrye.mutiny.Uni<io.vertx.kafka.admin.ClusterDescription> describeCluster()
        Describe the nodes in the cluster with the default options

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeClusterAndAwait

        public io.vertx.kafka.admin.ClusterDescription describeClusterAndAwait()
        Blocking variant of describeCluster().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the ClusterDescription instance produced by the operation.

      • describeClusterAndForget

        public void describeClusterAndForget()
        Variant of describeCluster() that ignores the result of the operation.

        This method subscribes on the result of describeCluster(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from describeCluster() but you don't need to compose it with other operations.

      • describeCluster

        @CheckReturnValue
public io.smallrye.mutiny.Uni<io.vertx.kafka.admin.ClusterDescription> describeCluster​(io.vertx.kafka.admin.DescribeClusterOptions options)
        Like describeCluster() but allows customized options.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        options -
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeClusterAndAwait

        public io.vertx.kafka.admin.ClusterDescription describeClusterAndAwait​(io.vertx.kafka.admin.DescribeClusterOptions options)
        Blocking variant of describeCluster(DescribeClusterOptions).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        options -
        Returns:
        the ClusterDescription instance produced by the operation.

      • deleteConsumerGroups

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> deleteConsumerGroups​(List<String> groupIds)
        Delete consumer groups from the cluster.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        groupIds - the ids of the groups to delete
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • deleteConsumerGroupsAndAwait

        public Void deleteConsumerGroupsAndAwait​(List<String> groupIds)
        Blocking variant of deleteConsumerGroups(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        groupIds - the ids of the groups to delete
        Returns:
        the Void instance produced by the operation.

      • deleteConsumerGroupsAndForget

        public void deleteConsumerGroupsAndForget​(List<String> groupIds)
        Variant of deleteConsumerGroups(List) that ignores the result of the operation.

        This method subscribes on the result of deleteConsumerGroups(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deleteConsumerGroups(List) but you don't need to compose it with other operations.

        Parameters:
        groupIds - the ids of the groups to delete

      • deleteConsumerGroupOffsets

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> deleteConsumerGroupOffsets​(String groupId,
                                                               Set<io.vertx.kafka.client.common.TopicPartition> partitions)
        Delete committed offsets for a set of partitions in a consumer group. This will succeed at the partition level only if the group is not actively subscribed to the corresponding topic.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        groupId - The group id of the group whose offsets will be deleted
        partitions - The set of partitions in the consumer group whose offsets will be deleted
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • deleteConsumerGroupOffsetsAndAwait

        public Void deleteConsumerGroupOffsetsAndAwait​(String groupId,
                                               Set<io.vertx.kafka.client.common.TopicPartition> partitions)
        Blocking variant of deleteConsumerGroupOffsets(String,Set).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        groupId - The group id of the group whose offsets will be deleted
        partitions - The set of partitions in the consumer group whose offsets will be deleted
        Returns:
        the Void instance produced by the operation.

      • deleteConsumerGroupOffsetsAndForget

        public void deleteConsumerGroupOffsetsAndForget​(String groupId,
                                                Set<io.vertx.kafka.client.common.TopicPartition> partitions)
        Variant of deleteConsumerGroupOffsets(String,Set) that ignores the result of the operation.

        This method subscribes on the result of deleteConsumerGroupOffsets(String,Set), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deleteConsumerGroupOffsets(String,Set) but you don't need to compose it with other operations.

        Parameters:
        groupId - The group id of the group whose offsets will be deleted
        partitions - The set of partitions in the consumer group whose offsets will be deleted

      • close

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close()
        Close the admin client

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • closeAndAwait

        public Void closeAndAwait()
        Blocking variant of close().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Void instance produced by the operation.

      • closeAndForget

        public void closeAndForget()
        Variant of close() that ignores the result of the operation.

        This method subscribes on the result of close(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from close() but you don't need to compose it with other operations.

      • close

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close​(long timeout)
        Close the admin client

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        timeout - timeout to wait for closing
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • closeAndAwait

        public Void closeAndAwait​(long timeout)
        Blocking variant of close(long).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        timeout - timeout to wait for closing
        Returns:
        the Void instance produced by the operation.

      • closeAndForget

        public void closeAndForget​(long timeout)
        Variant of close(long) that ignores the result of the operation.

        This method subscribes on the result of close(long), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from close(long) but you don't need to compose it with other operations.

        Parameters:
        timeout - timeout to wait for closing

      • describeAcls

        @CheckReturnValue
public io.smallrye.mutiny.Uni<List<org.apache.kafka.common.acl.AclBinding>> describeAcls​(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter)
        Describe the ACL rules.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        aclBindingFilter - The filter to use.
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • describeAclsAndAwait

        public List<org.apache.kafka.common.acl.AclBinding> describeAclsAndAwait​(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter)
        Blocking variant of describeAcls(AclBindingFilter).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        aclBindingFilter - The filter to use.
        Returns:
        the List instance produced by the operation.

      • describeAclsAndForget

        public void describeAclsAndForget​(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter)
        Variant of describeAcls(AclBindingFilter) that ignores the result of the operation.

        This method subscribes on the result of describeAcls(AclBindingFilter), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from describeAcls(AclBindingFilter) but you don't need to compose it with other operations.

        Parameters:
        aclBindingFilter - The filter to use.

      • createAcls

        @CheckReturnValue
public io.smallrye.mutiny.Uni<List<org.apache.kafka.common.acl.AclBinding>> createAcls​(List<org.apache.kafka.common.acl.AclBinding> aclBindings)
        Create the ACL rules.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        aclBindings - The ACL to create.
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • createAclsAndAwait

        public List<org.apache.kafka.common.acl.AclBinding> createAclsAndAwait​(List<org.apache.kafka.common.acl.AclBinding> aclBindings)
        Blocking variant of createAcls(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        aclBindings - The ACL to create.
        Returns:
        the List instance produced by the operation.

      • createAclsAndForget

        public void createAclsAndForget​(List<org.apache.kafka.common.acl.AclBinding> aclBindings)
        Variant of createAcls(List) that ignores the result of the operation.

        This method subscribes on the result of createAcls(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from createAcls(List) but you don't need to compose it with other operations.

        Parameters:
        aclBindings - The ACL to create.

      • deleteAcls

        @CheckReturnValue
public io.smallrye.mutiny.Uni<List<org.apache.kafka.common.acl.AclBinding>> deleteAcls​(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings)
        Delete the ACL rules.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Parameters:
        aclBindings - The filter to delete matching ACLs.
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • deleteAclsAndAwait

        public List<org.apache.kafka.common.acl.AclBinding> deleteAclsAndAwait​(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings)
        Blocking variant of deleteAcls(List).

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Parameters:
        aclBindings - The filter to delete matching ACLs.
        Returns:
        the List instance produced by the operation.

      • deleteAclsAndForget

        public void deleteAclsAndForget​(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings)
        Variant of deleteAcls(List) that ignores the result of the operation.

        This method subscribes on the result of deleteAcls(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from deleteAcls(List) but you don't need to compose it with other operations.

        Parameters:
        aclBindings - The filter to delete matching ACLs.

      • newInstance

        public static KafkaAdminClient newInstance​(io.vertx.kafka.admin.KafkaAdminClient arg)