Package io.vertx.mutiny.ext.consul

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.

Author:
Ruslan Sennov
See Also:
  • ConsulClient

  • Field Details

  • Constructor Details

    • ConsulClient

      public ConsulClient(io.vertx.ext.consul.ConsulClient delegate)
      Create a new instance of ConsulClient delegating to the given (non-null) instance of ConsulClient.

    • ConsulClient

      public ConsulClient(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.ext.consul.ConsulClient getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • agentInfoAndAwait

      public io.vertx.core.json.JsonObject agentInfoAndAwait()
      Returns the configuration and member information of the local agent

      Unlike the bare Vert.x variant, this method returns a JsonObject. This method awaits indefinitely 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 operation result
      See Also:

    • agentInfoAndForget

      public ConsulClient agentInfoAndForget()
      Returns the configuration and member information of the local agent

      Unlike the bare Vert.x variant, this method ignores the JsonObject result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • coordinateNodesAndAwait

      public io.vertx.ext.consul.CoordinateList coordinateNodesAndAwait()
      Returns the LAN network coordinates for all nodes in a given DC

      Unlike the bare Vert.x variant, this method returns a CoordinateList. This method awaits indefinitely 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 operation result
      See Also:

    • coordinateNodesAndForget

      public ConsulClient coordinateNodesAndForget()
      Returns the LAN network coordinates for all nodes in a given DC

      Unlike the bare Vert.x variant, this method ignores the CoordinateList result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • coordinateNodesWithOptionsAndAwait

      public io.vertx.ext.consul.CoordinateList coordinateNodesWithOptionsAndAwait(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 CoordinateList. This method awaits indefinitely 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 operation result
      See Also:

    • coordinateNodesWithOptionsAndForget

      public ConsulClient coordinateNodesWithOptionsAndForget(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 ignores the CoordinateList result or any failure.

      Parameters:
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • coordinateDatacentersAndAwait

      public List<io.vertx.ext.consul.DcCoordinates> coordinateDatacentersAndAwait()
      Returns the WAN network coordinates for all Consul servers, organized by DCs

      Unlike the bare Vert.x variant, this method returns a List<io.vertx.ext.consul.DcCoordinates>. This method awaits indefinitely 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 operation result
      See Also:

    • coordinateDatacentersAndForget

      public ConsulClient coordinateDatacentersAndForget()
      Returns the WAN network coordinates for all Consul servers, organized by DCs

      Unlike the bare Vert.x variant, this method ignores the List<io.vertx.ext.consul.DcCoordinates> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      keyPrefix - the prefix
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • getKeysAndAwait

      public List<String> getKeysAndAwait(String keyPrefix)
      Returns the list of keys that corresponding to the specified key prefix.

      Unlike the bare Vert.x variant, this method returns a List<String>. This method awaits indefinitely 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 operation result
      See Also:

    • getKeysAndForget

      public ConsulClient getKeysAndForget(String keyPrefix)
      Returns the list of keys that corresponding to the specified key prefix.

      Unlike the bare Vert.x variant, this method ignores the List<String> result or any failure.

      Parameters:
      keyPrefix - the prefix
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getKeysWithOptions(String, BlockingQueryOptions)

    • getKeysWithOptionsAndAwait

      public List<String> getKeysWithOptionsAndAwait(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 List<String>. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getKeysWithOptions(String, BlockingQueryOptions)

    • getKeysWithOptionsAndForget

      public ConsulClient getKeysWithOptionsAndForget(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 ignores the List<String> result or any failure.

      Parameters:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getKeysWithOptions(String, BlockingQueryOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      key - the key
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • getValueAndAwait

      public io.vertx.ext.consul.KeyValue getValueAndAwait(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 KeyValue. This method awaits indefinitely 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 operation result
      See Also:

    • getValueAndForget

      public ConsulClient getValueAndForget(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 ignores the KeyValue result or any failure.

      Parameters:
      key - the key
      Returns:
      The current instance to chain operations if needed.
      See Also:

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      key - the key
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getValueWithOptions(String, BlockingQueryOptions)

    • getValueWithOptionsAndAwait

      public io.vertx.ext.consul.KeyValue getValueWithOptionsAndAwait(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(String)

      Unlike the bare Vert.x variant, this method returns a KeyValue. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getValueWithOptions(String, BlockingQueryOptions)

    • getValueWithOptionsAndForget

      public ConsulClient getValueWithOptionsAndForget(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(String)

      Unlike the bare Vert.x variant, this method ignores the KeyValue result or any failure.

      Parameters:
      key - the key
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getValueWithOptions(String, BlockingQueryOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      key - the key
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.deleteValue(String)

    • deleteValueAndAwait

      public void deleteValueAndAwait(String key)
      Remove the key/value pair that corresponding to the specified key

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.deleteValue(String)

    • deleteValueAndForget

      public ConsulClient deleteValueAndForget(String key)
      Remove the key/value pair that corresponding to the specified key

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      key - the key
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.deleteValue(String)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      keyPrefix - the prefix
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • getValuesAndAwait

      public io.vertx.ext.consul.KeyValueList getValuesAndAwait(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 KeyValueList. This method awaits indefinitely 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 operation result
      See Also:

    • getValuesAndForget

      public ConsulClient getValuesAndForget(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 ignores the KeyValueList result or any failure.

      Parameters:
      keyPrefix - the prefix
      Returns:
      The current instance to chain operations if needed.
      See Also:

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getValuesWithOptions(String, BlockingQueryOptions)

    • getValuesWithOptionsAndAwait

      public io.vertx.ext.consul.KeyValueList getValuesWithOptionsAndAwait(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(String)

      Unlike the bare Vert.x variant, this method returns a KeyValueList. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getValuesWithOptions(String, BlockingQueryOptions)

    • getValuesWithOptionsAndForget

      public ConsulClient getValuesWithOptionsAndForget(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(String)

      Unlike the bare Vert.x variant, this method ignores the KeyValueList result or any failure.

      Parameters:
      keyPrefix - the prefix
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.getValuesWithOptions(String, BlockingQueryOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      keyPrefix - the prefix
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.deleteValues(String)

    • deleteValuesAndAwait

      public void deleteValuesAndAwait(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 Void. This method awaits indefinitely 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
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.deleteValues(String)

    • deleteValuesAndForget

      public ConsulClient deleteValuesAndForget(String keyPrefix)
      Removes all the key/value pair that corresponding to the specified key prefix

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      keyPrefix - the prefix
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.deleteValues(String)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      key - the key
      value - the value
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.putValue(String, String)

    • putValueAndAwait

      public Boolean putValueAndAwait(String key, String value)
      Adds specified key/value pair

      Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.putValue(String, String)

    • putValueAndForget

      public ConsulClient putValueAndForget(String key, String value)
      Adds specified key/value pair

      Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.

      Parameters:
      key - the key
      value - the value
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.putValue(String, String)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.putValueWithOptions(String, String, KeyValueOptions)

    • putValueWithOptionsAndAwait

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

      Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.putValueWithOptions(String, String, KeyValueOptions)

    • putValueWithOptionsAndForget

      public ConsulClient putValueWithOptionsAndForget(String key, String value, io.vertx.ext.consul.KeyValueOptions options)

      Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.

      Parameters:
      key - the key
      value - the value
      options - options used to push pair
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/kv/:key endpoint
      • ConsulClient.putValueWithOptions(String, String, KeyValueOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      request - transaction request
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/txn endpoint
      • ConsulClient.transaction(TxnRequest)

    • transactionAndAwait

      public io.vertx.ext.consul.TxnResponse transactionAndAwait(io.vertx.ext.consul.TxnRequest request)
      Manages multiple operations inside a single, atomic transaction.

      Unlike the bare Vert.x variant, this method returns a TxnResponse. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/txn endpoint
      • ConsulClient.transaction(TxnRequest)

    • transactionAndForget

      public ConsulClient transactionAndForget(io.vertx.ext.consul.TxnRequest request)
      Manages multiple operations inside a single, atomic transaction.

      Unlike the bare Vert.x variant, this method ignores the TxnResponse result or any failure.

      Parameters:
      request - transaction request
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/txn endpoint
      • ConsulClient.transaction(TxnRequest)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      policy - properties of policy
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • createAclPolicyAndAwait

      public String createAclPolicyAndAwait(io.vertx.ext.consul.policy.AclPolicy policy)
      Creates a new ACL policy

      Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely 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 operation result
      See Also:

    • createAclPolicyAndForget

      public ConsulClient createAclPolicyAndForget(io.vertx.ext.consul.policy.AclPolicy policy)
      Creates a new ACL policy

      Unlike the bare Vert.x variant, this method ignores the String result or any failure.

      Parameters:
      policy - properties of policy
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • readPolicy

      @CheckReturnValue public io.smallrye.mutiny.Uni<io.vertx.ext.consul.policy.AclPolicy> readPolicy(String id)

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • ConsulClient.readPolicy(String)

    • readPolicyAndAwait

      public io.vertx.ext.consul.policy.AclPolicy readPolicyAndAwait(String id)

      Unlike the bare Vert.x variant, this method returns a AclPolicy. This method awaits indefinitely 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 operation result
      See Also:
      • ConsulClient.readPolicy(String)

    • readPolicyAndForget

      public ConsulClient readPolicyAndForget(String id)

      Unlike the bare Vert.x variant, this method ignores the AclPolicy result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • ConsulClient.readPolicy(String)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      name - unique name of created policy
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • readPolicyByNameAndAwait

      public io.vertx.ext.consul.policy.AclPolicy readPolicyByNameAndAwait(String name)
      This endpoint reads an ACL policy with the given name

      Unlike the bare Vert.x variant, this method returns a AclPolicy. This method awaits indefinitely 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 operation result
      See Also:

    • readPolicyByNameAndForget

      public ConsulClient readPolicyByNameAndForget(String name)
      This endpoint reads an ACL policy with the given name

      Unlike the bare Vert.x variant, this method ignores the AclPolicy result or any failure.

      Parameters:
      name - unique name of created policy
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • updatePolicyAndAwait

      public io.vertx.ext.consul.policy.AclPolicy updatePolicyAndAwait(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 AclPolicy. This method awaits indefinitely 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 operation result
      See Also:

    • updatePolicyAndForget

      public ConsulClient updatePolicyAndForget(String id, io.vertx.ext.consul.policy.AclPolicy policy)
      This endpoint updates an existing ACL policy

      Unlike the bare Vert.x variant, this method ignores the AclPolicy result or any failure.

      Parameters:
      id - uuid of existing policy
      policy - options that will be applied to the existing policy
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - uuid of existing policy
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • deletePolicyAndAwait

      public Boolean deletePolicyAndAwait(String id)
      This endpoint deletes an ACL policy

      Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely 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 operation result
      See Also:

    • deletePolicyAndForget

      public ConsulClient deletePolicyAndForget(String id)
      This endpoint deletes an ACL policy

      Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.

      Parameters:
      id - uuid of existing policy
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • getAclPoliciesAndAwait

      public List<io.vertx.ext.consul.policy.AclPolicy> getAclPoliciesAndAwait()
      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 List<io.vertx.ext.consul.policy.AclPolicy>. This method awaits indefinitely 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 operation result
      See Also:

    • getAclPoliciesAndForget

      public ConsulClient getAclPoliciesAndForget()
      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 ignores the List<io.vertx.ext.consul.policy.AclPolicy> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      token - properties of the token
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • createAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken createAclTokenAndAwait(io.vertx.ext.consul.token.AclToken token)
      Create an Acl token

      Unlike the bare Vert.x variant, this method returns a AclToken. This method awaits indefinitely 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 operation result
      See Also:

    • createAclTokenAndForget

      public ConsulClient createAclTokenAndForget(io.vertx.ext.consul.token.AclToken token)
      Create an Acl token

      Unlike the bare Vert.x variant, this method ignores the AclToken result or any failure.

      Parameters:
      token - properties of the token
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      accessorId - uuid of the token
      token - properties of the token
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • updateAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken updateAclTokenAndAwait(String accessorId, io.vertx.ext.consul.token.AclToken token)
      Update an existing Acl token

      Unlike the bare Vert.x variant, this method returns a AclToken. This method awaits indefinitely 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 operation result
      See Also:

    • updateAclTokenAndForget

      public ConsulClient updateAclTokenAndForget(String accessorId, io.vertx.ext.consul.token.AclToken token)
      Update an existing Acl token

      Unlike the bare Vert.x variant, this method ignores the AclToken result or any failure.

      Parameters:
      accessorId - uuid of the token
      token - properties of the token
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • cloneAclToken

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      accessorId - uuid of the token
      cloneAclTokenOptions - properties of cloned token
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • cloneAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken cloneAclTokenAndAwait(String accessorId, io.vertx.ext.consul.token.CloneAclTokenOptions cloneAclTokenOptions)
      Clones an existing ACL token

      Unlike the bare Vert.x variant, this method returns a AclToken. This method awaits indefinitely 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
      cloneAclTokenOptions - properties of cloned token
      Returns:
      The operation result
      See Also:

    • cloneAclTokenAndForget

      public ConsulClient cloneAclTokenAndForget(String accessorId, io.vertx.ext.consul.token.CloneAclTokenOptions cloneAclTokenOptions)
      Clones an existing ACL token

      Unlike the bare Vert.x variant, this method ignores the AclToken result or any failure.

      Parameters:
      accessorId - uuid of the token
      cloneAclTokenOptions - properties of cloned token
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • getAclTokensAndAwait

      public List<io.vertx.ext.consul.token.AclToken> getAclTokensAndAwait()
      Get list of Acl token

      Unlike the bare Vert.x variant, this method returns a List<io.vertx.ext.consul.token.AclToken>. This method awaits indefinitely 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 operation result
      See Also:

    • getAclTokensAndForget

      public ConsulClient getAclTokensAndForget()
      Get list of Acl token

      Unlike the bare Vert.x variant, this method ignores the List<io.vertx.ext.consul.token.AclToken> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      accessorId - uuid of token
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • readAclTokenAndAwait

      public io.vertx.ext.consul.token.AclToken readAclTokenAndAwait(String accessorId)
      Reads an ACL token with the given Accessor ID

      Unlike the bare Vert.x variant, this method returns a AclToken. This method awaits indefinitely 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 operation result
      See Also:

    • readAclTokenAndForget

      public ConsulClient readAclTokenAndForget(String accessorId)
      Reads an ACL token with the given Accessor ID

      Unlike the bare Vert.x variant, this method ignores the AclToken result or any failure.

      Parameters:
      accessorId - uuid of token
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      accessorId - uuid of token
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • ConsulClient.deleteAclToken(String)

    • deleteAclTokenAndAwait

      public Boolean deleteAclTokenAndAwait(String accessorId)
      Deletes an ACL token

      Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • ConsulClient.deleteAclToken(String)

    • deleteAclTokenAndForget

      public ConsulClient deleteAclTokenAndForget(String accessorId)
      Deletes an ACL token

      Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.

      Parameters:
      accessorId - uuid of token
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • ConsulClient.deleteAclToken(String)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      name - name of event
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • fireEventAndAwait

      public io.vertx.ext.consul.Event fireEventAndAwait(String name)
      Fires a new user event

      Unlike the bare Vert.x variant, this method returns a Event. This method awaits indefinitely 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 operation result
      See Also:

    • fireEventAndForget

      public ConsulClient fireEventAndForget(String name)
      Fires a new user event

      Unlike the bare Vert.x variant, this method ignores the Event result or any failure.

      Parameters:
      name - name of event
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      name - name of event
      options - options used to create event
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • fireEventWithOptionsAndAwait

      public io.vertx.ext.consul.Event fireEventWithOptionsAndAwait(String name, io.vertx.ext.consul.EventOptions options)
      Fires a new user event

      Unlike the bare Vert.x variant, this method returns a Event. This method awaits indefinitely 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 operation result
      See Also:

    • fireEventWithOptionsAndForget

      public ConsulClient fireEventWithOptionsAndForget(String name, io.vertx.ext.consul.EventOptions options)
      Fires a new user event

      Unlike the bare Vert.x variant, this method ignores the Event result or any failure.

      Parameters:
      name - name of event
      options - options used to create event
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • listEventsAndAwait

      public io.vertx.ext.consul.EventList listEventsAndAwait()
      Returns the most recent events known by the agent

      Unlike the bare Vert.x variant, this method returns a EventList. This method awaits indefinitely 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 operation result
      See Also:

    • listEventsAndForget

      public ConsulClient listEventsAndForget()
      Returns the most recent events known by the agent

      Unlike the bare Vert.x variant, this method ignores the EventList result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/event/list endpoint
      • ConsulClient.listEventsWithOptions(EventListOptions)

    • listEventsWithOptionsAndAwait

      public io.vertx.ext.consul.EventList listEventsWithOptionsAndAwait(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 EventList. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/event/list endpoint
      • ConsulClient.listEventsWithOptions(EventListOptions)

    • listEventsWithOptionsAndForget

      public ConsulClient listEventsWithOptionsAndForget(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 ignores the EventList result or any failure.

      Parameters:
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/event/list endpoint
      • ConsulClient.listEventsWithOptions(EventListOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      serviceOptions - the options of new service
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • registerServiceAndAwait

      public void registerServiceAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • registerServiceAndForget

      public ConsulClient registerServiceAndForget(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 ignores the Void result or any failure.

      Parameters:
      serviceOptions - the options of new service
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      maintenanceOptions - the maintenance options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • maintenanceServiceAndAwait

      public void maintenanceServiceAndAwait(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
      Places a given service into "maintenance mode"

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:

    • maintenanceServiceAndForget

      public ConsulClient maintenanceServiceAndForget(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions)
      Places a given service into "maintenance mode"

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      maintenanceOptions - the maintenance options
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the ID of service
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • deregisterServiceAndAwait

      public void deregisterServiceAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • deregisterServiceAndForget

      public ConsulClient deregisterServiceAndForget(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 ignores the Void result or any failure.

      Parameters:
      id - the ID of service
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      service - name of service
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogServiceNodesAndAwait

      public io.vertx.ext.consul.ServiceList catalogServiceNodesAndAwait(String service)
      Returns the nodes providing a service

      Unlike the bare Vert.x variant, this method returns a ServiceList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogServiceNodesAndForget

      public ConsulClient catalogServiceNodesAndForget(String service)
      Returns the nodes providing a service

      Unlike the bare Vert.x variant, this method ignores the ServiceList result or any failure.

      Parameters:
      service - name of service
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      service - name of service
      options - options used to request services
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogServiceNodesWithOptionsAndAwait

      public io.vertx.ext.consul.ServiceList catalogServiceNodesWithOptionsAndAwait(String service, io.vertx.ext.consul.ServiceQueryOptions options)
      Returns the nodes providing a service

      Unlike the bare Vert.x variant, this method returns a ServiceList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogServiceNodesWithOptionsAndForget

      public ConsulClient catalogServiceNodesWithOptionsAndForget(String service, io.vertx.ext.consul.ServiceQueryOptions options)
      Returns the nodes providing a service

      Unlike the bare Vert.x variant, this method ignores the ServiceList result or any failure.

      Parameters:
      service - name of service
      options - options used to request services
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogDatacentersAndAwait

      public List<String> catalogDatacentersAndAwait()
      Return all the datacenters that are known by the Consul server

      Unlike the bare Vert.x variant, this method returns a List<String>. This method awaits indefinitely 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 operation result
      See Also:

    • catalogDatacentersAndForget

      public ConsulClient catalogDatacentersAndForget()
      Return all the datacenters that are known by the Consul server

      Unlike the bare Vert.x variant, this method ignores the List<String> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogNodesAndAwait

      public io.vertx.ext.consul.NodeList catalogNodesAndAwait()
      Returns the nodes registered in a datacenter

      Unlike the bare Vert.x variant, this method returns a NodeList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogNodesAndForget

      public ConsulClient catalogNodesAndForget()
      Returns the nodes registered in a datacenter

      Unlike the bare Vert.x variant, this method ignores the NodeList result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - options used to request nodes
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogNodesWithOptionsAndAwait

      public io.vertx.ext.consul.NodeList catalogNodesWithOptionsAndAwait(io.vertx.ext.consul.NodeQueryOptions options)
      Returns the nodes registered in a datacenter

      Unlike the bare Vert.x variant, this method returns a NodeList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogNodesWithOptionsAndForget

      public ConsulClient catalogNodesWithOptionsAndForget(io.vertx.ext.consul.NodeQueryOptions options)
      Returns the nodes registered in a datacenter

      Unlike the bare Vert.x variant, this method ignores the NodeList result or any failure.

      Parameters:
      options - options used to request nodes
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      service - the service name
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthChecksAndAwait

      public io.vertx.ext.consul.CheckList healthChecksAndAwait(String service)
      Returns the checks associated with the service

      Unlike the bare Vert.x variant, this method returns a CheckList. This method awaits indefinitely 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 operation result
      See Also:

    • healthChecksAndForget

      public ConsulClient healthChecksAndForget(String service)
      Returns the checks associated with the service

      Unlike the bare Vert.x variant, this method ignores the CheckList result or any failure.

      Parameters:
      service - the service name
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      service - the service name
      options - options used to request checks
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthChecksWithOptionsAndAwait

      public io.vertx.ext.consul.CheckList healthChecksWithOptionsAndAwait(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 CheckList. This method awaits indefinitely 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 operation result
      See Also:

    • healthChecksWithOptionsAndForget

      public ConsulClient healthChecksWithOptionsAndForget(String service, io.vertx.ext.consul.CheckQueryOptions options)
      Returns the checks associated with the service

      Unlike the bare Vert.x variant, this method ignores the CheckList result or any failure.

      Parameters:
      service - the service name
      options - options used to request checks
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      healthState - the health state
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthStateAndAwait

      public io.vertx.ext.consul.CheckList healthStateAndAwait(io.vertx.ext.consul.HealthState healthState)
      Returns the checks in the specified status

      Unlike the bare Vert.x variant, this method returns a CheckList. This method awaits indefinitely 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 operation result
      See Also:

    • healthStateAndForget

      public ConsulClient healthStateAndForget(io.vertx.ext.consul.HealthState healthState)
      Returns the checks in the specified status

      Unlike the bare Vert.x variant, this method ignores the CheckList result or any failure.

      Parameters:
      healthState - the health state
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      healthState - the health state
      options - options used to request checks
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthStateWithOptionsAndAwait

      public io.vertx.ext.consul.CheckList healthStateWithOptionsAndAwait(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 CheckList. This method awaits indefinitely 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 operation result
      See Also:

    • healthStateWithOptionsAndForget

      public ConsulClient healthStateWithOptionsAndForget(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 ignores the CheckList result or any failure.

      Parameters:
      healthState - the health state
      options - options used to request checks
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthServiceNodesAndAwait

      public io.vertx.ext.consul.ServiceEntryList healthServiceNodesAndAwait(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 ServiceEntryList. This method awaits indefinitely 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 operation result
      See Also:

    • healthServiceNodesAndForget

      public ConsulClient healthServiceNodesAndForget(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 ignores the ServiceEntryList result or any failure.

      Parameters:
      service - the service name
      passing - if true, filter results to only nodes with all checks in the passing state
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthServiceNodesWithOptionsAndAwait

      public io.vertx.ext.consul.ServiceEntryList healthServiceNodesWithOptionsAndAwait(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 ServiceEntryList. This method awaits indefinitely 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 operation result
      See Also:

    • healthServiceNodesWithOptionsAndForget

      public ConsulClient healthServiceNodesWithOptionsAndForget(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 ignores the ServiceEntryList result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • healthNodesWithOptionsAndAwait

      public io.vertx.ext.consul.CheckList healthNodesWithOptionsAndAwait(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 CheckList. This method awaits indefinitely 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 operation result
      See Also:

    • healthNodesWithOptionsAndForget

      public ConsulClient healthNodesWithOptionsAndForget(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 ignores the CheckList result or any failure.

      Parameters:
      node - the node name or ID
      options - options used to request node health checks
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogServicesAndAwait

      public io.vertx.ext.consul.ServiceList catalogServicesAndAwait()
      Returns the services registered in a datacenter

      Unlike the bare Vert.x variant, this method returns a ServiceList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogServicesAndForget

      public ConsulClient catalogServicesAndForget()
      Returns the services registered in a datacenter

      Unlike the bare Vert.x variant, this method ignores the ServiceList result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogServicesWithOptionsAndAwait

      public io.vertx.ext.consul.ServiceList catalogServicesWithOptionsAndAwait(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 ServiceList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogServicesWithOptionsAndForget

      public ConsulClient catalogServicesWithOptionsAndForget(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 ignores the ServiceList result or any failure.

      Parameters:
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      node - node name
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogNodeServicesAndAwait

      public io.vertx.ext.consul.ServiceList catalogNodeServicesAndAwait(String node)
      Returns the node's registered services

      Unlike the bare Vert.x variant, this method returns a ServiceList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogNodeServicesAndForget

      public ConsulClient catalogNodeServicesAndForget(String node)
      Returns the node's registered services

      Unlike the bare Vert.x variant, this method ignores the ServiceList result or any failure.

      Parameters:
      node - node name
      Returns:
      The current instance to chain operations if needed.
      See Also:

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      node - node name
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • catalogNodeServicesWithOptionsAndAwait

      public io.vertx.ext.consul.ServiceList catalogNodeServicesWithOptionsAndAwait(String node, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the node's registered services This is blocking query unlike catalogNodeServices(String)

      Unlike the bare Vert.x variant, this method returns a ServiceList. This method awaits indefinitely 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 operation result
      See Also:

    • catalogNodeServicesWithOptionsAndForget

      public ConsulClient catalogNodeServicesWithOptionsAndForget(String node, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the node's registered services This is blocking query unlike catalogNodeServices(String)

      Unlike the bare Vert.x variant, this method ignores the ServiceList result or any failure.

      Parameters:
      node - node name
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • localServicesAndAwait

      public List<io.vertx.ext.consul.Service> localServicesAndAwait()
      Returns list of services registered with the local agent.

      Unlike the bare Vert.x variant, this method returns a List<io.vertx.ext.consul.Service>. This method awaits indefinitely 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 operation result
      See Also:

    • localServicesAndForget

      public ConsulClient localServicesAndForget()
      Returns list of services registered with the local agent.

      Unlike the bare Vert.x variant, this method ignores the List<io.vertx.ext.consul.Service> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • localChecksAndAwait

      public List<io.vertx.ext.consul.Check> localChecksAndAwait()
      Return all the checks that are registered with the local agent.

      Unlike the bare Vert.x variant, this method returns a List<io.vertx.ext.consul.Check>. This method awaits indefinitely 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 operation result
      See Also:

    • localChecksAndForget

      public ConsulClient localChecksAndForget()
      Return all the checks that are registered with the local agent.

      Unlike the bare Vert.x variant, this method ignores the List<io.vertx.ext.consul.Check> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      checkOptions - options used to register new check
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • registerCheckAndAwait

      public void registerCheckAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • registerCheckAndForget

      public ConsulClient registerCheckAndForget(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 ignores the Void result or any failure.

      Parameters:
      checkOptions - options used to register new check
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      checkId - the ID of check
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • deregisterCheckAndAwait

      public void deregisterCheckAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • deregisterCheckAndForget

      public ConsulClient deregisterCheckAndForget(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 ignores the Void result or any failure.

      Parameters:
      checkId - the ID of check
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      checkId - the ID of check
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • passCheckAndAwait

      public void passCheckAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • passCheckAndForget

      public ConsulClient passCheckAndForget(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 ignores the Void result or any failure.

      Parameters:
      checkId - the ID of check
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • passCheckWithNoteAndAwait

      public void passCheckWithNoteAndAwait(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 Void. This method awaits indefinitely 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.
      See Also:

    • passCheckWithNoteAndForget

      public ConsulClient passCheckWithNoteAndForget(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 ignores the Void result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      checkId - the ID of check
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • warnCheckAndAwait

      public void warnCheckAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • warnCheckAndForget

      public ConsulClient warnCheckAndForget(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 ignores the Void result or any failure.

      Parameters:
      checkId - the ID of check
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • warnCheckWithNoteAndAwait

      public void warnCheckWithNoteAndAwait(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 Void. This method awaits indefinitely 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.
      See Also:

    • warnCheckWithNoteAndForget

      public ConsulClient warnCheckWithNoteAndForget(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 ignores the Void result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      checkId - the ID of check
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • failCheckAndAwait

      public void failCheckAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • failCheckAndForget

      public ConsulClient failCheckAndForget(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 ignores the Void result or any failure.

      Parameters:
      checkId - the ID of check
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • failCheckWithNoteAndAwait

      public void failCheckWithNoteAndAwait(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 Void. This method awaits indefinitely 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.
      See Also:

    • failCheckWithNoteAndForget

      public ConsulClient failCheckWithNoteAndForget(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 ignores the Void result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      checkId - the ID of check
      status - new status of check
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • updateCheckAndAwait

      public void updateCheckAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • updateCheckAndForget

      public ConsulClient updateCheckAndForget(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 ignores the Void result or any failure.

      Parameters:
      checkId - the ID of check
      status - new status of check
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • updateCheckWithNoteAndAwait

      public void updateCheckWithNoteAndAwait(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 Void. This method awaits indefinitely 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.
      See Also:

    • updateCheckWithNoteAndForget

      public ConsulClient updateCheckWithNoteAndForget(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 ignores the Void result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • leaderStatusAndAwait

      public String leaderStatusAndAwait()
      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 String. This method awaits indefinitely 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 operation result
      See Also:

    • leaderStatusAndForget

      public ConsulClient leaderStatusAndForget()
      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 ignores the String result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • peersStatusAndAwait

      public List<String> peersStatusAndAwait()
      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 List<String>. This method awaits indefinitely 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 operation result
      See Also:

    • peersStatusAndForget

      public ConsulClient peersStatusAndForget()
      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 ignores the List<String> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • createSession

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • createSessionAndAwait

      public String createSessionAndAwait()
      Initialize a new session

      Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely 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 operation result
      See Also:

    • createSessionAndForget

      public ConsulClient createSessionAndForget()
      Initialize a new session

      Unlike the bare Vert.x variant, this method ignores the String result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - options used to create session
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • createSessionWithOptionsAndAwait

      public String createSessionWithOptionsAndAwait(io.vertx.ext.consul.SessionOptions options)
      Initialize a new session

      Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely 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 operation result
      See Also:

    • createSessionWithOptionsAndForget

      public ConsulClient createSessionWithOptionsAndForget(io.vertx.ext.consul.SessionOptions options)
      Initialize a new session

      Unlike the bare Vert.x variant, this method ignores the String result or any failure.

      Parameters:
      options - options used to create session
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the ID of requested session
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • infoSessionAndAwait

      public io.vertx.ext.consul.Session infoSessionAndAwait(String id)
      Returns the requested session information

      Unlike the bare Vert.x variant, this method returns a Session. This method awaits indefinitely 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 operation result
      See Also:

    • infoSessionAndForget

      public ConsulClient infoSessionAndForget(String id)
      Returns the requested session information

      Unlike the bare Vert.x variant, this method ignores the Session result or any failure.

      Parameters:
      id - the ID of requested session
      Returns:
      The current instance to chain operations if needed.
      See Also:

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the ID of requested session
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • infoSessionWithOptionsAndAwait

      public io.vertx.ext.consul.Session infoSessionWithOptionsAndAwait(String id, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the requested session information This is blocking query unlike infoSession(String)

      Unlike the bare Vert.x variant, this method returns a Session. This method awaits indefinitely 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 operation result
      See Also:

    • infoSessionWithOptionsAndForget

      public ConsulClient infoSessionWithOptionsAndForget(String id, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the requested session information This is blocking query unlike infoSession(String)

      Unlike the bare Vert.x variant, this method ignores the Session result or any failure.

      Parameters:
      id - the ID of requested session
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the ID of session that should be renewed
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • renewSessionAndAwait

      public io.vertx.ext.consul.Session renewSessionAndAwait(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 Session. This method awaits indefinitely 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 operation result
      See Also:

    • renewSessionAndForget

      public ConsulClient renewSessionAndForget(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 ignores the Session result or any failure.

      Parameters:
      id - the ID of session that should be renewed
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • listSessionsAndAwait

      public io.vertx.ext.consul.SessionList listSessionsAndAwait()
      Returns the active sessions

      Unlike the bare Vert.x variant, this method returns a SessionList. This method awaits indefinitely 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 operation result
      See Also:

    • listSessionsAndForget

      public ConsulClient listSessionsAndForget()
      Returns the active sessions

      Unlike the bare Vert.x variant, this method ignores the SessionList result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/session/list endpoint
      • ConsulClient.listSessionsWithOptions(BlockingQueryOptions)

    • listSessionsWithOptionsAndAwait

      public io.vertx.ext.consul.SessionList listSessionsWithOptionsAndAwait(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 SessionList. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/session/list endpoint
      • ConsulClient.listSessionsWithOptions(BlockingQueryOptions)

    • listSessionsWithOptionsAndForget

      public ConsulClient listSessionsWithOptionsAndForget(io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the active sessions This is blocking query unlike listSessions()

      Unlike the bare Vert.x variant, this method ignores the SessionList result or any failure.

      Parameters:
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/session/list endpoint
      • ConsulClient.listSessionsWithOptions(BlockingQueryOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      nodeId - the ID of node
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • listNodeSessionsAndAwait

      public io.vertx.ext.consul.SessionList listNodeSessionsAndAwait(String nodeId)
      Returns the active sessions for a given node

      Unlike the bare Vert.x variant, this method returns a SessionList. This method awaits indefinitely 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 operation result
      See Also:

    • listNodeSessionsAndForget

      public ConsulClient listNodeSessionsAndForget(String nodeId)
      Returns the active sessions for a given node

      Unlike the bare Vert.x variant, this method ignores the SessionList result or any failure.

      Parameters:
      nodeId - the ID of node
      Returns:
      The current instance to chain operations if needed.
      See Also:

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

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      nodeId - the ID of node
      options - the blocking options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • listNodeSessionsWithOptionsAndAwait

      public io.vertx.ext.consul.SessionList listNodeSessionsWithOptionsAndAwait(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the active sessions for a given node This is blocking query unlike listNodeSessions(String)

      Unlike the bare Vert.x variant, this method returns a SessionList. This method awaits indefinitely 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 operation result
      See Also:

    • listNodeSessionsWithOptionsAndForget

      public ConsulClient listNodeSessionsWithOptionsAndForget(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options)
      Returns the active sessions for a given node This is blocking query unlike listNodeSessions(String)

      Unlike the bare Vert.x variant, this method ignores the SessionList result or any failure.

      Parameters:
      nodeId - the ID of node
      options - the blocking options
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the ID of session
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • destroySessionAndAwait

      public void destroySessionAndAwait(String id)
      Destroys the given session

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:

    • destroySessionAndForget

      public ConsulClient destroySessionAndForget(String id)
      Destroys the given session

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      id - the ID of session
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      definition - definition of the prepare query
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/query endpoint
      • ConsulClient.createPreparedQuery(PreparedQueryDefinition)

    • createPreparedQueryAndAwait

      public String createPreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)

      Unlike the bare Vert.x variant, this method returns a String. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/query endpoint
      • ConsulClient.createPreparedQuery(PreparedQueryDefinition)

    • createPreparedQueryAndForget

      public ConsulClient createPreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)

      Unlike the bare Vert.x variant, this method ignores the String result or any failure.

      Parameters:
      definition - definition of the prepare query
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/query endpoint
      • ConsulClient.createPreparedQuery(PreparedQueryDefinition)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the id of the query to read
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • getPreparedQueryAndAwait

      public io.vertx.ext.consul.PreparedQueryDefinition getPreparedQueryAndAwait(String id)
      Returns an existing prepared query

      Unlike the bare Vert.x variant, this method returns a PreparedQueryDefinition. This method awaits indefinitely 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 operation result
      See Also:

    • getPreparedQueryAndForget

      public ConsulClient getPreparedQueryAndForget(String id)
      Returns an existing prepared query

      Unlike the bare Vert.x variant, this method ignores the PreparedQueryDefinition result or any failure.

      Parameters:
      id - the id of the query to read
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/query endpoint
      • ConsulClient.getAllPreparedQueries()

    • getAllPreparedQueriesAndAwait

      public List<io.vertx.ext.consul.PreparedQueryDefinition> getAllPreparedQueriesAndAwait()
      Returns a list of all prepared queries.

      Unlike the bare Vert.x variant, this method returns a List<io.vertx.ext.consul.PreparedQueryDefinition>. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/query endpoint
      • ConsulClient.getAllPreparedQueries()

    • getAllPreparedQueriesAndForget

      public ConsulClient getAllPreparedQueriesAndForget()
      Returns a list of all prepared queries.

      Unlike the bare Vert.x variant, this method ignores the List<io.vertx.ext.consul.PreparedQueryDefinition> result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/query endpoint
      • ConsulClient.getAllPreparedQueries()

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      definition - definition of the prepare query
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/query/:uuid endpoint
      • ConsulClient.updatePreparedQuery(PreparedQueryDefinition)

    • updatePreparedQueryAndAwait

      public void updatePreparedQueryAndAwait(io.vertx.ext.consul.PreparedQueryDefinition definition)

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:
      • /v1/query/:uuid endpoint
      • ConsulClient.updatePreparedQuery(PreparedQueryDefinition)

    • updatePreparedQueryAndForget

      public ConsulClient updatePreparedQueryAndForget(io.vertx.ext.consul.PreparedQueryDefinition definition)

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      definition - definition of the prepare query
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • /v1/query/:uuid endpoint
      • ConsulClient.updatePreparedQuery(PreparedQueryDefinition)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      id - the id of the query to delete
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • deletePreparedQueryAndAwait

      public void deletePreparedQueryAndAwait(String id)
      Deletes an existing prepared query

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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
      See Also:

    • deletePreparedQueryAndForget

      public ConsulClient deletePreparedQueryAndForget(String id)
      Deletes an existing prepared query

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      id - the id of the query to delete
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • executePreparedQueryAndAwait

      public io.vertx.ext.consul.PreparedQueryExecuteResponse executePreparedQueryAndAwait(String query)
      Executes an existing prepared query.

      Unlike the bare Vert.x variant, this method returns a PreparedQueryExecuteResponse. This method awaits indefinitely 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 operation result
      See Also:

    • executePreparedQueryAndForget

      public ConsulClient executePreparedQueryAndForget(String query)
      Executes an existing prepared query.

      Unlike the bare Vert.x variant, this method ignores the PreparedQueryExecuteResponse result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • /v1/query/:uuid/execute endpoint
      • ConsulClient.executePreparedQueryWithOptions(String, PreparedQueryExecuteOptions)

    • executePreparedQueryWithOptionsAndAwait

      public io.vertx.ext.consul.PreparedQueryExecuteResponse executePreparedQueryWithOptionsAndAwait(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)
      Executes an existing prepared query.

      Unlike the bare Vert.x variant, this method returns a PreparedQueryExecuteResponse. This method awaits indefinitely 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 operation result
      See Also:
      • /v1/query/:uuid/execute endpoint
      • ConsulClient.executePreparedQueryWithOptions(String, PreparedQueryExecuteOptions)

    • executePreparedQueryWithOptionsAndForget

      public ConsulClient executePreparedQueryWithOptionsAndForget(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options)
      Executes an existing prepared query.

      Unlike the bare Vert.x variant, this method ignores the PreparedQueryExecuteResponse result or any failure.

      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 current instance to chain operations if needed.
      See Also:
      • /v1/query/:uuid/execute endpoint
      • ConsulClient.executePreparedQueryWithOptions(String, PreparedQueryExecuteOptions)

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • registerCatalogServiceAndAwait

      public void registerCatalogServiceAndAwait(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 Void. This method awaits indefinitely 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
      See Also:

    • registerCatalogServiceAndForget

      public ConsulClient registerCatalogServiceAndForget(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 ignores the Void result or any failure.

      Parameters:
      nodeOptions - the options of new node
      serviceOptions - the options of new service
      Returns:
      The current instance to chain operations if needed.
      See Also:

    • 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. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      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:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • deregisterCatalogServiceAndAwait

      public void deregisterCatalogServiceAndAwait(String nodeId, String serviceId)
      Deregister entities from the node or deregister the node itself.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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)
      See Also:

    • deregisterCatalogServiceAndForget

      public ConsulClient deregisterCatalogServiceAndForget(String nodeId, String serviceId)
      Deregister entities from the node or deregister the node itself.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      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 current instance to chain operations if needed.
      See Also:

    • create

      public static ConsulClient create(Vertx vertx)
      Create a Consul client with default options.
      Parameters:
      vertx - the Vert.x instance
      Returns:
      the client

    • create

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

    • close

      public void close()
      Close the client and release its resources

    • newInstance

      public static ConsulClient newInstance(io.vertx.ext.consul.ConsulClient delegate)
      Creates a new instance of the ConsulClient.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

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

    • toString

      public String toString()
      Overrides:
      toString in class Object