Class ConsulClient


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

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

    • Constructor Detail

      • ConsulClient

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

        public ConsulClient​(Object delegate)
    • Method Detail

      • getDelegate

        public io.vertx.ext.consul.ConsulClient getDelegate()
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object
      • create

        public static ConsulClient create​(Vertx vertx)
        Parameters:
        vertx - the Vert.x instance
        Returns:
        the client
      • create

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

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

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

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

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

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

        Returns:
        the JsonObject instance produced by the operation.
      • agentInfoAndForget

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

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

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

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

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

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

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

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

        Returns:
        the CoordinateList instance produced by the operation.
      • coordinateNodesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        options - the blocking options
        Returns:
        the CoordinateList instance produced by the operation.
      • coordinateDatacenters

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

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

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

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

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

        Returns:
        the List instance produced by the operation.
      • coordinateDatacentersAndForget

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

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

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

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

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

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

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

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

        Parameters:
        keyPrefix - the prefix
        Returns:
        the List instance produced by the operation.
      • getKeysAndForget

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

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

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

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

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

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

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

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

        Parameters:
        keyPrefix - the prefix
        options - the blocking options
        Returns:
        the List instance produced by the operation.
      • getValue

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

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

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

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

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

        Parameters:
        key - the key
        Returns:
        the KeyValue instance produced by the operation.
      • getValueAndForget

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

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

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

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

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

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

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

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

        Parameters:
        key - the key
        options - the blocking options
        Returns:
        the KeyValue instance produced by the operation.
      • deleteValue

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

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

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

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

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

        Parameters:
        key - the key
        Returns:
        the Void instance produced by the operation.
      • deleteValueAndForget

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

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

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

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

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

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

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

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

        Parameters:
        keyPrefix - the prefix
        Returns:
        the KeyValueList instance produced by the operation.
      • getValuesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        keyPrefix - the prefix
        options - the blocking options
        Returns:
        the KeyValueList instance produced by the operation.
      • deleteValues

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

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

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

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

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

        Parameters:
        keyPrefix - the prefix
        Returns:
        the Void instance produced by the operation.
      • deleteValuesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        key - the key
        value - the value
        Returns:
        the Boolean instance produced by the operation.
      • putValueAndForget

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

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

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

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

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

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

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

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

        Parameters:
        key - the key
        value - the value
        options - options used to push pair
        Returns:
        the Boolean instance produced by the operation.
      • transaction

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

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

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

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

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

        Parameters:
        request - transaction request
        Returns:
        the TxnResponse instance produced by the operation.
      • transactionAndForget

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

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

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

        public io.smallrye.mutiny.Uni<String> createAclToken​(io.vertx.ext.consul.AclToken token)
        Create new Acl token

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

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

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

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

        Parameters:
        token - properties of the token
        Returns:
        the String instance produced by the operation.
      • createAclTokenAndForget

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

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

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

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

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

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

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

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

        Parameters:
        token - properties of the token to be updated
        Returns:
        the String instance produced by the operation.
      • updateAclTokenAndForget

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

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

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

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

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

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

        public String cloneAclTokenAndAwait​(String id)
        Blocking variant of cloneAclToken(String).

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

        Parameters:
        id - the ID of token to be cloned
        Returns:
        the String instance produced by the operation.
      • cloneAclTokenAndForget

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

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

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

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

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

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

        public List<io.vertx.ext.consul.AclToken> listAclTokensAndAwait()
        Blocking variant of listAclTokens().

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

        Returns:
        the List instance produced by the operation.
      • listAclTokensAndForget

        public ConsulClient listAclTokensAndForget()
        Variant of listAclTokens() that ignores the result of the operation.

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

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

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

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

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

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

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

        Parameters:
        id - the ID of token
        Returns:
        the AclToken instance produced by the operation.
      • infoAclTokenAndForget

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

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

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

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

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

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

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

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

        Parameters:
        id - the ID of token
        Returns:
        the Void instance produced by the operation.
      • destroyAclTokenAndForget

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

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

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

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

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

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

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

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

        Parameters:
        name - name of event
        Returns:
        the Event instance produced by the operation.
      • fireEventAndForget

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

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

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

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

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

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

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

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

        Parameters:
        name - name of event
        options - options used to create event
        Returns:
        the Event instance produced by the operation.
      • listEvents

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

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

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

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

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

        Returns:
        the EventList instance produced by the operation.
      • listEventsAndForget

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

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

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

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

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

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

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

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

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

        Parameters:
        options - the blocking options
        Returns:
        the EventList instance produced by the operation.
      • registerService

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

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

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

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

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

        Parameters:
        serviceOptions - the options of new service
        Returns:
        the Void instance produced by the operation.
      • registerServiceAndForget

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

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

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

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

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

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

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

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

        Parameters:
        maintenanceOptions - the maintenance options
        Returns:
        the Void instance produced by the operation.
      • maintenanceServiceAndForget

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

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

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

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

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

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

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

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

        Parameters:
        id - the ID of service
        Returns:
        the Void instance produced by the operation.
      • deregisterServiceAndForget

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

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

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

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

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

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

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

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

        Parameters:
        service - name of service
        Returns:
        the ServiceList instance produced by the operation.
      • catalogServiceNodesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        service - name of service
        options - options used to request services
        Returns:
        the ServiceList instance produced by the operation.
      • catalogDatacenters

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

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

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

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

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

        Returns:
        the List instance produced by the operation.
      • catalogDatacentersAndForget

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

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

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

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

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

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

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

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

        Returns:
        the NodeList instance produced by the operation.
      • catalogNodesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        options - options used to request nodes
        Returns:
        the NodeList instance produced by the operation.
      • healthChecks

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

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

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

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

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

        Parameters:
        service - the service name
        Returns:
        the CheckList instance produced by the operation.
      • healthChecksAndForget

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

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

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

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

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

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

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

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

        Parameters:
        service - the service name
        options - options used to request checks
        Returns:
        the CheckList instance produced by the operation.
      • healthState

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

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

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

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

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

        Parameters:
        healthState - the health state
        Returns:
        the CheckList instance produced by the operation.
      • healthStateAndForget

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

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

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

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

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

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

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

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

        Parameters:
        healthState - the health state
        options - options used to request checks
        Returns:
        the CheckList instance produced by the operation.
      • healthServiceNodes

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

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

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

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

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

        Parameters:
        service - the service name
        passing - if true, filter results to only nodes with all checks in the passing state
        Returns:
        the ServiceEntryList instance produced by the operation.
      • healthServiceNodesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        service - the service name
        passing - if true, filter results to only nodes with all checks in the passing state
        options - options used to request services
        Returns:
        the ServiceEntryList instance produced by the operation.
      • catalogServices

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

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

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

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

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

        Returns:
        the ServiceList instance produced by the operation.
      • catalogServicesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        options - the blocking options
        Returns:
        the ServiceList instance produced by the operation.
      • catalogNodeServices

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

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

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

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

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

        Parameters:
        node - node name
        Returns:
        the ServiceList instance produced by the operation.
      • catalogNodeServicesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        node - node name
        options - the blocking options
        Returns:
        the ServiceList instance produced by the operation.
      • localServices

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

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

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

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

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

        Returns:
        the List instance produced by the operation.
      • localServicesAndForget

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

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

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

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

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

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

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

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

        Returns:
        the List instance produced by the operation.
      • localChecksAndForget

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

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

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

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

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

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

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

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

        Parameters:
        checkOptions - options used to register new check
        Returns:
        the Void instance produced by the operation.
      • registerCheckAndForget

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

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

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

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

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

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

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

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

        Parameters:
        checkId - the ID of check
        Returns:
        the Void instance produced by the operation.
      • deregisterCheckAndForget

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

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

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

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

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

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

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

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

        Parameters:
        checkId - the ID of check
        Returns:
        the Void instance produced by the operation.
      • passCheckAndForget

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Parameters:
        checkId - the ID of check
        Returns:
        the Void instance produced by the operation.
      • warnCheckAndForget

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Parameters:
        checkId - the ID of check
        Returns:
        the Void instance produced by the operation.
      • failCheckAndForget

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Parameters:
        checkId - the ID of check
        status - new status of check
        Returns:
        the Void instance produced by the operation.
      • updateCheckAndForget

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

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

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

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

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

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

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

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

        Parameters:
        checkId - the ID of check
        status - new status of check
        note - specifies a human-readable message. This will be passed through to the check's Output field.
        Returns:
        the Void instance produced by the operation.
      • leaderStatus

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

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

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

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

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

        Returns:
        the String instance produced by the operation.
      • leaderStatusAndForget

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

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

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

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

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

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

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

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

        Returns:
        the List instance produced by the operation.
      • peersStatusAndForget

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

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

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

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

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

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

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

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

        Returns:
        the String instance produced by the operation.
      • createSessionAndForget

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

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

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

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

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

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

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

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

        Parameters:
        options - options used to create session
        Returns:
        the String instance produced by the operation.
      • infoSession

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

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

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

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

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

        Parameters:
        id - the ID of requested session
        Returns:
        the Session instance produced by the operation.
      • infoSessionAndForget

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

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

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

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

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

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

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

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

        Parameters:
        id - the ID of requested session
        options - the blocking options
        Returns:
        the Session instance produced by the operation.
      • renewSession

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

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

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

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

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

        Parameters:
        id - the ID of session that should be renewed
        Returns:
        the Session instance produced by the operation.
      • renewSessionAndForget

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

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

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

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

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

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

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

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

        Returns:
        the SessionList instance produced by the operation.
      • listSessionsAndForget

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

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

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

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

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

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

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

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

        Parameters:
        options - the blocking options
        Returns:
        the SessionList instance produced by the operation.
      • listNodeSessions

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

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

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

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

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

        Parameters:
        nodeId - the ID of node
        Returns:
        the SessionList instance produced by the operation.
      • listNodeSessionsAndForget

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

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

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

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

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

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

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

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

        Parameters:
        nodeId - the ID of node
        options - the blocking options
        Returns:
        the SessionList instance produced by the operation.
      • destroySession

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

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

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

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

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

        Parameters:
        id - the ID of session
        Returns:
        the Void instance produced by the operation.
      • destroySessionAndForget

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

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

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

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

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

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

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

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

        Parameters:
        definition - definition of the prepare query
        Returns:
        the String instance produced by the operation.
      • getPreparedQuery

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

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

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

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

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

        Parameters:
        id - the id of the query to read
        Returns:
        the PreparedQueryDefinition instance produced by the operation.
      • getPreparedQueryAndForget

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

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

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

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

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

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

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

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

        Returns:
        the List instance produced by the operation.
      • getAllPreparedQueriesAndForget

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

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

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

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

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

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

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

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

        Parameters:
        definition - definition of the prepare query
        Returns:
        the Void instance produced by the operation.
      • deletePreparedQuery

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

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

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

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

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

        Parameters:
        id - the id of the query to delete
        Returns:
        the Void instance produced by the operation.
      • deletePreparedQueryAndForget

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Parameters:
        nodeOptions - the options of new node
        serviceOptions - the options of new service
        Returns:
        the Void instance produced by the operation.
      • registerCatalogServiceAndForget

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

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

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

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

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

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

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

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

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

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

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

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

        public void close()
      • newInstance

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