Package io.vertx.mutiny.kafka.admin

Class KafkaAdminClient

java.lang.Object
io.vertx.mutiny.kafka.admin.KafkaAdminClient
All Implemented Interfaces:
MutinyDelegate
public class KafkaAdminClient extends Object implements MutinyDelegate
Vert.x Kafka Admin client implementation

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

  • Field Details

  • Constructor Details

    • KafkaAdminClient

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

    • KafkaAdminClient

      public KafkaAdminClient(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.kafka.admin.KafkaAdminClient getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate used by this Mutiny object of generated type

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • 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<String,TopicDescription> 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<String,TopicDescription> instance produced by the operation.

    • describeTopicsAndForget

      public void describeTopicsAndForget(List<String> topicNames, io.vertx.kafka.admin.DescribeTopicsOptions options)
      Variant of describeTopics(List,DescribeTopicsOptions) that ignores the result of the operation.

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

      Parameters:
      topicNames -
      options -

    • 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<String,ConsumerGroupDescription> 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<String,ConsumerGroupDescription> instance produced by the operation.

    • describeConsumerGroupsAndForget

      public void describeConsumerGroupsAndForget(List<String> groupIds, io.vertx.kafka.admin.DescribeConsumerGroupsOptions options)
      Variant of describeConsumerGroups(List,DescribeConsumerGroupsOptions) that ignores the result of the operation.

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

      Parameters:
      groupIds -
      options -

    • 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.

    • describeClusterAndForget

      public void describeClusterAndForget(io.vertx.kafka.admin.DescribeClusterOptions options)
      Variant of describeCluster(DescribeClusterOptions) that ignores the result of the operation.

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

      Parameters:
      options -

    • 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)