io.vertx.rxjava.ext.consul.ConsulClient Maven / Gradle / Ivy
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat licenses this file to you under the Apache License, version 2.0
* (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.vertx.rxjava.ext.consul;
import rx.Observable;
import rx.Single;
import io.vertx.rx.java.RxHelper;
import io.vertx.rx.java.WriteStreamSubscriber;
import io.vertx.rx.java.SingleOnSubscribeAdapter;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;
/**
* A Vert.x service used to interact with Consul.
*
*
* NOTE: This class has been automatically generated from the {@link io.vertx.ext.consul.ConsulClient original} non RX-ified interface using Vert.x codegen.
*/
@RxGen(io.vertx.ext.consul.ConsulClient.class)
public class ConsulClient {
@Override
public String toString() {
return delegate.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ConsulClient that = (ConsulClient) o;
return delegate.equals(that.delegate);
}
@Override
public int hashCode() {
return delegate.hashCode();
}
public static final TypeArg __TYPE_ARG = new TypeArg<>( obj -> new ConsulClient((io.vertx.ext.consul.ConsulClient) obj),
ConsulClient::getDelegate
);
private final io.vertx.ext.consul.ConsulClient delegate;
public ConsulClient(io.vertx.ext.consul.ConsulClient delegate) {
this.delegate = delegate;
}
public ConsulClient(Object delegate) {
this.delegate = (io.vertx.ext.consul.ConsulClient)delegate;
}
public io.vertx.ext.consul.ConsulClient getDelegate() {
return delegate;
}
/**
* Create a Consul client with default options.
* @param vertx the Vert.x instance
* @return the client
*/
public static io.vertx.rxjava.ext.consul.ConsulClient create(io.vertx.rxjava.core.Vertx vertx) {
io.vertx.rxjava.ext.consul.ConsulClient ret = io.vertx.rxjava.ext.consul.ConsulClient.newInstance((io.vertx.ext.consul.ConsulClient)io.vertx.ext.consul.ConsulClient.create(vertx.getDelegate()));
return ret;
}
/**
* Create a Consul client.
* @param vertx the Vert.x instance
* @param options the options
* @return the client
*/
public static io.vertx.rxjava.ext.consul.ConsulClient create(io.vertx.rxjava.core.Vertx vertx, io.vertx.ext.consul.ConsulClientOptions options) {
io.vertx.rxjava.ext.consul.ConsulClient ret = io.vertx.rxjava.ext.consul.ConsulClient.newInstance((io.vertx.ext.consul.ConsulClient)io.vertx.ext.consul.ConsulClient.create(vertx.getDelegate(), options));
return ret;
}
/**
* Returns the configuration and member information of the local agent
* @param resultHandler will be provided with the configuration and member information of the local agent
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient agentInfo(Handler> resultHandler) {
delegate.agentInfo(resultHandler);
return this;
}
/**
* Returns the configuration and member information of the local agent
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient agentInfo() {
return
agentInfo(ar -> { });
}
/**
* Returns the configuration and member information of the local agent
* @return reference to this, for fluency
*/
public Single rxAgentInfo() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
agentInfo(fut);
}));
}
/**
* Returns the LAN network coordinates for all nodes in a given DC
* @param resultHandler will be provided with network coordinates of nodes in datacenter
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient coordinateNodes(Handler> resultHandler) {
delegate.coordinateNodes(resultHandler);
return this;
}
/**
* Returns the LAN network coordinates for all nodes in a given DC
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient coordinateNodes() {
return
coordinateNodes(ar -> { });
}
/**
* Returns the LAN network coordinates for all nodes in a given DC
* @return reference to this, for fluency
*/
public Single rxCoordinateNodes() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
coordinateNodes(fut);
}));
}
/**
* Returns the LAN network coordinates for all nodes in a given DC
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#coordinateNodes}
* @param options the blocking options
* @param resultHandler will be provided with network coordinates of nodes in datacenter
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient coordinateNodesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.coordinateNodesWithOptions(options, resultHandler);
return this;
}
/**
* Returns the LAN network coordinates for all nodes in a given DC
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#coordinateNodes}
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient coordinateNodesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options) {
return
coordinateNodesWithOptions(options, ar -> { });
}
/**
* Returns the LAN network coordinates for all nodes in a given DC
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#coordinateNodes}
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxCoordinateNodesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
coordinateNodesWithOptions(options, fut);
}));
}
/**
* Returns the WAN network coordinates for all Consul servers, organized by DCs
* @param resultHandler will be provided with network coordinates for all Consul servers
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient coordinateDatacenters(Handler>> resultHandler) {
delegate.coordinateDatacenters(resultHandler);
return this;
}
/**
* Returns the WAN network coordinates for all Consul servers, organized by DCs
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient coordinateDatacenters() {
return
coordinateDatacenters(ar -> { });
}
/**
* Returns the WAN network coordinates for all Consul servers, organized by DCs
* @return reference to this, for fluency
*/
public Single> rxCoordinateDatacenters() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
coordinateDatacenters(fut);
}));
}
/**
* Returns the list of keys that corresponding to the specified key prefix.
* @param keyPrefix the prefix
* @param resultHandler will be provided with keys list
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getKeys(String keyPrefix, Handler>> resultHandler) {
delegate.getKeys(keyPrefix, resultHandler);
return this;
}
/**
* Returns the list of keys that corresponding to the specified key prefix.
* @param keyPrefix the prefix
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getKeys(String keyPrefix) {
return
getKeys(keyPrefix, ar -> { });
}
/**
* Returns the list of keys that corresponding to the specified key prefix.
* @param keyPrefix the prefix
* @return reference to this, for fluency
*/
public Single> rxGetKeys(String keyPrefix) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getKeys(keyPrefix, fut);
}));
}
/**
* Returns the list of keys that corresponding to the specified key prefix.
* @param keyPrefix the prefix
* @param options the blocking options
* @param resultHandler will be provided with keys list
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getKeysWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options, Handler>> resultHandler) {
delegate.getKeysWithOptions(keyPrefix, options, resultHandler);
return this;
}
/**
* Returns the list of keys that corresponding to the specified key prefix.
* @param keyPrefix the prefix
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getKeysWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options) {
return
getKeysWithOptions(keyPrefix, options, ar -> { });
}
/**
* Returns the list of keys that corresponding to the specified key prefix.
* @param keyPrefix the prefix
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single> rxGetKeysWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getKeysWithOptions(keyPrefix, options, fut);
}));
}
/**
* Returns key/value pair that corresponding to the specified key.
* An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found.
* @param key the key
* @param resultHandler will be provided with key/value pair
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValue(String key, Handler> resultHandler) {
delegate.getValue(key, resultHandler);
return this;
}
/**
* Returns key/value pair that corresponding to the specified key.
* An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found.
* @param key the key
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValue(String key) {
return
getValue(key, ar -> { });
}
/**
* Returns key/value pair that corresponding to the specified key.
* An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found.
* @param key the key
* @return reference to this, for fluency
*/
public Single rxGetValue(String key) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getValue(key, fut);
}));
}
/**
* Returns key/value pair that corresponding to the specified key.
* An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#getValue}
* @param key the key
* @param options the blocking options
* @param resultHandler will be provided with key/value pair
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValueWithOptions(String key, io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.getValueWithOptions(key, options, resultHandler);
return this;
}
/**
* Returns key/value pair that corresponding to the specified key.
* An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#getValue}
* @param key the key
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValueWithOptions(String key, io.vertx.ext.consul.BlockingQueryOptions options) {
return
getValueWithOptions(key, options, ar -> { });
}
/**
* Returns key/value pair that corresponding to the specified key.
* An empty {@link io.vertx.ext.consul.KeyValue} object will be returned if no such key is found.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#getValue}
* @param key the key
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxGetValueWithOptions(String key, io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getValueWithOptions(key, options, fut);
}));
}
/**
* Remove the key/value pair that corresponding to the specified key
* @param key the key
* @param resultHandler will be called on complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deleteValue(String key, Handler> resultHandler) {
delegate.deleteValue(key, resultHandler);
return this;
}
/**
* Remove the key/value pair that corresponding to the specified key
* @param key the key
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deleteValue(String key) {
return
deleteValue(key, ar -> { });
}
/**
* Remove the key/value pair that corresponding to the specified key
* @param key the key
* @return reference to this, for fluency
*/
public Single rxDeleteValue(String key) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
deleteValue(key, fut);
}));
}
/**
* Returns the list of key/value pairs that corresponding to the specified key prefix.
* An empty {@link io.vertx.ext.consul.KeyValueList} object will be returned if no such key prefix is found.
* @param keyPrefix the prefix
* @param resultHandler will be provided with list of key/value pairs
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValues(String keyPrefix, Handler> resultHandler) {
delegate.getValues(keyPrefix, resultHandler);
return this;
}
/**
* Returns the list of key/value pairs that corresponding to the specified key prefix.
* An empty {@link io.vertx.ext.consul.KeyValueList} object will be returned if no such key prefix is found.
* @param keyPrefix the prefix
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValues(String keyPrefix) {
return
getValues(keyPrefix, ar -> { });
}
/**
* Returns the list of key/value pairs that corresponding to the specified key prefix.
* An empty {@link io.vertx.ext.consul.KeyValueList} object will be returned if no such key prefix is found.
* @param keyPrefix the prefix
* @return reference to this, for fluency
*/
public Single rxGetValues(String keyPrefix) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getValues(keyPrefix, fut);
}));
}
/**
* Returns the list of key/value pairs that corresponding to the specified key prefix.
* An empty {@link io.vertx.ext.consul.KeyValueList} object will be returned if no such key prefix is found.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#getValues}
* @param keyPrefix the prefix
* @param options the blocking options
* @param resultHandler will be provided with list of key/value pairs
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValuesWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.getValuesWithOptions(keyPrefix, options, resultHandler);
return this;
}
/**
* Returns the list of key/value pairs that corresponding to the specified key prefix.
* An empty {@link io.vertx.ext.consul.KeyValueList} object will be returned if no such key prefix is found.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#getValues}
* @param keyPrefix the prefix
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getValuesWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options) {
return
getValuesWithOptions(keyPrefix, options, ar -> { });
}
/**
* Returns the list of key/value pairs that corresponding to the specified key prefix.
* An empty {@link io.vertx.ext.consul.KeyValueList} object will be returned if no such key prefix is found.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#getValues}
* @param keyPrefix the prefix
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxGetValuesWithOptions(String keyPrefix, io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getValuesWithOptions(keyPrefix, options, fut);
}));
}
/**
* Removes all the key/value pair that corresponding to the specified key prefix
* @param keyPrefix the prefix
* @param resultHandler will be called on complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deleteValues(String keyPrefix, Handler> resultHandler) {
delegate.deleteValues(keyPrefix, resultHandler);
return this;
}
/**
* Removes all the key/value pair that corresponding to the specified key prefix
* @param keyPrefix the prefix
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deleteValues(String keyPrefix) {
return
deleteValues(keyPrefix, ar -> { });
}
/**
* Removes all the key/value pair that corresponding to the specified key prefix
* @param keyPrefix the prefix
* @return reference to this, for fluency
*/
public Single rxDeleteValues(String keyPrefix) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
deleteValues(keyPrefix, fut);
}));
}
/**
* Adds specified key/value pair
* @param key the key
* @param value the value
* @param resultHandler will be provided with success of operation
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient putValue(String key, String value, Handler> resultHandler) {
delegate.putValue(key, value, resultHandler);
return this;
}
/**
* Adds specified key/value pair
* @param key the key
* @param value the value
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient putValue(String key, String value) {
return
putValue(key, value, ar -> { });
}
/**
* Adds specified key/value pair
* @param key the key
* @param value the value
* @return reference to this, for fluency
*/
public Single rxPutValue(String key, String value) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
putValue(key, value, fut);
}));
}
/**
* @param key the key
* @param value the value
* @param options options used to push pair
* @param resultHandler will be provided with success of operation
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient putValueWithOptions(String key, String value, io.vertx.ext.consul.KeyValueOptions options, Handler> resultHandler) {
delegate.putValueWithOptions(key, value, options, resultHandler);
return this;
}
/**
* @param key the key
* @param value the value
* @param options options used to push pair
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient putValueWithOptions(String key, String value, io.vertx.ext.consul.KeyValueOptions options) {
return
putValueWithOptions(key, value, options, ar -> { });
}
/**
* @param key the key
* @param value the value
* @param options options used to push pair
* @return reference to this, for fluency
*/
public Single rxPutValueWithOptions(String key, String value, io.vertx.ext.consul.KeyValueOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
putValueWithOptions(key, value, options, fut);
}));
}
/**
* Manages multiple operations inside a single, atomic transaction.
* @param request transaction request
* @param resultHandler will be provided with result of transaction
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient transaction(io.vertx.ext.consul.TxnRequest request, Handler> resultHandler) {
delegate.transaction(request, resultHandler);
return this;
}
/**
* Manages multiple operations inside a single, atomic transaction.
* @param request transaction request
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient transaction(io.vertx.ext.consul.TxnRequest request) {
return
transaction(request, ar -> { });
}
/**
* Manages multiple operations inside a single, atomic transaction.
* @param request transaction request
* @return reference to this, for fluency
*/
public Single rxTransaction(io.vertx.ext.consul.TxnRequest request) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
transaction(request, fut);
}));
}
/**
* Create new Acl token
* @param token properties of the token
* @param idHandler will be provided with ID of created token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createAclToken(io.vertx.ext.consul.AclToken token, Handler> idHandler) {
delegate.createAclToken(token, idHandler);
return this;
}
/**
* Create new Acl token
* @param token properties of the token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createAclToken(io.vertx.ext.consul.AclToken token) {
return
createAclToken(token, ar -> { });
}
/**
* Create new Acl token
* @param token properties of the token
* @return reference to this, for fluency
*/
public Single rxCreateAclToken(io.vertx.ext.consul.AclToken token) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
createAclToken(token, fut);
}));
}
/**
* Update Acl token
* @param token properties of the token to be updated
* @param idHandler will be provided with ID of updated
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updateAclToken(io.vertx.ext.consul.AclToken token, Handler> idHandler) {
delegate.updateAclToken(token, idHandler);
return this;
}
/**
* Update Acl token
* @param token properties of the token to be updated
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updateAclToken(io.vertx.ext.consul.AclToken token) {
return
updateAclToken(token, ar -> { });
}
/**
* Update Acl token
* @param token properties of the token to be updated
* @return reference to this, for fluency
*/
public Single rxUpdateAclToken(io.vertx.ext.consul.AclToken token) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
updateAclToken(token, fut);
}));
}
/**
* Clone Acl token
* @param id the ID of token to be cloned
* @param idHandler will be provided with ID of cloned token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient cloneAclToken(String id, Handler> idHandler) {
delegate.cloneAclToken(id, idHandler);
return this;
}
/**
* Clone Acl token
* @param id the ID of token to be cloned
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient cloneAclToken(String id) {
return
cloneAclToken(id, ar -> { });
}
/**
* Clone Acl token
* @param id the ID of token to be cloned
* @return reference to this, for fluency
*/
public Single rxCloneAclToken(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
cloneAclToken(id, fut);
}));
}
/**
* Get list of Acl token
* @param resultHandler will be provided with list of tokens
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listAclTokens(Handler>> resultHandler) {
delegate.listAclTokens(resultHandler);
return this;
}
/**
* Get list of Acl token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listAclTokens() {
return
listAclTokens(ar -> { });
}
/**
* Get list of Acl token
* @return reference to this, for fluency
*/
public Single> rxListAclTokens() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listAclTokens(fut);
}));
}
/**
* Get info of Acl token
* @param id the ID of token
* @param tokenHandler will be provided with token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient infoAclToken(String id, Handler> tokenHandler) {
delegate.infoAclToken(id, tokenHandler);
return this;
}
/**
* Get info of Acl token
* @param id the ID of token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient infoAclToken(String id) {
return
infoAclToken(id, ar -> { });
}
/**
* Get info of Acl token
* @param id the ID of token
* @return reference to this, for fluency
*/
public Single rxInfoAclToken(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
infoAclToken(id, fut);
}));
}
/**
* Destroy Acl token
* @param id the ID of token
* @param resultHandler will be called on complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient destroyAclToken(String id, Handler> resultHandler) {
delegate.destroyAclToken(id, resultHandler);
return this;
}
/**
* Destroy Acl token
* @param id the ID of token
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient destroyAclToken(String id) {
return
destroyAclToken(id, ar -> { });
}
/**
* Destroy Acl token
* @param id the ID of token
* @return reference to this, for fluency
*/
public Single rxDestroyAclToken(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
destroyAclToken(id, fut);
}));
}
/**
* Fires a new user event
* @param name name of event
* @param resultHandler will be provided with properties of event
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient fireEvent(String name, Handler> resultHandler) {
delegate.fireEvent(name, resultHandler);
return this;
}
/**
* Fires a new user event
* @param name name of event
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient fireEvent(String name) {
return
fireEvent(name, ar -> { });
}
/**
* Fires a new user event
* @param name name of event
* @return reference to this, for fluency
*/
public Single rxFireEvent(String name) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
fireEvent(name, fut);
}));
}
/**
* Fires a new user event
* @param name name of event
* @param options options used to create event
* @param resultHandler will be provided with properties of event
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient fireEventWithOptions(String name, io.vertx.ext.consul.EventOptions options, Handler> resultHandler) {
delegate.fireEventWithOptions(name, options, resultHandler);
return this;
}
/**
* Fires a new user event
* @param name name of event
* @param options options used to create event
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient fireEventWithOptions(String name, io.vertx.ext.consul.EventOptions options) {
return
fireEventWithOptions(name, options, ar -> { });
}
/**
* Fires a new user event
* @param name name of event
* @param options options used to create event
* @return reference to this, for fluency
*/
public Single rxFireEventWithOptions(String name, io.vertx.ext.consul.EventOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
fireEventWithOptions(name, options, fut);
}));
}
/**
* Returns the most recent events known by the agent
* @param resultHandler will be provided with list of events
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listEvents(Handler> resultHandler) {
delegate.listEvents(resultHandler);
return this;
}
/**
* Returns the most recent events known by the agent
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listEvents() {
return
listEvents(ar -> { });
}
/**
* Returns the most recent events known by the agent
* @return reference to this, for fluency
*/
public Single rxListEvents() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listEvents(fut);
}));
}
/**
* Returns the most recent events known by the agent.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#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.
* @param options the blocking options
* @param resultHandler will be provided with list of events
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listEventsWithOptions(io.vertx.ext.consul.EventListOptions options, Handler> resultHandler) {
delegate.listEventsWithOptions(options, resultHandler);
return this;
}
/**
* Returns the most recent events known by the agent.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#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.
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listEventsWithOptions(io.vertx.ext.consul.EventListOptions options) {
return
listEventsWithOptions(options, ar -> { });
}
/**
* Returns the most recent events known by the agent.
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#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.
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxListEventsWithOptions(io.vertx.ext.consul.EventListOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listEventsWithOptions(options, fut);
}));
}
/**
* Adds a new service, with an optional health check, to the local agent.
* @param serviceOptions the options of new service
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient registerService(io.vertx.ext.consul.ServiceOptions serviceOptions, Handler> resultHandler) {
delegate.registerService(serviceOptions, resultHandler);
return this;
}
/**
* Adds a new service, with an optional health check, to the local agent.
* @param serviceOptions the options of new service
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient registerService(io.vertx.ext.consul.ServiceOptions serviceOptions) {
return
registerService(serviceOptions, ar -> { });
}
/**
* Adds a new service, with an optional health check, to the local agent.
* @param serviceOptions the options of new service
* @return reference to this, for fluency
*/
public Single rxRegisterService(io.vertx.ext.consul.ServiceOptions serviceOptions) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
registerService(serviceOptions, fut);
}));
}
/**
* Places a given service into "maintenance mode"
* @param maintenanceOptions the maintenance options
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient maintenanceService(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions, Handler> resultHandler) {
delegate.maintenanceService(maintenanceOptions, resultHandler);
return this;
}
/**
* Places a given service into "maintenance mode"
* @param maintenanceOptions the maintenance options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient maintenanceService(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions) {
return
maintenanceService(maintenanceOptions, ar -> { });
}
/**
* Places a given service into "maintenance mode"
* @param maintenanceOptions the maintenance options
* @return reference to this, for fluency
*/
public Single rxMaintenanceService(io.vertx.ext.consul.MaintenanceOptions maintenanceOptions) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
maintenanceService(maintenanceOptions, fut);
}));
}
/**
* 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.
* @param id the ID of service
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deregisterService(String id, Handler> resultHandler) {
delegate.deregisterService(id, resultHandler);
return this;
}
/**
* 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.
* @param id the ID of service
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deregisterService(String id) {
return
deregisterService(id, ar -> { });
}
/**
* 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.
* @param id the ID of service
* @return reference to this, for fluency
*/
public Single rxDeregisterService(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
deregisterService(id, fut);
}));
}
/**
* Returns the nodes providing a service
* @param service name of service
* @param resultHandler will be provided with list of nodes providing given service
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServiceNodes(String service, Handler> resultHandler) {
delegate.catalogServiceNodes(service, resultHandler);
return this;
}
/**
* Returns the nodes providing a service
* @param service name of service
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServiceNodes(String service) {
return
catalogServiceNodes(service, ar -> { });
}
/**
* Returns the nodes providing a service
* @param service name of service
* @return reference to this, for fluency
*/
public Single rxCatalogServiceNodes(String service) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogServiceNodes(service, fut);
}));
}
/**
* Returns the nodes providing a service
* @param service name of service
* @param options options used to request services
* @param resultHandler will be provided with list of nodes providing given service
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServiceNodesWithOptions(String service, io.vertx.ext.consul.ServiceQueryOptions options, Handler> resultHandler) {
delegate.catalogServiceNodesWithOptions(service, options, resultHandler);
return this;
}
/**
* Returns the nodes providing a service
* @param service name of service
* @param options options used to request services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServiceNodesWithOptions(String service, io.vertx.ext.consul.ServiceQueryOptions options) {
return
catalogServiceNodesWithOptions(service, options, ar -> { });
}
/**
* Returns the nodes providing a service
* @param service name of service
* @param options options used to request services
* @return reference to this, for fluency
*/
public Single rxCatalogServiceNodesWithOptions(String service, io.vertx.ext.consul.ServiceQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogServiceNodesWithOptions(service, options, fut);
}));
}
/**
* Return all the datacenters that are known by the Consul server
* @param resultHandler will be provided with list of datacenters
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogDatacenters(Handler>> resultHandler) {
delegate.catalogDatacenters(resultHandler);
return this;
}
/**
* Return all the datacenters that are known by the Consul server
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogDatacenters() {
return
catalogDatacenters(ar -> { });
}
/**
* Return all the datacenters that are known by the Consul server
* @return reference to this, for fluency
*/
public Single> rxCatalogDatacenters() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogDatacenters(fut);
}));
}
/**
* Returns the nodes registered in a datacenter
* @param resultHandler will be provided with list of nodes
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodes(Handler> resultHandler) {
delegate.catalogNodes(resultHandler);
return this;
}
/**
* Returns the nodes registered in a datacenter
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodes() {
return
catalogNodes(ar -> { });
}
/**
* Returns the nodes registered in a datacenter
* @return reference to this, for fluency
*/
public Single rxCatalogNodes() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogNodes(fut);
}));
}
/**
* Returns the nodes registered in a datacenter
* @param options options used to request nodes
* @param resultHandler will be provided with list of nodes
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodesWithOptions(io.vertx.ext.consul.NodeQueryOptions options, Handler> resultHandler) {
delegate.catalogNodesWithOptions(options, resultHandler);
return this;
}
/**
* Returns the nodes registered in a datacenter
* @param options options used to request nodes
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodesWithOptions(io.vertx.ext.consul.NodeQueryOptions options) {
return
catalogNodesWithOptions(options, ar -> { });
}
/**
* Returns the nodes registered in a datacenter
* @param options options used to request nodes
* @return reference to this, for fluency
*/
public Single rxCatalogNodesWithOptions(io.vertx.ext.consul.NodeQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogNodesWithOptions(options, fut);
}));
}
/**
* Returns the checks associated with the service
* @param service the service name
* @param resultHandler will be provided with list of checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthChecks(String service, Handler> resultHandler) {
delegate.healthChecks(service, resultHandler);
return this;
}
/**
* Returns the checks associated with the service
* @param service the service name
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthChecks(String service) {
return
healthChecks(service, ar -> { });
}
/**
* Returns the checks associated with the service
* @param service the service name
* @return reference to this, for fluency
*/
public Single rxHealthChecks(String service) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
healthChecks(service, fut);
}));
}
/**
* Returns the checks associated with the service
* @param service the service name
* @param options options used to request checks
* @param resultHandler will be provided with list of checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthChecksWithOptions(String service, io.vertx.ext.consul.CheckQueryOptions options, Handler> resultHandler) {
delegate.healthChecksWithOptions(service, options, resultHandler);
return this;
}
/**
* Returns the checks associated with the service
* @param service the service name
* @param options options used to request checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthChecksWithOptions(String service, io.vertx.ext.consul.CheckQueryOptions options) {
return
healthChecksWithOptions(service, options, ar -> { });
}
/**
* Returns the checks associated with the service
* @param service the service name
* @param options options used to request checks
* @return reference to this, for fluency
*/
public Single rxHealthChecksWithOptions(String service, io.vertx.ext.consul.CheckQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
healthChecksWithOptions(service, options, fut);
}));
}
/**
* Returns the checks in the specified status
* @param healthState the health state
* @param resultHandler will be provided with list of checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthState(io.vertx.ext.consul.HealthState healthState, Handler> resultHandler) {
delegate.healthState(healthState, resultHandler);
return this;
}
/**
* Returns the checks in the specified status
* @param healthState the health state
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthState(io.vertx.ext.consul.HealthState healthState) {
return
healthState(healthState, ar -> { });
}
/**
* Returns the checks in the specified status
* @param healthState the health state
* @return reference to this, for fluency
*/
public Single rxHealthState(io.vertx.ext.consul.HealthState healthState) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
healthState(healthState, fut);
}));
}
/**
* Returns the checks in the specified status
* @param healthState the health state
* @param options options used to request checks
* @param resultHandler will be provided with list of checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthStateWithOptions(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options, Handler> resultHandler) {
delegate.healthStateWithOptions(healthState, options, resultHandler);
return this;
}
/**
* Returns the checks in the specified status
* @param healthState the health state
* @param options options used to request checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthStateWithOptions(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options) {
return
healthStateWithOptions(healthState, options, ar -> { });
}
/**
* Returns the checks in the specified status
* @param healthState the health state
* @param options options used to request checks
* @return reference to this, for fluency
*/
public Single rxHealthStateWithOptions(io.vertx.ext.consul.HealthState healthState, io.vertx.ext.consul.CheckQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
healthStateWithOptions(healthState, options, fut);
}));
}
/**
* Returns the nodes providing the service. This endpoint is very similar to the {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServiceNodes} endpoint;
* however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
* @param service the service name
* @param passing if true, filter results to only nodes with all checks in the passing state
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthServiceNodes(String service, boolean passing, Handler> resultHandler) {
delegate.healthServiceNodes(service, passing, resultHandler);
return this;
}
/**
* Returns the nodes providing the service. This endpoint is very similar to the {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServiceNodes} endpoint;
* however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
* @param service the service name
* @param passing if true, filter results to only nodes with all checks in the passing state
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthServiceNodes(String service, boolean passing) {
return
healthServiceNodes(service, passing, ar -> { });
}
/**
* Returns the nodes providing the service. This endpoint is very similar to the {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServiceNodes} endpoint;
* however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
* @param service the service name
* @param passing if true, filter results to only nodes with all checks in the passing state
* @return reference to this, for fluency
*/
public Single rxHealthServiceNodes(String service, boolean passing) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
healthServiceNodes(service, passing, fut);
}));
}
/**
* Returns the nodes providing the service. This endpoint is very similar to the {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServiceNodesWithOptions} endpoint;
* however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
* @param service the service name
* @param passing if true, filter results to only nodes with all checks in the passing state
* @param options options used to request services
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthServiceNodesWithOptions(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options, Handler> resultHandler) {
delegate.healthServiceNodesWithOptions(service, passing, options, resultHandler);
return this;
}
/**
* Returns the nodes providing the service. This endpoint is very similar to the {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServiceNodesWithOptions} endpoint;
* however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
* @param service the service name
* @param passing if true, filter results to only nodes with all checks in the passing state
* @param options options used to request services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient healthServiceNodesWithOptions(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options) {
return
healthServiceNodesWithOptions(service, passing, options, ar -> { });
}
/**
* Returns the nodes providing the service. This endpoint is very similar to the {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServiceNodesWithOptions} endpoint;
* however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.
* @param service the service name
* @param passing if true, filter results to only nodes with all checks in the passing state
* @param options options used to request services
* @return reference to this, for fluency
*/
public Single rxHealthServiceNodesWithOptions(String service, boolean passing, io.vertx.ext.consul.ServiceQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
healthServiceNodesWithOptions(service, passing, options, fut);
}));
}
/**
* Returns the services registered in a datacenter
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServices(Handler> resultHandler) {
delegate.catalogServices(resultHandler);
return this;
}
/**
* Returns the services registered in a datacenter
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServices() {
return
catalogServices(ar -> { });
}
/**
* Returns the services registered in a datacenter
* @return reference to this, for fluency
*/
public Single rxCatalogServices() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogServices(fut);
}));
}
/**
* Returns the services registered in a datacenter
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServices}
* @param options the blocking options
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServicesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.catalogServicesWithOptions(options, resultHandler);
return this;
}
/**
* Returns the services registered in a datacenter
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServices}
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogServicesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options) {
return
catalogServicesWithOptions(options, ar -> { });
}
/**
* Returns the services registered in a datacenter
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogServices}
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxCatalogServicesWithOptions(io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogServicesWithOptions(options, fut);
}));
}
/**
* Returns the node's registered services
* @param node node name
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodeServices(String node, Handler> resultHandler) {
delegate.catalogNodeServices(node, resultHandler);
return this;
}
/**
* Returns the node's registered services
* @param node node name
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodeServices(String node) {
return
catalogNodeServices(node, ar -> { });
}
/**
* Returns the node's registered services
* @param node node name
* @return reference to this, for fluency
*/
public Single rxCatalogNodeServices(String node) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogNodeServices(node, fut);
}));
}
/**
* Returns the node's registered services
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogNodeServices}
* @param node node name
* @param options the blocking options
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodeServicesWithOptions(String node, io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.catalogNodeServicesWithOptions(node, options, resultHandler);
return this;
}
/**
* Returns the node's registered services
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogNodeServices}
* @param node node name
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient catalogNodeServicesWithOptions(String node, io.vertx.ext.consul.BlockingQueryOptions options) {
return
catalogNodeServicesWithOptions(node, options, ar -> { });
}
/**
* Returns the node's registered services
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#catalogNodeServices}
* @param node node name
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxCatalogNodeServicesWithOptions(String node, io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
catalogNodeServicesWithOptions(node, options, fut);
}));
}
/**
* Returns list of services registered with the local agent.
* @param resultHandler will be provided with list of services
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient localServices(Handler>> resultHandler) {
delegate.localServices(resultHandler);
return this;
}
/**
* Returns list of services registered with the local agent.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient localServices() {
return
localServices(ar -> { });
}
/**
* Returns list of services registered with the local agent.
* @return reference to this, for fluency
*/
public Single> rxLocalServices() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
localServices(fut);
}));
}
/**
* Return all the checks that are registered with the local agent.
* @param resultHandler will be provided with list of checks
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient localChecks(Handler>> resultHandler) {
delegate.localChecks(resultHandler);
return this;
}
/**
* Return all the checks that are registered with the local agent.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient localChecks() {
return
localChecks(ar -> { });
}
/**
* Return all the checks that are registered with the local agent.
* @return reference to this, for fluency
*/
public Single> rxLocalChecks() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
localChecks(fut);
}));
}
/**
* 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.
* @param checkOptions options used to register new check
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient registerCheck(io.vertx.ext.consul.CheckOptions checkOptions, Handler> resultHandler) {
delegate.registerCheck(checkOptions, resultHandler);
return this;
}
/**
* 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.
* @param checkOptions options used to register new check
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient registerCheck(io.vertx.ext.consul.CheckOptions checkOptions) {
return
registerCheck(checkOptions, ar -> { });
}
/**
* 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.
* @param checkOptions options used to register new check
* @return reference to this, for fluency
*/
public Single rxRegisterCheck(io.vertx.ext.consul.CheckOptions checkOptions) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
registerCheck(checkOptions, fut);
}));
}
/**
* Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.
* @param checkId the ID of check
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deregisterCheck(String checkId, Handler> resultHandler) {
delegate.deregisterCheck(checkId, resultHandler);
return this;
}
/**
* Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deregisterCheck(String checkId) {
return
deregisterCheck(checkId, ar -> { });
}
/**
* Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public Single rxDeregisterCheck(String checkId) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
deregisterCheck(checkId, fut);
}));
}
/**
* Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient passCheck(String checkId, Handler> resultHandler) {
delegate.passCheck(checkId, resultHandler);
return this;
}
/**
* Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient passCheck(String checkId) {
return
passCheck(checkId, ar -> { });
}
/**
* Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public Single rxPassCheck(String checkId) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
passCheck(checkId, fut);
}));
}
/**
* Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient passCheckWithNote(String checkId, String note, Handler> resultHandler) {
delegate.passCheckWithNote(checkId, note, resultHandler);
return this;
}
/**
* Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient passCheckWithNote(String checkId, String note) {
return
passCheckWithNote(checkId, note, ar -> { });
}
/**
* Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public Single rxPassCheckWithNote(String checkId, String note) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
passCheckWithNote(checkId, note, fut);
}));
}
/**
* Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient warnCheck(String checkId, Handler> resultHandler) {
delegate.warnCheck(checkId, resultHandler);
return this;
}
/**
* Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient warnCheck(String checkId) {
return
warnCheck(checkId, ar -> { });
}
/**
* Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public Single rxWarnCheck(String checkId) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
warnCheck(checkId, fut);
}));
}
/**
* Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient warnCheckWithNote(String checkId, String note, Handler> resultHandler) {
delegate.warnCheckWithNote(checkId, note, resultHandler);
return this;
}
/**
* Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient warnCheckWithNote(String checkId, String note) {
return
warnCheckWithNote(checkId, note, ar -> { });
}
/**
* Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public Single rxWarnCheckWithNote(String checkId, String note) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
warnCheckWithNote(checkId, note, fut);
}));
}
/**
* Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient failCheck(String checkId, Handler> resultHandler) {
delegate.failCheck(checkId, resultHandler);
return this;
}
/**
* Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient failCheck(String checkId) {
return
failCheck(checkId, ar -> { });
}
/**
* Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @return reference to this, for fluency
*/
public Single rxFailCheck(String checkId) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
failCheck(checkId, fut);
}));
}
/**
* Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient failCheckWithNote(String checkId, String note, Handler> resultHandler) {
delegate.failCheckWithNote(checkId, note, resultHandler);
return this;
}
/**
* Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient failCheckWithNote(String checkId, String note) {
return
failCheckWithNote(checkId, note, ar -> { });
}
/**
* Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public Single rxFailCheckWithNote(String checkId, String note) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
failCheckWithNote(checkId, note, fut);
}));
}
/**
* Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param status new status of check
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updateCheck(String checkId, io.vertx.ext.consul.CheckStatus status, Handler> resultHandler) {
delegate.updateCheck(checkId, status, resultHandler);
return this;
}
/**
* Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param status new status of check
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updateCheck(String checkId, io.vertx.ext.consul.CheckStatus status) {
return
updateCheck(checkId, status, ar -> { });
}
/**
* Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param status new status of check
* @return reference to this, for fluency
*/
public Single rxUpdateCheck(String checkId, io.vertx.ext.consul.CheckStatus status) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
updateCheck(checkId, status, fut);
}));
}
/**
* Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param status new status of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updateCheckWithNote(String checkId, io.vertx.ext.consul.CheckStatus status, String note, Handler> resultHandler) {
delegate.updateCheckWithNote(checkId, status, note, resultHandler);
return this;
}
/**
* Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param status new status of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updateCheckWithNote(String checkId, io.vertx.ext.consul.CheckStatus status, String note) {
return
updateCheckWithNote(checkId, status, note, ar -> { });
}
/**
* Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset.
* @param checkId the ID of check
* @param status new status of check
* @param note specifies a human-readable message. This will be passed through to the check's Output field.
* @return reference to this, for fluency
*/
public Single rxUpdateCheckWithNote(String checkId, io.vertx.ext.consul.CheckStatus status, String note) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
updateCheckWithNote(checkId, status, note, fut);
}));
}
/**
* Get the Raft leader for the datacenter in which the agent is running.
* It returns an address in format "10.1.10.12:8300"
* @param resultHandler will be provided with address of cluster leader
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient leaderStatus(Handler> resultHandler) {
delegate.leaderStatus(resultHandler);
return this;
}
/**
* Get the Raft leader for the datacenter in which the agent is running.
* It returns an address in format "10.1.10.12:8300"
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient leaderStatus() {
return
leaderStatus(ar -> { });
}
/**
* Get the Raft leader for the datacenter in which the agent is running.
* It returns an address in format "10.1.10.12:8300"
* @return reference to this, for fluency
*/
public Single rxLeaderStatus() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
leaderStatus(fut);
}));
}
/**
* 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"
* @param resultHandler will be provided with list of peers
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient peersStatus(Handler>> resultHandler) {
delegate.peersStatus(resultHandler);
return this;
}
/**
* 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"
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient peersStatus() {
return
peersStatus(ar -> { });
}
/**
* 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"
* @return reference to this, for fluency
*/
public Single> rxPeersStatus() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
peersStatus(fut);
}));
}
/**
* Initialize a new session
* @param idHandler will be provided with ID of new session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createSession(Handler> idHandler) {
delegate.createSession(idHandler);
return this;
}
/**
* Initialize a new session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createSession() {
return
createSession(ar -> { });
}
/**
* Initialize a new session
* @return reference to this, for fluency
*/
public Single rxCreateSession() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
createSession(fut);
}));
}
/**
* Initialize a new session
* @param options options used to create session
* @param idHandler will be provided with ID of new session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createSessionWithOptions(io.vertx.ext.consul.SessionOptions options, Handler> idHandler) {
delegate.createSessionWithOptions(options, idHandler);
return this;
}
/**
* Initialize a new session
* @param options options used to create session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createSessionWithOptions(io.vertx.ext.consul.SessionOptions options) {
return
createSessionWithOptions(options, ar -> { });
}
/**
* Initialize a new session
* @param options options used to create session
* @return reference to this, for fluency
*/
public Single rxCreateSessionWithOptions(io.vertx.ext.consul.SessionOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
createSessionWithOptions(options, fut);
}));
}
/**
* Returns the requested session information
* @param id the ID of requested session
* @param resultHandler will be provided with info of requested session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient infoSession(String id, Handler> resultHandler) {
delegate.infoSession(id, resultHandler);
return this;
}
/**
* Returns the requested session information
* @param id the ID of requested session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient infoSession(String id) {
return
infoSession(id, ar -> { });
}
/**
* Returns the requested session information
* @param id the ID of requested session
* @return reference to this, for fluency
*/
public Single rxInfoSession(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
infoSession(id, fut);
}));
}
/**
* Returns the requested session information
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#infoSession}
* @param id the ID of requested session
* @param options the blocking options
* @param resultHandler will be provided with info of requested session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient infoSessionWithOptions(String id, io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.infoSessionWithOptions(id, options, resultHandler);
return this;
}
/**
* Returns the requested session information
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#infoSession}
* @param id the ID of requested session
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient infoSessionWithOptions(String id, io.vertx.ext.consul.BlockingQueryOptions options) {
return
infoSessionWithOptions(id, options, ar -> { });
}
/**
* Returns the requested session information
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#infoSession}
* @param id the ID of requested session
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxInfoSessionWithOptions(String id, io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
infoSessionWithOptions(id, options, fut);
}));
}
/**
* Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL
* @param id the ID of session that should be renewed
* @param resultHandler will be provided with info of renewed session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient renewSession(String id, Handler> resultHandler) {
delegate.renewSession(id, resultHandler);
return this;
}
/**
* Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL
* @param id the ID of session that should be renewed
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient renewSession(String id) {
return
renewSession(id, ar -> { });
}
/**
* Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL
* @param id the ID of session that should be renewed
* @return reference to this, for fluency
*/
public Single rxRenewSession(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
renewSession(id, fut);
}));
}
/**
* Returns the active sessions
* @param resultHandler will be provided with list of sessions
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listSessions(Handler> resultHandler) {
delegate.listSessions(resultHandler);
return this;
}
/**
* Returns the active sessions
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listSessions() {
return
listSessions(ar -> { });
}
/**
* Returns the active sessions
* @return reference to this, for fluency
*/
public Single rxListSessions() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listSessions(fut);
}));
}
/**
* Returns the active sessions
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#listSessions}
* @param options the blocking options
* @param resultHandler will be provided with list of sessions
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listSessionsWithOptions(io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.listSessionsWithOptions(options, resultHandler);
return this;
}
/**
* Returns the active sessions
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#listSessions}
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listSessionsWithOptions(io.vertx.ext.consul.BlockingQueryOptions options) {
return
listSessionsWithOptions(options, ar -> { });
}
/**
* Returns the active sessions
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#listSessions}
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxListSessionsWithOptions(io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listSessionsWithOptions(options, fut);
}));
}
/**
* Returns the active sessions for a given node
* @param nodeId the ID of node
* @param resultHandler will be provided with list of sessions
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listNodeSessions(String nodeId, Handler> resultHandler) {
delegate.listNodeSessions(nodeId, resultHandler);
return this;
}
/**
* Returns the active sessions for a given node
* @param nodeId the ID of node
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listNodeSessions(String nodeId) {
return
listNodeSessions(nodeId, ar -> { });
}
/**
* Returns the active sessions for a given node
* @param nodeId the ID of node
* @return reference to this, for fluency
*/
public Single rxListNodeSessions(String nodeId) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listNodeSessions(nodeId, fut);
}));
}
/**
* Returns the active sessions for a given node
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#listNodeSessions}
* @param nodeId the ID of node
* @param options the blocking options
* @param resultHandler will be provided with list of sessions
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listNodeSessionsWithOptions(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options, Handler> resultHandler) {
delegate.listNodeSessionsWithOptions(nodeId, options, resultHandler);
return this;
}
/**
* Returns the active sessions for a given node
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#listNodeSessions}
* @param nodeId the ID of node
* @param options the blocking options
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient listNodeSessionsWithOptions(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options) {
return
listNodeSessionsWithOptions(nodeId, options, ar -> { });
}
/**
* Returns the active sessions for a given node
* This is blocking query unlike {@link io.vertx.rxjava.ext.consul.ConsulClient#listNodeSessions}
* @param nodeId the ID of node
* @param options the blocking options
* @return reference to this, for fluency
*/
public Single rxListNodeSessionsWithOptions(String nodeId, io.vertx.ext.consul.BlockingQueryOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
listNodeSessionsWithOptions(nodeId, options, fut);
}));
}
/**
* Destroys the given session
* @param id the ID of session
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient destroySession(String id, Handler> resultHandler) {
delegate.destroySession(id, resultHandler);
return this;
}
/**
* Destroys the given session
* @param id the ID of session
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient destroySession(String id) {
return
destroySession(id, ar -> { });
}
/**
* Destroys the given session
* @param id the ID of session
* @return reference to this, for fluency
*/
public Single rxDestroySession(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
destroySession(id, fut);
}));
}
/**
* @param definition definition of the prepare query
* @param resultHandler will be provided with id of created prepare query
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createPreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition, Handler> resultHandler) {
delegate.createPreparedQuery(definition, resultHandler);
return this;
}
/**
* @param definition definition of the prepare query
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient createPreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition) {
return
createPreparedQuery(definition, ar -> { });
}
/**
* @param definition definition of the prepare query
* @return reference to this, for fluency
*/
public Single rxCreatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
createPreparedQuery(definition, fut);
}));
}
/**
* Returns an existing prepared query
* @param id the id of the query to read
* @param resultHandler will be provided with definition of the prepare query
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getPreparedQuery(String id, Handler> resultHandler) {
delegate.getPreparedQuery(id, resultHandler);
return this;
}
/**
* Returns an existing prepared query
* @param id the id of the query to read
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getPreparedQuery(String id) {
return
getPreparedQuery(id, ar -> { });
}
/**
* Returns an existing prepared query
* @param id the id of the query to read
* @return reference to this, for fluency
*/
public Single rxGetPreparedQuery(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getPreparedQuery(id, fut);
}));
}
/**
* Returns a list of all prepared queries.
* @param resultHandler will be provided with list of definitions of the all prepare queries
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getAllPreparedQueries(Handler>> resultHandler) {
delegate.getAllPreparedQueries(resultHandler);
return this;
}
/**
* Returns a list of all prepared queries.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient getAllPreparedQueries() {
return
getAllPreparedQueries(ar -> { });
}
/**
* Returns a list of all prepared queries.
* @return reference to this, for fluency
*/
public Single> rxGetAllPreparedQueries() {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
getAllPreparedQueries(fut);
}));
}
/**
* @param definition definition of the prepare query
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition, Handler> resultHandler) {
delegate.updatePreparedQuery(definition, resultHandler);
return this;
}
/**
* @param definition definition of the prepare query
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient updatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition) {
return
updatePreparedQuery(definition, ar -> { });
}
/**
* @param definition definition of the prepare query
* @return reference to this, for fluency
*/
public Single rxUpdatePreparedQuery(io.vertx.ext.consul.PreparedQueryDefinition definition) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
updatePreparedQuery(definition, fut);
}));
}
/**
* Deletes an existing prepared query
* @param id the id of the query to delete
* @param resultHandler will be called when complete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deletePreparedQuery(String id, Handler> resultHandler) {
delegate.deletePreparedQuery(id, resultHandler);
return this;
}
/**
* Deletes an existing prepared query
* @param id the id of the query to delete
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient deletePreparedQuery(String id) {
return
deletePreparedQuery(id, ar -> { });
}
/**
* Deletes an existing prepared query
* @param id the id of the query to delete
* @return reference to this, for fluency
*/
public Single rxDeletePreparedQuery(String id) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
deletePreparedQuery(id, fut);
}));
}
/**
* Executes an existing prepared query.
* @param 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.
* @param resultHandler will be provided with response
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient executePreparedQuery(String query, Handler> resultHandler) {
delegate.executePreparedQuery(query, resultHandler);
return this;
}
/**
* Executes an existing prepared query.
* @param 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.
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient executePreparedQuery(String query) {
return
executePreparedQuery(query, ar -> { });
}
/**
* Executes an existing prepared query.
* @param 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.
* @return reference to this, for fluency
*/
public Single rxExecutePreparedQuery(String query) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
executePreparedQuery(query, fut);
}));
}
/**
* Executes an existing prepared query.
* @param 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.
* @param options the options used to execute prepared query
* @param resultHandler will be provided with response
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient executePreparedQueryWithOptions(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options, Handler> resultHandler) {
delegate.executePreparedQueryWithOptions(query, options, resultHandler);
return this;
}
/**
* Executes an existing prepared query.
* @param 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.
* @param options the options used to execute prepared query
* @return reference to this, for fluency
*/
public io.vertx.rxjava.ext.consul.ConsulClient executePreparedQueryWithOptions(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options) {
return
executePreparedQueryWithOptions(query, options, ar -> { });
}
/**
* Executes an existing prepared query.
* @param 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.
* @param options the options used to execute prepared query
* @return reference to this, for fluency
*/
public Single rxExecutePreparedQueryWithOptions(String query, io.vertx.ext.consul.PreparedQueryExecuteOptions options) {
return Single.create(new SingleOnSubscribeAdapter<>(fut -> {
executePreparedQueryWithOptions(query, options, fut);
}));
}
/**
* Close the client and release its resources
*/
public void close() {
delegate.close();
}
public static ConsulClient newInstance(io.vertx.ext.consul.ConsulClient arg) {
return arg != null ? new ConsulClient(arg) : null;
}
}