Class ConsulClient

java.lang.Object
io.vertx.mutiny.ext.consul.ConsulClient
All Implemented Interfaces:
MutinyDelegate

public class ConsulClient extends Object implements MutinyDelegate
A Vert.x service used to interact with Consul.

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

  • Field Details

  • Constructor Details

    • ConsulClient

      public ConsulClient(io.vertx.ext.consul.ConsulClient delegate)
    • ConsulClient

      public ConsulClient(Object delegate)
  • Method Details

    • getDelegate

      public io.vertx.ext.consul.ConsulClient 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 ConsulClient create(Vertx vertx)
      Parameters:
      vertx - the Vert.x instance
      Returns:
      the client
    • create

      public static ConsulClient create(Vertx vertx, io.vertx.ext.consul.ConsulClientOptions options)
      Parameters:
      vertx - the Vert.x instance
      options - the options
      Returns:
      the client
    • agentInfo

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.core.json.JsonObject> agentInfo()
      Returns the configuration and member information of the local agent

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

      public io.vertx.core.json.JsonObject agentInfoAndAwait()
      Blocking variant of agentInfo().

      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 JsonObject instance produced by the operation.
    • agentInfoAndForget

      public ConsulClient agentInfoAndForget()
      Variant of agentInfo() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • coordinateNodes

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CoordinateList> coordinateNodes()
      Returns the LAN network coordinates for all nodes in a given DC

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

      public io.vertx.ext.consul.CoordinateList coordinateNodesAndAwait()
      Blocking variant of coordinateNodes().

      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 CoordinateList instance produced by the operation.
    • coordinateNodesAndForget

      public ConsulClient coordinateNodesAndForget()
      Variant of coordinateNodes() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • coordinateNodesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CoordinateList> coordinateNodesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike coordinateNodes()

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

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

      public io.vertx.ext.consul.CoordinateList coordinateNodesWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of coordinateNodesWithOptions(BlockingQueryOptions).

      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 - the blocking options
      Returns:
      the CoordinateList instance produced by the operation.
    • coordinateNodesWithOptionsAndForget

      public ConsulClient coordinateNodesWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of coordinateNodesWithOptions(BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • coordinateDatacenters

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.DcCoordinates>> coordinateDatacenters()
      Returns the WAN network coordinates for all Consul servers, organized by DCs

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

      public List<io.vertx.ext.consul.DcCoordinates> coordinateDatacentersAndAwait()
      Blocking variant of coordinateDatacenters().

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

      public ConsulClient coordinateDatacentersAndForget()
      Variant of coordinateDatacenters() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • getKeys

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> getKeys(String keyPrefix)
      Returns the list of keys that corresponding to the specified key prefix.

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

      Parameters:
      keyPrefix - the prefix
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • getKeysAndAwait

      public List<String> getKeysAndAwait(String keyPrefix)
      Blocking variant of getKeys(String).

      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:
      keyPrefix - the prefix
      Returns:
      the List instance produced by the operation.
    • getKeysAndForget

      public ConsulClient getKeysAndForget(String keyPrefix)
      Variant of getKeys(String) that ignores the result of the operation.

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

      Parameters:
      keyPrefix - the prefix
      Returns:
      the instance of ConsulClient to chain method calls.
    • getKeysWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> getKeysWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the list of keys that corresponding to the specified key prefix.

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

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

      public List<String> getKeysWithOptionsAndAwait(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of getKeysWithOptions(String,BlockingQueryOptions).

      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:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      the List instance produced by the operation.
    • getKeysWithOptionsAndForget

      public ConsulClient getKeysWithOptionsAndForget(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of getKeysWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • getValue

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValue> getValue(String key)
      Returns key/value pair that corresponding to the specified key. An empty KeyValue object will be returned if no such key is found.

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

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

      public io.vertx.ext.consul.KeyValue getValueAndAwait(String key)
      Blocking variant of getValue(String).

      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:
      key - the key
      Returns:
      the KeyValue instance produced by the operation.
    • getValueAndForget

      public ConsulClient getValueAndForget(String key)
      Variant of getValue(String) that ignores the result of the operation.

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

      Parameters:
      key - the key
      Returns:
      the instance of ConsulClient to chain method calls.
    • getValueWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValue> getValueWithOptions(String key, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns key/value pair that corresponding to the specified key. An empty KeyValue object will be returned if no such key is found. This is blocking query unlike getValue(java.lang.String)

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

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

      public io.vertx.ext.consul.KeyValue getValueWithOptionsAndAwait(String key, io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of getValueWithOptions(String,BlockingQueryOptions).

      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:
      key - the key
      options - the blocking options
      Returns:
      the KeyValue instance produced by the operation.
    • getValueWithOptionsAndForget

      public ConsulClient getValueWithOptionsAndForget(String key, io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of getValueWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      key - the key
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • deleteValue

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deleteValue(String key)
      Remove the key/value pair that corresponding to the specified key

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

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

      public Void deleteValueAndAwait(String key)
      Blocking variant of deleteValue(String).

      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:
      key - the key
      Returns:
      the Void instance produced by the operation.
    • deleteValueAndForget

      public ConsulClient deleteValueAndForget(String key)
      Variant of deleteValue(String) that ignores the result of the operation.

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

      Parameters:
      key - the key
      Returns:
      the instance of ConsulClient to chain method calls.
    • getValues

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValueList> getValues(String keyPrefix)
      Returns the list of key/value pairs that corresponding to the specified key prefix. An empty KeyValueList object will be returned if no such key prefix is found.

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

      Parameters:
      keyPrefix - the prefix
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • getValuesAndAwait

      public io.vertx.ext.consul.KeyValueList getValuesAndAwait(String keyPrefix)
      Blocking variant of getValues(String).

      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:
      keyPrefix - the prefix
      Returns:
      the KeyValueList instance produced by the operation.
    • getValuesAndForget

      public ConsulClient getValuesAndForget(String keyPrefix)
      Variant of getValues(String) that ignores the result of the operation.

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

      Parameters:
      keyPrefix - the prefix
      Returns:
      the instance of ConsulClient to chain method calls.
    • getValuesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.KeyValueList> getValuesWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the list of key/value pairs that corresponding to the specified key prefix. An empty KeyValueList object will be returned if no such key prefix is found. This is blocking query unlike getValues(java.lang.String)

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

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

      public io.vertx.ext.consul.KeyValueList getValuesWithOptionsAndAwait(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of getValuesWithOptions(String,BlockingQueryOptions).

      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:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      the KeyValueList instance produced by the operation.
    • getValuesWithOptionsAndForget

      public ConsulClient getValuesWithOptionsAndForget(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of getValuesWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • deleteValues

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deleteValues(String keyPrefix)
      Removes all the key/value pair that corresponding to the specified key prefix

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

      Parameters:
      keyPrefix - the prefix
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deleteValuesAndAwait

      public Void deleteValuesAndAwait(String keyPrefix)
      Blocking variant of deleteValues(String).

      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:
      keyPrefix - the prefix
      Returns:
      the Void instance produced by the operation.
    • deleteValuesAndForget

      public ConsulClient deleteValuesAndForget(String keyPrefix)
      Variant of deleteValues(String) that ignores the result of the operation.

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

      Parameters:
      keyPrefix - the prefix
      Returns:
      the instance of ConsulClient to chain method calls.
    • putValue

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> putValue(String key, String value)
      Adds specified key/value pair

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

      Parameters:
      key - the key
      value - the value
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • putValueAndAwait

      public Boolean putValueAndAwait(String key, String value)
      Blocking variant of putValue(String,String).

      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:
      key - the key
      value - the value
      Returns:
      the Boolean instance produced by the operation.
    • putValueAndForget

      public ConsulClient putValueAndForget(String key, String value)
      Variant of putValue(String,String) that ignores the result of the operation.

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

      Parameters:
      key - the key
      value - the value
      Returns:
      the instance of ConsulClient to chain method calls.
    • putValueWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> putValueWithOptions(String key, String value, io.vertx.ext.consul.KeyValueOptions options)

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

      Parameters:
      key - the key
      value - the value
      options - options used to push pair
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • putValueWithOptionsAndAwait

      public Boolean putValueWithOptionsAndAwait(String key, String value, io.vertx.ext.consul.KeyValueOptions options)
      Blocking variant of putValueWithOptions(String,String,KeyValueOptions).

      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:
      key - the key
      value - the value
      options - options used to push pair
      Returns:
      the Boolean instance produced by the operation.
    • putValueWithOptionsAndForget

      public ConsulClient putValueWithOptionsAndForget(String key, String value, io.vertx.ext.consul.KeyValueOptions options)
      Variant of putValueWithOptions(String,String,KeyValueOptions) that ignores the result of the operation.

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

      Parameters:
      key - the key
      value - the value
      options - options used to push pair
      Returns:
      the instance of ConsulClient to chain method calls.
    • transaction

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.TxnResponse> transaction(io.vertx.ext.consul.TxnRequest request)
      Manages multiple operations inside a single, atomic transaction.

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

      Parameters:
      request - transaction request
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • transactionAndAwait

      public io.vertx.ext.consul.TxnResponse transactionAndAwait(io.vertx.ext.consul.TxnRequest request)
      Blocking variant of transaction(TxnRequest).

      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:
      request - transaction request
      Returns:
      the TxnResponse instance produced by the operation.
    • transactionAndForget

      public ConsulClient transactionAndForget(io.vertx.ext.consul.TxnRequest request)
      Variant of transaction(TxnRequest) that ignores the result of the operation.

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

      Parameters:
      request - transaction request
      Returns:
      the instance of ConsulClient to chain method calls.
    • createAclPolicy

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> createAclPolicy(io.vertx.ext.consul.policy.AclPolicy policy)
      Creates a new ACL policy

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

      Parameters:
      policy - properties of policy
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createAclPolicyAndAwait

      public String createAclPolicyAndAwait(io.vertx.ext.consul.policy.AclPolicy policy)
      Blocking variant of createAclPolicy(AclPolicy).

      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:
      policy - properties of policy
      Returns:
      the String instance produced by the operation.
    • createAclPolicyAndForget

      public ConsulClient createAclPolicyAndForget(io.vertx.ext.consul.policy.AclPolicy policy)
      Variant of createAclPolicy(AclPolicy) that ignores the result of the operation.

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

      Parameters:
      policy - properties of policy
      Returns:
      the instance of ConsulClient to chain method calls.
    • readPolicy

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.policy.AclPolicy> readPolicy(String id)
      This endpoint reads an ACL policy with the given ID

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

      Parameters:
      id - uuid policy
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • readPolicyAndAwait

      public io.vertx.ext.consul.policy.AclPolicy readPolicyAndAwait(String id)
      Blocking variant of readPolicy(String).

      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:
      id - uuid policy
      Returns:
      the AclPolicy instance produced by the operation.
    • readPolicyAndForget

      public ConsulClient readPolicyAndForget(String id)
      Variant of readPolicy(String) that ignores the result of the operation.

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

      Parameters:
      id - uuid policy
      Returns:
      the instance of ConsulClient to chain method calls.
    • readPolicyByName

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.policy.AclPolicy> readPolicyByName(String name)
      This endpoint reads an ACL policy with the given name

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

      Parameters:
      name - unique name of created policy
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • readPolicyByNameAndAwait

      public io.vertx.ext.consul.policy.AclPolicy readPolicyByNameAndAwait(String name)
      Blocking variant of readPolicyByName(String).

      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:
      name - unique name of created policy
      Returns:
      the AclPolicy instance produced by the operation.
    • readPolicyByNameAndForget

      public ConsulClient readPolicyByNameAndForget(String name)
      Variant of readPolicyByName(String) that ignores the result of the operation.

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

      Parameters:
      name - unique name of created policy
      Returns:
      the instance of ConsulClient to chain method calls.
    • updatePolicy

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.policy.AclPolicy> updatePolicy(String id, io.vertx.ext.consul.policy.AclPolicy policy)
      This endpoint updates an existing ACL policy

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

      Parameters:
      id - uuid of existing policy
      policy - options that will be applied to the existing policy
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updatePolicyAndAwait

      public io.vertx.ext.consul.policy.AclPolicy updatePolicyAndAwait(String id, io.vertx.ext.consul.policy.AclPolicy policy)
      Blocking variant of updatePolicy(String,AclPolicy).

      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:
      id - uuid of existing policy
      policy - options that will be applied to the existing policy
      Returns:
      the AclPolicy instance produced by the operation.
    • updatePolicyAndForget

      public ConsulClient updatePolicyAndForget(String id, io.vertx.ext.consul.policy.AclPolicy policy)
      Variant of updatePolicy(String,AclPolicy) that ignores the result of the operation.

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

      Parameters:
      id - uuid of existing policy
      policy - options that will be applied to the existing policy
      Returns:
      the instance of ConsulClient to chain method calls.
    • deletePolicy

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> deletePolicy(String id)
      This endpoint deletes an ACL policy

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

      Parameters:
      id - uuid of existing policy
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deletePolicyAndAwait

      public Boolean deletePolicyAndAwait(String id)
      Blocking variant of deletePolicy(String).

      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:
      id - uuid of existing policy
      Returns:
      the Boolean instance produced by the operation.
    • deletePolicyAndForget

      public void deletePolicyAndForget(String id)
      Variant of deletePolicy(String) that ignores the result of the operation.

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

      Parameters:
      id - uuid of existing policy
    • getAclPolicies

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.policy.AclPolicy>> getAclPolicies()
      This endpoint lists all the ACL policies. Note - The policies rules are not included in the listing and must be retrieved by the policy reading endpoint

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

      public List<io.vertx.ext.consul.policy.AclPolicy> getAclPoliciesAndAwait()
      Blocking variant of getAclPolicies().

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

      public void getAclPoliciesAndForget()
      Variant of getAclPolicies() that ignores the result of the operation.

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

    • createAclToken

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.token.AclToken> createAclToken(io.vertx.ext.consul.token.AclToken token)
      Create an Acl token

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

      Parameters:
      token - properties of the token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken createAclTokenAndAwait(io.vertx.ext.consul.token.AclToken token)
      Blocking variant of createAclToken(AclToken).

      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:
      token - properties of the token
      Returns:
      the AclToken instance produced by the operation.
    • createAclTokenAndForget

      public ConsulClient createAclTokenAndForget(io.vertx.ext.consul.token.AclToken token)
      Variant of createAclToken(AclToken) that ignores the result of the operation.

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

      Parameters:
      token - properties of the token
      Returns:
      the instance of ConsulClient to chain method calls.
    • updateAclToken

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.token.AclToken> updateAclToken(String accessorId, io.vertx.ext.consul.token.AclToken token)
      Update an existing Acl token

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

      Parameters:
      accessorId - uuid of the token
      token - properties of the token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken updateAclTokenAndAwait(String accessorId, io.vertx.ext.consul.token.AclToken token)
      Blocking variant of updateAclToken(String,AclToken).

      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:
      accessorId - uuid of the token
      token - properties of the token
      Returns:
      the AclToken instance produced by the operation.
    • updateAclTokenAndForget

      public ConsulClient updateAclTokenAndForget(String accessorId, io.vertx.ext.consul.token.AclToken token)
      Variant of updateAclToken(String,AclToken) that ignores the result of the operation.

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

      Parameters:
      accessorId - uuid of the token
      token - properties of the token
      Returns:
      the instance of ConsulClient to chain method calls.
    • cloneAclToken

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.token.AclToken> cloneAclToken(String accessorId, io.vertx.ext.consul.token.CloneAclTokenOptions cloneAclToken)
      Clones an existing ACL token

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

      Parameters:
      accessorId - uuid of the token
      cloneAclToken - properties of cloned token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • cloneAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken cloneAclTokenAndAwait(String accessorId, io.vertx.ext.consul.token.CloneAclTokenOptions cloneAclToken)
      Blocking variant of cloneAclToken(String,CloneAclTokenOptions).

      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:
      accessorId - uuid of the token
      cloneAclToken - properties of cloned token
      Returns:
      the AclToken instance produced by the operation.
    • cloneAclTokenAndForget

      public ConsulClient cloneAclTokenAndForget(String accessorId, io.vertx.ext.consul.token.CloneAclTokenOptions cloneAclToken)
      Variant of cloneAclToken(String,CloneAclTokenOptions) that ignores the result of the operation.

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

      Parameters:
      accessorId - uuid of the token
      cloneAclToken - properties of cloned token
      Returns:
      the instance of ConsulClient to chain method calls.
    • getAclTokens

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.token.AclToken>> getAclTokens()
      Get list of Acl token

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

      public List<io.vertx.ext.consul.token.AclToken> getAclTokensAndAwait()
      Blocking variant of getAclTokens().

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

      public ConsulClient getAclTokensAndForget()
      Variant of getAclTokens() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • readAclToken

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.token.AclToken> readAclToken(String accessorId)
      Reads an ACL token with the given Accessor ID

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

      Parameters:
      accessorId - uuid of token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • readAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken readAclTokenAndAwait(String accessorId)
      Blocking variant of readAclToken(String).

      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:
      accessorId - uuid of token
      Returns:
      the AclToken instance produced by the operation.
    • readAclTokenAndForget

      public ConsulClient readAclTokenAndForget(String accessorId)
      Variant of readAclToken(String) that ignores the result of the operation.

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

      Parameters:
      accessorId - uuid of token
      Returns:
      the instance of ConsulClient to chain method calls.
    • deleteAclToken

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> deleteAclToken(String accessorId)
      Deletes an ACL token

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

      Parameters:
      accessorId - uuid of token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deleteAclTokenAndAwait

      public Boolean deleteAclTokenAndAwait(String accessorId)
      Blocking variant of deleteAclToken(String).

      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:
      accessorId - uuid of token
      Returns:
      the Boolean instance produced by the operation.
    • deleteAclTokenAndForget

      public ConsulClient deleteAclTokenAndForget(String accessorId)
      Variant of deleteAclToken(String) that ignores the result of the operation.

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

      Parameters:
      accessorId - uuid of token
      Returns:
      the instance of ConsulClient to chain method calls.
    • createAclToken

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<String> createAclToken(io.vertx.ext.consul.AclToken token)
      Legacy create new Acl token

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

      Parameters:
      token - properties of the token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createAclTokenAndAwait

      @Deprecated public String createAclTokenAndAwait(io.vertx.ext.consul.AclToken token)
      Blocking variant of createAclToken(AclToken).

      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:
      token - properties of the token
      Returns:
      the String instance produced by the operation.
    • createAclTokenAndForget

      @Deprecated public ConsulClient createAclTokenAndForget(io.vertx.ext.consul.AclToken token)
      Variant of createAclToken(AclToken) that ignores the result of the operation.

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

      Parameters:
      token - properties of the token
      Returns:
      the instance of ConsulClient to chain method calls.
    • updateAclToken

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<String> updateAclToken(io.vertx.ext.consul.AclToken token)
      Update Acl token

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

      Parameters:
      token - properties of the token to be updated
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateAclTokenAndAwait

      @Deprecated public String updateAclTokenAndAwait(io.vertx.ext.consul.AclToken token)
      Blocking variant of io.vertx.mutiny.ext.consul.ConsulClient#updateAclToken(AclToken).

      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:
      token - properties of the token to be updated
      Returns:
      the String instance produced by the operation.
    • updateAclTokenAndForget

      @Deprecated public ConsulClient updateAclTokenAndForget(io.vertx.ext.consul.AclToken token)
      Variant of io.vertx.mutiny.ext.consul.ConsulClient#updateAclToken(AclToken) that ignores the result of the operation.

      This method subscribes on the result of io.vertx.mutiny.ext.consul.ConsulClient#updateAclToken(AclToken), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.ext.consul.ConsulClient#updateAclToken(AclToken) but you don't need to compose it with other operations.

      Parameters:
      token - properties of the token to be updated
      Returns:
      the instance of ConsulClient to chain method calls.
    • cloneAclToken

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<String> cloneAclToken(String id)
      Clone Acl token

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

      Parameters:
      id - the ID of token to be cloned
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • cloneAclTokenAndAwait

      @Deprecated public String cloneAclTokenAndAwait(String id)
      Blocking variant of cloneAclToken(String).

      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:
      id - the ID of token to be cloned
      Returns:
      the String instance produced by the operation.
    • cloneAclTokenAndForget

      @Deprecated public ConsulClient cloneAclTokenAndForget(String id)
      Variant of cloneAclToken(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of token to be cloned
      Returns:
      the instance of ConsulClient to chain method calls.
    • listAclTokens

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.AclToken>> listAclTokens()
      Deprecated.
      Use getAclTokens() instead
      Get list of Acl token

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

      @Deprecated public List<io.vertx.ext.consul.AclToken> listAclTokensAndAwait()
      Deprecated.
      Use getAclTokens() instead
      Blocking variant of listAclTokens().

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

      @Deprecated public ConsulClient listAclTokensAndForget()
      Deprecated.
      Use getAclTokens() instead
      Variant of listAclTokens() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • infoAclToken

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<io.vertx.ext.consul.AclToken> infoAclToken(String id)
      Deprecated.
      Get info of Acl token

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

      Parameters:
      id - the ID of token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • infoAclTokenAndAwait

      @Deprecated public io.vertx.ext.consul.AclToken infoAclTokenAndAwait(String id)
      Deprecated.
      Blocking variant of infoAclToken(String).

      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:
      id - the ID of token
      Returns:
      the AclToken instance produced by the operation.
    • infoAclTokenAndForget

      @Deprecated public ConsulClient infoAclTokenAndForget(String id)
      Deprecated.
      Variant of infoAclToken(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of token
      Returns:
      the instance of ConsulClient to chain method calls.
    • destroyAclToken

      @CheckReturnValue @Deprecated public io.smallrye.mutiny.Uni<Void> destroyAclToken(String id)
      Deprecated.
      Destroy Acl token

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

      Parameters:
      id - the ID of token
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • destroyAclTokenAndAwait

      @Deprecated public Void destroyAclTokenAndAwait(String id)
      Deprecated.
      Blocking variant of destroyAclToken(String).

      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:
      id - the ID of token
      Returns:
      the Void instance produced by the operation.
    • destroyAclTokenAndForget

      @Deprecated public ConsulClient destroyAclTokenAndForget(String id)
      Deprecated.
      Variant of destroyAclToken(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of token
      Returns:
      the instance of ConsulClient to chain method calls.
    • fireEvent

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Event> fireEvent(String name)
      Fires a new user event

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

      Parameters:
      name - name of event
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • fireEventAndAwait

      public io.vertx.ext.consul.Event fireEventAndAwait(String name)
      Blocking variant of fireEvent(String).

      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:
      name - name of event
      Returns:
      the Event instance produced by the operation.
    • fireEventAndForget

      public ConsulClient fireEventAndForget(String name)
      Variant of fireEvent(String) that ignores the result of the operation.

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

      Parameters:
      name - name of event
      Returns:
      the instance of ConsulClient to chain method calls.
    • fireEventWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Event> fireEventWithOptions(String name, io.vertx.ext.consul.EventOptions options)
      Fires a new user event

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

      Parameters:
      name - name of event
      options - options used to create event
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • fireEventWithOptionsAndAwait

      public io.vertx.ext.consul.Event fireEventWithOptionsAndAwait(String name, io.vertx.ext.consul.EventOptions options)
      Blocking variant of fireEventWithOptions(String,EventOptions).

      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:
      name - name of event
      options - options used to create event
      Returns:
      the Event instance produced by the operation.
    • fireEventWithOptionsAndForget

      public ConsulClient fireEventWithOptionsAndForget(String name, io.vertx.ext.consul.EventOptions options)
      Variant of fireEventWithOptions(String,EventOptions) that ignores the result of the operation.

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

      Parameters:
      name - name of event
      options - options used to create event
      Returns:
      the instance of ConsulClient to chain method calls.
    • listEvents

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.EventList> listEvents()
      Returns the most recent events known by the agent

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

      public io.vertx.ext.consul.EventList listEventsAndAwait()
      Blocking variant of listEvents().

      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 EventList instance produced by the operation.
    • listEventsAndForget

      public ConsulClient listEventsAndForget()
      Variant of listEvents() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • listEventsWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.EventList> listEventsWithOptions(io.vertx.ext.consul.EventListOptions options)
      Returns the most recent events known by the agent. This is blocking query unlike listEvents(). However, the semantics of this endpoint are slightly different. Most blocking queries provide a monotonic index and block until a newer index is available. This can be supported as a consequence of the total ordering of the consensus protocol. With gossip, there is no ordering, and instead X-Consul-Index maps to the newest event that matches the query.

      In practice, this means the index is only useful when used against a single agent and has no meaning globally. Because Consul defines the index as being opaque, clients should not be expecting a natural ordering either.

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

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

      public io.vertx.ext.consul.EventList listEventsWithOptionsAndAwait(io.vertx.ext.consul.EventListOptions options)
      Blocking variant of listEventsWithOptions(EventListOptions).

      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 - the blocking options
      Returns:
      the EventList instance produced by the operation.
    • listEventsWithOptionsAndForget

      public ConsulClient listEventsWithOptionsAndForget(io.vertx.ext.consul.EventListOptions options)
      Variant of listEventsWithOptions(EventListOptions) that ignores the result of the operation.

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

      Parameters:
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • registerService

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> registerService(io.vertx.ext.consul.ServiceOptions serviceOptions)
      Adds a new service, with an optional health check, to the local agent.

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

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

      public Void registerServiceAndAwait(io.vertx.ext.consul.ServiceOptions serviceOptions)
      Blocking variant of registerService(ServiceOptions).

      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:
      serviceOptions - the options of new service
      Returns:
      the Void instance produced by the operation.
    • registerServiceAndForget

      public ConsulClient registerServiceAndForget(io.vertx.ext.consul.ServiceOptions serviceOptions)
      Variant of registerService(ServiceOptions) that ignores the result of the operation.

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

      Parameters:
      serviceOptions - the options of new service
      Returns:
      the instance of ConsulClient to chain method calls.
    • maintenanceService

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> maintenanceService(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
      Places a given service into "maintenance mode"

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

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

      public Void maintenanceServiceAndAwait(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
      Blocking variant of maintenanceService(MaintenanceOptions).

      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:
      maintenanceOptions - the maintenance options
      Returns:
      the Void instance produced by the operation.
    • maintenanceServiceAndForget

      public ConsulClient maintenanceServiceAndForget(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
      Variant of maintenanceService(MaintenanceOptions) that ignores the result of the operation.

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

      Parameters:
      maintenanceOptions - the maintenance options
      Returns:
      the instance of ConsulClient to chain method calls.
    • deregisterService

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deregisterService(String id)
      Remove a service from the local agent. The agent will take care of deregistering the service with the Catalog. If there is an associated check, that is also deregistered.

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

      Parameters:
      id - the ID of service
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deregisterServiceAndAwait

      public Void deregisterServiceAndAwait(String id)
      Blocking variant of deregisterService(String).

      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:
      id - the ID of service
      Returns:
      the Void instance produced by the operation.
    • deregisterServiceAndForget

      public ConsulClient deregisterServiceAndForget(String id)
      Variant of deregisterService(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of service
      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogServiceNodes

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServiceNodes(String service)
      Returns the nodes providing a service

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

      Parameters:
      service - name of service
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • catalogServiceNodesAndAwait

      public io.vertx.ext.consul.ServiceList catalogServiceNodesAndAwait(String service)
      Blocking variant of catalogServiceNodes(String).

      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:
      service - name of service
      Returns:
      the ServiceList instance produced by the operation.
    • catalogServiceNodesAndForget

      public ConsulClient catalogServiceNodesAndForget(String service)
      Variant of catalogServiceNodes(String) that ignores the result of the operation.

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

      Parameters:
      service - name of service
      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogServiceNodesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServiceNodesWithOptions(String service, io.vertx.ext.consul.ServiceQueryOptions options)
      Returns the nodes providing a service

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

      Parameters:
      service - name of service
      options - options used to request services
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • catalogServiceNodesWithOptionsAndAwait

      public io.vertx.ext.consul.ServiceList catalogServiceNodesWithOptionsAndAwait(String service, io.vertx.ext.consul.ServiceQueryOptions options)
      Blocking variant of catalogServiceNodesWithOptions(String,ServiceQueryOptions).

      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:
      service - name of service
      options - options used to request services
      Returns:
      the ServiceList instance produced by the operation.
    • catalogServiceNodesWithOptionsAndForget

      public ConsulClient catalogServiceNodesWithOptionsAndForget(String service, io.vertx.ext.consul.ServiceQueryOptions options)
      Variant of catalogServiceNodesWithOptions(String,ServiceQueryOptions) that ignores the result of the operation.

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

      Parameters:
      service - name of service
      options - options used to request services
      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogDatacenters

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> catalogDatacenters()
      Return all the datacenters that are known by the Consul server

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

      public List<String> catalogDatacentersAndAwait()
      Blocking variant of catalogDatacenters().

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

      public ConsulClient catalogDatacentersAndForget()
      Variant of catalogDatacenters() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogNodes

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.NodeList> catalogNodes()
      Returns the nodes registered in a datacenter

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

      public io.vertx.ext.consul.NodeList catalogNodesAndAwait()
      Blocking variant of catalogNodes().

      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 NodeList instance produced by the operation.
    • catalogNodesAndForget

      public ConsulClient catalogNodesAndForget()
      Variant of catalogNodes() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogNodesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.NodeList> catalogNodesWithOptions(io.vertx.ext.consul.NodeQueryOptions options)
      Returns the nodes registered in a datacenter

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

      Parameters:
      options - options used to request nodes
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • catalogNodesWithOptionsAndAwait

      public io.vertx.ext.consul.NodeList catalogNodesWithOptionsAndAwait(io.vertx.ext.consul.NodeQueryOptions options)
      Blocking variant of catalogNodesWithOptions(NodeQueryOptions).

      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 - options used to request nodes
      Returns:
      the NodeList instance produced by the operation.
    • catalogNodesWithOptionsAndForget

      public ConsulClient catalogNodesWithOptionsAndForget(io.vertx.ext.consul.NodeQueryOptions options)
      Variant of catalogNodesWithOptions(NodeQueryOptions) that ignores the result of the operation.

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

      Parameters:
      options - options used to request nodes
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthChecks

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthChecks(String service)
      Returns the checks associated with the service

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

      Parameters:
      service - the service name
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthChecksAndAwait

      public io.vertx.ext.consul.CheckList healthChecksAndAwait(String service)
      Blocking variant of healthChecks(String).

      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:
      service - the service name
      Returns:
      the CheckList instance produced by the operation.
    • healthChecksAndForget

      public ConsulClient healthChecksAndForget(String service)
      Variant of healthChecks(String) that ignores the result of the operation.

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

      Parameters:
      service - the service name
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthChecksWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthChecksWithOptions(String service, io.vertx.ext.consul.CheckQueryOptions options)
      Returns the checks associated with the service

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

      Parameters:
      service - the service name
      options - options used to request checks
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthChecksWithOptionsAndAwait

      public io.vertx.ext.consul.CheckList healthChecksWithOptionsAndAwait(String service, io.vertx.ext.consul.CheckQueryOptions options)
      Blocking variant of healthChecksWithOptions(String,CheckQueryOptions).

      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:
      service - the service name
      options - options used to request checks
      Returns:
      the CheckList instance produced by the operation.
    • healthChecksWithOptionsAndForget

      public ConsulClient healthChecksWithOptionsAndForget(String service, io.vertx.ext.consul.CheckQueryOptions options)
      Variant of healthChecksWithOptions(String,CheckQueryOptions) that ignores the result of the operation.

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

      Parameters:
      service - the service name
      options - options used to request checks
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthState

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthState(io.vertx.ext.consul.HealthState healthState)
      Returns the checks in the specified status

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

      Parameters:
      healthState - the health state
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthStateAndAwait

      public io.vertx.ext.consul.CheckList healthStateAndAwait(io.vertx.ext.consul.HealthState healthState)
      Blocking variant of healthState(HealthState).

      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:
      healthState - the health state
      Returns:
      the CheckList instance produced by the operation.
    • healthStateAndForget

      public ConsulClient healthStateAndForget(io.vertx.ext.consul.HealthState healthState)
      Variant of healthState(HealthState) that ignores the result of the operation.

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

      Parameters:
      healthState - the health state
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthStateWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthStateWithOptions(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options)
      Returns the checks in the specified status

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

      Parameters:
      healthState - the health state
      options - options used to request checks
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthStateWithOptionsAndAwait

      public io.vertx.ext.consul.CheckList healthStateWithOptionsAndAwait(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options)
      Blocking variant of healthStateWithOptions(HealthState,CheckQueryOptions).

      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:
      healthState - the health state
      options - options used to request checks
      Returns:
      the CheckList instance produced by the operation.
    • healthStateWithOptionsAndForget

      public ConsulClient healthStateWithOptionsAndForget(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options)
      Variant of healthStateWithOptions(HealthState,CheckQueryOptions) that ignores the result of the operation.

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

      Parameters:
      healthState - the health state
      options - options used to request checks
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthServiceNodes

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceEntryList> healthServiceNodes(String service, boolean passing)
      Returns the nodes providing the service. This endpoint is very similar to the catalogServiceNodes(java.lang.String) endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.

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

      Parameters:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthServiceNodesAndAwait

      public io.vertx.ext.consul.ServiceEntryList healthServiceNodesAndAwait(String service, boolean passing)
      Blocking variant of healthServiceNodes(String,boolean).

      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:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      Returns:
      the ServiceEntryList instance produced by the operation.
    • healthServiceNodesAndForget

      public ConsulClient healthServiceNodesAndForget(String service, boolean passing)
      Variant of healthServiceNodes(String,boolean) that ignores the result of the operation.

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

      Parameters:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthServiceNodesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceEntryList> healthServiceNodesWithOptions(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options)
      Returns the nodes providing the service. This endpoint is very similar to the catalogServiceNodesWithOptions(java.lang.String, io.vertx.ext.consul.ServiceQueryOptions) endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.

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

      Parameters:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      options - options used to request services
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthServiceNodesWithOptionsAndAwait

      public io.vertx.ext.consul.ServiceEntryList healthServiceNodesWithOptionsAndAwait(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options)
      Blocking variant of healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions).

      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:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      options - options used to request services
      Returns:
      the ServiceEntryList instance produced by the operation.
    • healthServiceNodesWithOptionsAndForget

      public ConsulClient healthServiceNodesWithOptionsAndForget(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options)
      Variant of healthServiceNodesWithOptions(String,boolean,ServiceQueryOptions) that ignores the result of the operation.

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

      Parameters:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      options - options used to request services
      Returns:
      the instance of ConsulClient to chain method calls.
    • healthNodesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.CheckList> healthNodesWithOptions(String node, io.vertx.ext.consul.CheckQueryOptions options)
      Returns the checks specific to the node provided on the path.

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

      Parameters:
      node - the node name or ID
      options - options used to request node health checks
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • healthNodesWithOptionsAndAwait

      public io.vertx.ext.consul.CheckList healthNodesWithOptionsAndAwait(String node, io.vertx.ext.consul.CheckQueryOptions options)
      Blocking variant of healthNodesWithOptions(String,CheckQueryOptions).

      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:
      node - the node name or ID
      options - options used to request node health checks
      Returns:
      the CheckList instance produced by the operation.
    • healthNodesWithOptionsAndForget

      public ConsulClient healthNodesWithOptionsAndForget(String node, io.vertx.ext.consul.CheckQueryOptions options)
      Variant of healthNodesWithOptions(String,CheckQueryOptions) that ignores the result of the operation.

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

      Parameters:
      node - the node name or ID
      options - options used to request node health checks
      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogServices

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServices()
      Returns the services registered in a datacenter

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

      public io.vertx.ext.consul.ServiceList catalogServicesAndAwait()
      Blocking variant of catalogServices().

      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 ServiceList instance produced by the operation.
    • catalogServicesAndForget

      public ConsulClient catalogServicesAndForget()
      Variant of catalogServices() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogServicesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogServicesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the services registered in a datacenter This is blocking query unlike catalogServices()

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

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

      public io.vertx.ext.consul.ServiceList catalogServicesWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of catalogServicesWithOptions(BlockingQueryOptions).

      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 - the blocking options
      Returns:
      the ServiceList instance produced by the operation.
    • catalogServicesWithOptionsAndForget

      public ConsulClient catalogServicesWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of catalogServicesWithOptions(BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogNodeServices

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogNodeServices(String node)
      Returns the node's registered services

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

      Parameters:
      node - node name
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • catalogNodeServicesAndAwait

      public io.vertx.ext.consul.ServiceList catalogNodeServicesAndAwait(String node)
      Blocking variant of catalogNodeServices(String).

      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:
      node - node name
      Returns:
      the ServiceList instance produced by the operation.
    • catalogNodeServicesAndForget

      public ConsulClient catalogNodeServicesAndForget(String node)
      Variant of catalogNodeServices(String) that ignores the result of the operation.

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

      Parameters:
      node - node name
      Returns:
      the instance of ConsulClient to chain method calls.
    • catalogNodeServicesWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.ServiceList> catalogNodeServicesWithOptions(String node, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the node's registered services This is blocking query unlike catalogNodeServices(java.lang.String)

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

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

      public io.vertx.ext.consul.ServiceList catalogNodeServicesWithOptionsAndAwait(String node, io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of catalogNodeServicesWithOptions(String,BlockingQueryOptions).

      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:
      node - node name
      options - the blocking options
      Returns:
      the ServiceList instance produced by the operation.
    • catalogNodeServicesWithOptionsAndForget

      public ConsulClient catalogNodeServicesWithOptionsAndForget(String node, io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of catalogNodeServicesWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      node - node name
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • localServices

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.Service>> localServices()
      Returns list of services registered with the local agent.

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

      public List<io.vertx.ext.consul.Service> localServicesAndAwait()
      Blocking variant of localServices().

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

      public ConsulClient localServicesAndForget()
      Variant of localServices() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • localChecks

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.Check>> localChecks()
      Return all the checks that are registered with the local agent.

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

      public List<io.vertx.ext.consul.Check> localChecksAndAwait()
      Blocking variant of localChecks().

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

      public ConsulClient localChecksAndForget()
      Variant of localChecks() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • registerCheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> registerCheck(io.vertx.ext.consul.CheckOptions checkOptions)
      Add a new check to the local agent. The agent is responsible for managing the status of the check and keeping the Catalog in sync.

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

      Parameters:
      checkOptions - options used to register new check
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • registerCheckAndAwait

      public Void registerCheckAndAwait(io.vertx.ext.consul.CheckOptions checkOptions)
      Blocking variant of registerCheck(CheckOptions).

      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:
      checkOptions - options used to register new check
      Returns:
      the Void instance produced by the operation.
    • registerCheckAndForget

      public ConsulClient registerCheckAndForget(io.vertx.ext.consul.CheckOptions checkOptions)
      Variant of registerCheck(CheckOptions) that ignores the result of the operation.

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

      Parameters:
      checkOptions - options used to register new check
      Returns:
      the instance of ConsulClient to chain method calls.
    • deregisterCheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deregisterCheck(String checkId)
      Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deregisterCheckAndAwait

      public Void deregisterCheckAndAwait(String checkId)
      Blocking variant of deregisterCheck(String).

      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:
      checkId - the ID of check
      Returns:
      the Void instance produced by the operation.
    • deregisterCheckAndForget

      public ConsulClient deregisterCheckAndForget(String checkId)
      Variant of deregisterCheck(String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the instance of ConsulClient to chain method calls.
    • passCheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> passCheck(String checkId)
      Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • passCheckAndAwait

      public Void passCheckAndAwait(String checkId)
      Blocking variant of passCheck(String).

      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:
      checkId - the ID of check
      Returns:
      the Void instance produced by the operation.
    • passCheckAndForget

      public ConsulClient passCheckAndForget(String checkId)
      Variant of passCheck(String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the instance of ConsulClient to chain method calls.
    • passCheckWithNote

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> passCheckWithNote(String checkId, String note)
      Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • passCheckWithNoteAndAwait

      public Void passCheckWithNoteAndAwait(String checkId, String note)
      Blocking variant of passCheckWithNote(String,String).

      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:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the Void instance produced by the operation.
    • passCheckWithNoteAndForget

      public ConsulClient passCheckWithNoteAndForget(String checkId, String note)
      Variant of passCheckWithNote(String,String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the instance of ConsulClient to chain method calls.
    • warnCheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> warnCheck(String checkId)
      Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • warnCheckAndAwait

      public Void warnCheckAndAwait(String checkId)
      Blocking variant of warnCheck(String).

      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:
      checkId - the ID of check
      Returns:
      the Void instance produced by the operation.
    • warnCheckAndForget

      public ConsulClient warnCheckAndForget(String checkId)
      Variant of warnCheck(String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the instance of ConsulClient to chain method calls.
    • warnCheckWithNote

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> warnCheckWithNote(String checkId, String note)
      Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • warnCheckWithNoteAndAwait

      public Void warnCheckWithNoteAndAwait(String checkId, String note)
      Blocking variant of warnCheckWithNote(String,String).

      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:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the Void instance produced by the operation.
    • warnCheckWithNoteAndForget

      public ConsulClient warnCheckWithNoteAndForget(String checkId, String note)
      Variant of warnCheckWithNote(String,String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the instance of ConsulClient to chain method calls.
    • failCheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> failCheck(String checkId)
      Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • failCheckAndAwait

      public Void failCheckAndAwait(String checkId)
      Blocking variant of failCheck(String).

      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:
      checkId - the ID of check
      Returns:
      the Void instance produced by the operation.
    • failCheckAndForget

      public ConsulClient failCheckAndForget(String checkId)
      Variant of failCheck(String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      Returns:
      the instance of ConsulClient to chain method calls.
    • failCheckWithNote

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> failCheckWithNote(String checkId, String note)
      Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • failCheckWithNoteAndAwait

      public Void failCheckWithNoteAndAwait(String checkId, String note)
      Blocking variant of failCheckWithNote(String,String).

      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:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the Void instance produced by the operation.
    • failCheckWithNoteAndForget

      public ConsulClient failCheckWithNoteAndForget(String checkId, String note)
      Variant of failCheckWithNote(String,String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the instance of ConsulClient to chain method calls.
    • updateCheck

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> updateCheck(String checkId, io.vertx.ext.consul.CheckStatus status)
      Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      status - new status of check
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateCheckAndAwait

      public Void updateCheckAndAwait(String checkId, io.vertx.ext.consul.CheckStatus status)
      Blocking variant of updateCheck(String,CheckStatus).

      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:
      checkId - the ID of check
      status - new status of check
      Returns:
      the Void instance produced by the operation.
    • updateCheckAndForget

      public ConsulClient updateCheckAndForget(String checkId, io.vertx.ext.consul.CheckStatus status)
      Variant of updateCheck(String,CheckStatus) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      status - new status of check
      Returns:
      the instance of ConsulClient to chain method calls.
    • updateCheckWithNote

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> updateCheckWithNote(String checkId, io.vertx.ext.consul.CheckStatus status, String note)
      Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.

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

      Parameters:
      checkId - the ID of check
      status - new status of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updateCheckWithNoteAndAwait

      public Void updateCheckWithNoteAndAwait(String checkId, io.vertx.ext.consul.CheckStatus status, String note)
      Blocking variant of updateCheckWithNote(String,CheckStatus,String).

      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:
      checkId - the ID of check
      status - new status of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the Void instance produced by the operation.
    • updateCheckWithNoteAndForget

      public ConsulClient updateCheckWithNoteAndForget(String checkId, io.vertx.ext.consul.CheckStatus status, String note)
      Variant of updateCheckWithNote(String,CheckStatus,String) that ignores the result of the operation.

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

      Parameters:
      checkId - the ID of check
      status - new status of check
      note - specifies a human-readable message. This will be passed through to the check's Output field.
      Returns:
      the instance of ConsulClient to chain method calls.
    • leaderStatus

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> leaderStatus()
      Get the Raft leader for the datacenter in which the agent is running. It returns an address in format "10.1.10.12:8300"

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

      public String leaderStatusAndAwait()
      Blocking variant of leaderStatus().

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

      public ConsulClient leaderStatusAndForget()
      Variant of leaderStatus() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • peersStatus

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<String>> peersStatus()
      Retrieves the Raft peers for the datacenter in which the the agent is running. It returns a list of addresses "10.1.10.12:8300", "10.1.10.13:8300"

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

      public List<String> peersStatusAndAwait()
      Blocking variant of peersStatus().

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

      public ConsulClient peersStatusAndForget()
      Variant of peersStatus() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • createSession

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> createSession()
      Initialize a new session

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

      public String createSessionAndAwait()
      Blocking variant of createSession().

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

      public ConsulClient createSessionAndForget()
      Variant of createSession() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • createSessionWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> createSessionWithOptions(io.vertx.ext.consul.SessionOptions options)
      Initialize a new session

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

      Parameters:
      options - options used to create session
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createSessionWithOptionsAndAwait

      public String createSessionWithOptionsAndAwait(io.vertx.ext.consul.SessionOptions options)
      Blocking variant of createSessionWithOptions(SessionOptions).

      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 - options used to create session
      Returns:
      the String instance produced by the operation.
    • createSessionWithOptionsAndForget

      public ConsulClient createSessionWithOptionsAndForget(io.vertx.ext.consul.SessionOptions options)
      Variant of createSessionWithOptions(SessionOptions) that ignores the result of the operation.

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

      Parameters:
      options - options used to create session
      Returns:
      the instance of ConsulClient to chain method calls.
    • infoSession

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session> infoSession(String id)
      Returns the requested session information

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

      Parameters:
      id - the ID of requested session
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • infoSessionAndAwait

      public io.vertx.ext.consul.Session infoSessionAndAwait(String id)
      Blocking variant of infoSession(String).

      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:
      id - the ID of requested session
      Returns:
      the Session instance produced by the operation.
    • infoSessionAndForget

      public ConsulClient infoSessionAndForget(String id)
      Variant of infoSession(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of requested session
      Returns:
      the instance of ConsulClient to chain method calls.
    • infoSessionWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session> infoSessionWithOptions(String id, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the requested session information This is blocking query unlike infoSession(java.lang.String)

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

      Parameters:
      id - the ID of requested session
      options - the blocking options
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • infoSessionWithOptionsAndAwait

      public io.vertx.ext.consul.Session infoSessionWithOptionsAndAwait(String id, io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of infoSessionWithOptions(String,BlockingQueryOptions).

      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:
      id - the ID of requested session
      options - the blocking options
      Returns:
      the Session instance produced by the operation.
    • infoSessionWithOptionsAndForget

      public ConsulClient infoSessionWithOptionsAndForget(String id, io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of infoSessionWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      id - the ID of requested session
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • renewSession

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.Session> renewSession(String id)
      Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL

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

      Parameters:
      id - the ID of session that should be renewed
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • renewSessionAndAwait

      public io.vertx.ext.consul.Session renewSessionAndAwait(String id)
      Blocking variant of renewSession(String).

      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:
      id - the ID of session that should be renewed
      Returns:
      the Session instance produced by the operation.
    • renewSessionAndForget

      public ConsulClient renewSessionAndForget(String id)
      Variant of renewSession(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of session that should be renewed
      Returns:
      the instance of ConsulClient to chain method calls.
    • listSessions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listSessions()
      Returns the active sessions

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

      public io.vertx.ext.consul.SessionList listSessionsAndAwait()
      Blocking variant of listSessions().

      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 SessionList instance produced by the operation.
    • listSessionsAndForget

      public ConsulClient listSessionsAndForget()
      Variant of listSessions() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • listSessionsWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listSessionsWithOptions(io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the active sessions This is blocking query unlike listSessions()

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

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

      public io.vertx.ext.consul.SessionList listSessionsWithOptionsAndAwait(io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of listSessionsWithOptions(BlockingQueryOptions).

      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 - the blocking options
      Returns:
      the SessionList instance produced by the operation.
    • listSessionsWithOptionsAndForget

      public ConsulClient listSessionsWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of listSessionsWithOptions(BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • listNodeSessions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listNodeSessions(String nodeId)
      Returns the active sessions for a given node

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

      Parameters:
      nodeId - the ID of node
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • listNodeSessionsAndAwait

      public io.vertx.ext.consul.SessionList listNodeSessionsAndAwait(String nodeId)
      Blocking variant of listNodeSessions(String).

      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:
      nodeId - the ID of node
      Returns:
      the SessionList instance produced by the operation.
    • listNodeSessionsAndForget

      public ConsulClient listNodeSessionsAndForget(String nodeId)
      Variant of listNodeSessions(String) that ignores the result of the operation.

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

      Parameters:
      nodeId - the ID of node
      Returns:
      the instance of ConsulClient to chain method calls.
    • listNodeSessionsWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.SessionList> listNodeSessionsWithOptions(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the active sessions for a given node This is blocking query unlike listNodeSessions(java.lang.String)

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

      Parameters:
      nodeId - the ID of node
      options - the blocking options
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • listNodeSessionsWithOptionsAndAwait

      public io.vertx.ext.consul.SessionList listNodeSessionsWithOptionsAndAwait(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)
      Blocking variant of listNodeSessionsWithOptions(String,BlockingQueryOptions).

      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:
      nodeId - the ID of node
      options - the blocking options
      Returns:
      the SessionList instance produced by the operation.
    • listNodeSessionsWithOptionsAndForget

      public ConsulClient listNodeSessionsWithOptionsAndForget(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)
      Variant of listNodeSessionsWithOptions(String,BlockingQueryOptions) that ignores the result of the operation.

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

      Parameters:
      nodeId - the ID of node
      options - the blocking options
      Returns:
      the instance of ConsulClient to chain method calls.
    • destroySession

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> destroySession(String id)
      Destroys the given session

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

      Parameters:
      id - the ID of session
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • destroySessionAndAwait

      public Void destroySessionAndAwait(String id)
      Blocking variant of destroySession(String).

      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:
      id - the ID of session
      Returns:
      the Void instance produced by the operation.
    • destroySessionAndForget

      public ConsulClient destroySessionAndForget(String id)
      Variant of destroySession(String) that ignores the result of the operation.

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

      Parameters:
      id - the ID of session
      Returns:
      the instance of ConsulClient to chain method calls.
    • createPreparedQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> createPreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition)

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

      Parameters:
      definition - definition of the prepare query
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • createPreparedQueryAndAwait

      public String createPreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)
      Blocking variant of createPreparedQuery(PreparedQueryDefinition).

      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:
      definition - definition of the prepare query
      Returns:
      the String instance produced by the operation.
    • createPreparedQueryAndForget

      public ConsulClient createPreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)
      Variant of createPreparedQuery(PreparedQueryDefinition) that ignores the result of the operation.

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

      Parameters:
      definition - definition of the prepare query
      Returns:
      the instance of ConsulClient to chain method calls.
    • getPreparedQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryDefinition> getPreparedQuery(String id)
      Returns an existing prepared query

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

      Parameters:
      id - the id of the query to read
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • getPreparedQueryAndAwait

      public io.vertx.ext.consul.PreparedQueryDefinition getPreparedQueryAndAwait(String id)
      Blocking variant of getPreparedQuery(String).

      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:
      id - the id of the query to read
      Returns:
      the PreparedQueryDefinition instance produced by the operation.
    • getPreparedQueryAndForget

      public ConsulClient getPreparedQueryAndForget(String id)
      Variant of getPreparedQuery(String) that ignores the result of the operation.

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

      Parameters:
      id - the id of the query to read
      Returns:
      the instance of ConsulClient to chain method calls.
    • getAllPreparedQueries

      @CheckReturnValue public io.smallrye.mutiny.Uni<List<io.vertx.ext.consul.PreparedQueryDefinition>> getAllPreparedQueries()
      Returns a list of all prepared queries.

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

      public List<io.vertx.ext.consul.PreparedQueryDefinition> getAllPreparedQueriesAndAwait()
      Blocking variant of getAllPreparedQueries().

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

      public ConsulClient getAllPreparedQueriesAndForget()
      Variant of getAllPreparedQueries() that ignores the result of the operation.

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

      Returns:
      the instance of ConsulClient to chain method calls.
    • updatePreparedQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> updatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition)

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

      Parameters:
      definition - definition of the prepare query
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • updatePreparedQueryAndAwait

      public Void updatePreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)
      Blocking variant of updatePreparedQuery(PreparedQueryDefinition).

      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:
      definition - definition of the prepare query
      Returns:
      the Void instance produced by the operation.
    • updatePreparedQueryAndForget

      public ConsulClient updatePreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)
      Variant of updatePreparedQuery(PreparedQueryDefinition) that ignores the result of the operation.

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

      Parameters:
      definition - definition of the prepare query
      Returns:
      the instance of ConsulClient to chain method calls.
    • deletePreparedQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deletePreparedQuery(String id)
      Deletes an existing prepared query

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

      Parameters:
      id - the id of the query to delete
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deletePreparedQueryAndAwait

      public Void deletePreparedQueryAndAwait(String id)
      Blocking variant of deletePreparedQuery(String).

      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:
      id - the id of the query to delete
      Returns:
      the Void instance produced by the operation.
    • deletePreparedQueryAndForget

      public ConsulClient deletePreparedQueryAndForget(String id)
      Variant of deletePreparedQuery(String) that ignores the result of the operation.

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

      Parameters:
      id - the id of the query to delete
      Returns:
      the instance of ConsulClient to chain method calls.
    • executePreparedQuery

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryExecuteResponse> executePreparedQuery(String query)
      Executes an existing prepared query.

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

      Parameters:
      query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • executePreparedQueryAndAwait

      public io.vertx.ext.consul.PreparedQueryExecuteResponse executePreparedQueryAndAwait(String query)
      Blocking variant of executePreparedQuery(String).

      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:
      query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
      Returns:
      the PreparedQueryExecuteResponse instance produced by the operation.
    • executePreparedQueryAndForget

      public ConsulClient executePreparedQueryAndForget(String query)
      Variant of executePreparedQuery(String) that ignores the result of the operation.

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

      Parameters:
      query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
      Returns:
      the instance of ConsulClient to chain method calls.
    • executePreparedQueryWithOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.PreparedQueryExecuteResponse> executePreparedQueryWithOptions(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)
      Executes an existing prepared query.

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

      Parameters:
      query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
      options - the options used to execute prepared query
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • executePreparedQueryWithOptionsAndAwait

      public io.vertx.ext.consul.PreparedQueryExecuteResponse executePreparedQueryWithOptionsAndAwait(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)
      Blocking variant of executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions).

      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:
      query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
      options - the options used to execute prepared query
      Returns:
      the PreparedQueryExecuteResponse instance produced by the operation.
    • executePreparedQueryWithOptionsAndForget

      public ConsulClient executePreparedQueryWithOptionsAndForget(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)
      Variant of executePreparedQueryWithOptions(String,PreparedQueryExecuteOptions) that ignores the result of the operation.

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

      Parameters:
      query - the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.
      options - the options used to execute prepared query
      Returns:
      the instance of ConsulClient to chain method calls.
    • registerCatalogService

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> registerCatalogService(io.vertx.ext.consul.Node nodeOptions, io.vertx.ext.consul.ServiceOptions serviceOptions)
      Register node with external service

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

      Parameters:
      nodeOptions - the options of new node
      serviceOptions - the options of new service
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • registerCatalogServiceAndAwait

      public Void registerCatalogServiceAndAwait(io.vertx.ext.consul.Node nodeOptions, io.vertx.ext.consul.ServiceOptions serviceOptions)
      Blocking variant of registerCatalogService(Node,ServiceOptions).

      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:
      nodeOptions - the options of new node
      serviceOptions - the options of new service
      Returns:
      the Void instance produced by the operation.
    • registerCatalogServiceAndForget

      public ConsulClient registerCatalogServiceAndForget(io.vertx.ext.consul.Node nodeOptions, io.vertx.ext.consul.ServiceOptions serviceOptions)
      Variant of registerCatalogService(Node,ServiceOptions) that ignores the result of the operation.

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

      Parameters:
      nodeOptions - the options of new node
      serviceOptions - the options of new service
      Returns:
      the instance of ConsulClient to chain method calls.
    • deregisterCatalogService

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> deregisterCatalogService(String nodeId, String serviceId)
      Deregister entities from the node or deregister the node itself.

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

      Parameters:
      nodeId - the ID of node
      serviceId - the ID of the service to de-registered; if it is null, the node itself will be de-registered (as well as the entities that belongs to that node)
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.
    • deregisterCatalogServiceAndAwait

      public Void deregisterCatalogServiceAndAwait(String nodeId, String serviceId)
      Blocking variant of deregisterCatalogService(String,String).

      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:
      nodeId - the ID of node
      serviceId - the ID of the service to de-registered; if it is null, the node itself will be de-registered (as well as the entities that belongs to that node)
      Returns:
      the Void instance produced by the operation.
    • deregisterCatalogServiceAndForget

      public ConsulClient deregisterCatalogServiceAndForget(String nodeId, String serviceId)
      Variant of deregisterCatalogService(String,String) that ignores the result of the operation.

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

      Parameters:
      nodeId - the ID of node
      serviceId - the ID of the service to de-registered; if it is null, the node itself will be de-registered (as well as the entities that belongs to that node)
      Returns:
      the instance of ConsulClient to chain method calls.
    • close

      public void close()
    • newInstance

      public static ConsulClient newInstance(io.vertx.ext.consul.ConsulClient arg)