Modifier and Type | Method and Description |
---|---|
void |
AmqpBridge.close(Handler<AsyncResult<Void>> resultHandler)
Shuts the bridge down, closing the underlying connection.
|
void |
AmqpBridge.start(String hostname,
int port,
Handler<AsyncResult<AmqpBridge>> resultHandler)
Starts the bridge, establishing the underlying connection.
|
void |
AmqpBridge.start(String hostname,
int port,
String username,
String password,
Handler<AsyncResult<AmqpBridge>> resultHandler)
Starts the bridge, establishing the underlying connection.
|
Modifier and Type | Method and Description |
---|---|
CamelBridge |
CamelBridge.start(Handler<AsyncResult<Void>> completed)
Starts the bridge.
|
CamelBridge |
CamelBridge.stop(Handler<AsyncResult<Void>> completed)
Stops the bridge.
|
Modifier and Type | Method and Description |
---|---|
CircuitBreaker |
CircuitBreaker.closeHandler(Handler<Void> handler)
Sets a
Handler invoked when the circuit breaker state switches to close. |
<T> Future<T> |
CircuitBreaker.execute(Handler<Future<T>> operation)
Same as
CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker default fallback. |
<T> CircuitBreaker |
CircuitBreaker.executeAndReport(Future<T> resultFuture,
Handler<Future<T>> operation)
Same as
CircuitBreaker.executeAndReportWithFallback(Future, Handler, Function) but using the circuit breaker default
fallback. |
<T> CircuitBreaker |
CircuitBreaker.executeAndReportWithFallback(Future<T> resultFuture,
Handler<Future<T>> operation,
java.util.function.Function<Throwable,T> fallback)
Executes the given operation with the circuit breaker control.
|
<T> Future<T> |
CircuitBreaker.executeWithFallback(Handler<Future<T>> operation,
java.util.function.Function<Throwable,T> fallback)
Executes the given operation with the circuit breaker control.
|
CircuitBreaker |
CircuitBreaker.halfOpenHandler(Handler<Void> handler)
Sets a
Handler invoked when the circuit breaker state switches to half-open. |
CircuitBreaker |
CircuitBreaker.openHandler(Handler<Void> handler)
Sets a
Handler invoked when the circuit breaker state switches to open. |
Modifier and Type | Interface and Description |
---|---|
interface |
AsyncResultHandler<T>
Handler for
AsyncResult |
Modifier and Type | Class and Description |
---|---|
class |
VoidHandler
This class can be used for simple handlers which don't receive any value.
|
Modifier and Type | Method and Description |
---|---|
default Handler<AsyncResult<T>> |
Future.completer() |
Handler<Throwable> |
Context.exceptionHandler() |
Handler<Throwable> |
Vertx.exceptionHandler() |
Modifier and Type | Method and Description |
---|---|
void |
Closeable.close(Handler<AsyncResult<Void>> completionHandler) |
void |
Vertx.close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.close() but the completionHandler will be called when the close is complete |
static void |
Vertx.clusteredVertx(VertxOptions options,
Handler<AsyncResult<Vertx>> resultHandler)
Creates a clustered instance using the specified options.
|
default <U> Future<U> |
Future.compose(Handler<T> handler,
Future<U> composed)
Compose this future with a provided
next future. |
void |
Vertx.deployVerticle(String name,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(String, Handler) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(String name,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(String) but the completionHandler will be notified when the deployment is complete. |
void |
Vertx.deployVerticle(Verticle verticle,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, Handler) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(Verticle verticle,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle) but the completionHandler will be notified when the deployment is complete. |
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
Context |
Context.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called when the context runs an action throwing an uncaught throwable.
When this handler is called,
Vertx.currentContext() will return this context. |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
Vertx |
Vertx.exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context , set on Context.exceptionHandler(Handler) at creation. |
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Invoke
Context.executeBlocking(Handler, boolean, Handler) with order = true. |
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Invoke
Context.executeBlocking(Handler, boolean, Handler) with order = true. |
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
default <T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
WorkerExecutor.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
default <T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
WorkerExecutor.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
TimeoutStream |
TimeoutStream.handler(Handler<Long> handler) |
void |
Context.runOnContext(Handler<Void> action)
Run the specified action asynchronously on the same context, some time after the current execution has completed.
|
void |
Vertx.runOnContext(Handler<Void> action)
Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all
preceeding events have been handled.
|
CompositeFuture |
CompositeFuture.setHandler(Handler<AsyncResult<CompositeFuture>> handler) |
Future<T> |
Future.setHandler(Handler<AsyncResult<T>> handler)
Set a handler for the result.
|
long |
Vertx.setPeriodic(long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds, at which point handler will be called with
the id of the timer. |
long |
Vertx.setTimer(long delay,
Handler<Long> handler)
Set a one-shot timer to fire after
delay milliseconds, at which point handler will be called with
the id of the timer. |
void |
Vertx.undeploy(String deploymentID,
Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.undeploy(String) but the completionHandler will be notified when the undeployment is complete. |
Modifier and Type | Method and Description |
---|---|
DatagramSocket |
DatagramSocket.blockMulticastGroup(String multicastAddress,
String sourceToBlock,
Handler<AsyncResult<DatagramSocket>> handler)
Block the given address for the given multicast address and notifies the
Handler once
the operation completes. |
DatagramSocket |
DatagramSocket.blockMulticastGroup(String multicastAddress,
String networkInterface,
String sourceToBlock,
Handler<AsyncResult<DatagramSocket>> handler)
Block the given address for the given multicast address on the given network interface and notifies
the
Handler once the operation completes. |
void |
DatagramSocket.close(Handler<AsyncResult<Void>> handler)
Closes the
DatagramSocket implementation asynchronous
and notifies the handler once done. |
PacketWritestream |
PacketWritestream.drainHandler(Handler<Void> handler) |
DatagramSocket |
DatagramSocket.endHandler(Handler<Void> endHandler) |
DatagramSocket |
DatagramSocket.exceptionHandler(Handler<Throwable> handler) |
PacketWritestream |
PacketWritestream.exceptionHandler(Handler<Throwable> handler) |
DatagramSocket |
DatagramSocket.handler(Handler<DatagramPacket> handler) |
DatagramSocket |
DatagramSocket.listen(int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Start listening on the given port and host.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
Handler<AsyncResult<DatagramSocket>> handler)
Joins a multicast group and listens for packets send to it.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<DatagramSocket>> handler)
Joins a multicast group and listens for packets send to it on the given network interface.
|
DatagramSocket |
DatagramSocket.send(Buffer packet,
int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Write the given
Buffer to the SocketAddress . |
DatagramSocket |
DatagramSocket.send(String str,
int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Write the given
String to the SocketAddress using UTF8 encoding. |
DatagramSocket |
DatagramSocket.send(String str,
String enc,
int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Write the given
String to the SocketAddress using the given encoding. |
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
Handler<AsyncResult<DatagramSocket>> handler)
Leaves a multicast group and stops listening for packets send to it.
|
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<DatagramSocket>> handler)
Leaves a multicast group and stops listening for packets send to it on the given network interface.
|
Modifier and Type | Method and Description |
---|---|
DnsClient |
DnsClient.lookup(String name,
Handler<AsyncResult<String>> handler)
Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
|
DnsClient |
DnsClient.lookup4(String name,
Handler<AsyncResult<String>> handler)
Try to lookup the A (ipv4) record for the given name.
|
DnsClient |
DnsClient.lookup6(String name,
Handler<AsyncResult<String>> handler)
Try to lookup the AAAA (ipv6) record for the given name.
|
DnsClient |
DnsClient.resolveA(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve all A (ipv4) records for the given name.
|
DnsClient |
DnsClient.resolveAAAA(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve all AAAA (ipv6) records for the given name.
|
DnsClient |
DnsClient.resolveCNAME(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve the CNAME record for the given name.
|
DnsClient |
DnsClient.resolveMX(String name,
Handler<AsyncResult<List<MxRecord>>> handler)
Try to resolve the MX records for the given name.
|
DnsClient |
DnsClient.resolveNS(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve the NS records for the given name.
|
DnsClient |
DnsClient.resolvePTR(String name,
Handler<AsyncResult<String>> handler)
Try to resolve the PTR record for the given name.
|
DnsClient |
DnsClient.resolveSRV(String name,
Handler<AsyncResult<List<SrvRecord>>> handler)
Try to resolve the SRV records for the given name.
|
DnsClient |
DnsClient.resolveTXT(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve the TXT records for the given name.
|
DnsClient |
DnsClient.reverseLookup(String ipaddress,
Handler<AsyncResult<String>> handler)
Try to do a reverse lookup of an IP address.
|
Modifier and Type | Class and Description |
---|---|
class |
BridgeInterceptor |
class |
FilteringInterceptor |
Modifier and Type | Method and Description |
---|---|
EventBus |
EventBus.addInterceptor(Handler<SendContext> interceptor)
Add an interceptor that will be called whenever a message is sent from Vert.x
|
void |
EventBus.close(Handler<AsyncResult<Void>> completionHandler)
Close the event bus and release any resources held.
|
void |
MessageConsumer.completionHandler(Handler<AsyncResult<Void>> completionHandler)
Optional method which can be called to indicate when the registration has been propagated across the cluster.
|
<T> MessageConsumer<T> |
EventBus.consumer(String address,
Handler<Message<T>> handler)
Create a consumer and register it against the specified address.
|
MessageProducer<T> |
MessageProducer.drainHandler(Handler<Void> handler) |
MessageConsumer<T> |
MessageConsumer.endHandler(Handler<Void> endHandler) |
MessageConsumer<T> |
MessageConsumer.exceptionHandler(Handler<Throwable> handler) |
MessageProducer<T> |
MessageProducer.exceptionHandler(Handler<Throwable> handler) |
MessageConsumer<T> |
MessageConsumer.handler(Handler<Message<T>> handler) |
<T> MessageConsumer<T> |
EventBus.localConsumer(String address,
Handler<Message<T>> handler)
Like
EventBus.consumer(String, Handler) but the address won't be propagated across the cluster. |
EventBus |
EventBus.removeInterceptor(Handler<SendContext> interceptor)
Remove an interceptor
|
<R> void |
Message.reply(Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<R>>> replyHandler)
The same as
reply(R message, DeliveryOptions) but you can specify handler for the reply - i.e. |
<R> void |
Message.reply(Object message,
Handler<AsyncResult<Message<R>>> replyHandler)
The same as
reply(R message) but you can specify handler for the reply - i.e. |
<T> EventBus |
EventBus.send(String address,
Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.send(String, Object, DeliveryOptions) but specifying a replyHandler that will be called if the recipient
subsequently replies to the message. |
<T> EventBus |
EventBus.send(String address,
Object message,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.send(String, Object) but specifying a replyHandler that will be called if the recipient
subsequently replies to the message. |
<R> MessageProducer<T> |
MessageProducer.send(T message,
Handler<AsyncResult<Message<R>>> replyHandler) |
void |
EventBus.start(Handler<AsyncResult<Void>> completionHandler)
Start the event bus.
|
void |
MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler)
Unregisters the handler which created this registration
|
Modifier and Type | Method and Description |
---|---|
FileSystem |
FileSystem.chmod(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
FileSystem.chmodRecursive(String path,
String perms,
String dirPerms,
Handler<AsyncResult<Void>> handler)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
FileSystem.chown(String path,
String user,
String group,
Handler<AsyncResult<Void>> handler)
Change the ownership on the file represented by
path to user and {code group}, asynchronously. |
void |
AsyncFile.close(Handler<AsyncResult<Void>> handler)
Close the file.
|
FileSystem |
FileSystem.copy(String from,
String to,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
FileSystem.copyRecursive(String from,
String to,
boolean recursive,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
FileSystem.createFile(String path,
Handler<AsyncResult<Void>> handler)
Creates an empty file with the specified
path , asynchronously. |
FileSystem |
FileSystem.createFile(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Creates an empty file with the specified
path and permissions perms , asynchronously. |
FileSystem |
FileSystem.delete(String path,
Handler<AsyncResult<Void>> handler)
Deletes the file represented by the specified
path , asynchronously. |
FileSystem |
FileSystem.deleteRecursive(String path,
boolean recursive,
Handler<AsyncResult<Void>> handler)
Deletes the file represented by the specified
path , asynchronously. |
AsyncFile |
AsyncFile.drainHandler(Handler<Void> handler) |
AsyncFile |
AsyncFile.endHandler(Handler<Void> endHandler) |
AsyncFile |
AsyncFile.exceptionHandler(Handler<Throwable> handler) |
FileSystem |
FileSystem.exists(String path,
Handler<AsyncResult<Boolean>> handler)
Determines whether the file as specified by the path
path exists, asynchronously. |
AsyncFile |
AsyncFile.flush(Handler<AsyncResult<Void>> handler)
Same as
AsyncFile.flush() but the handler will be called when the flush is complete or if an error occurs |
FileSystem |
FileSystem.fsProps(String path,
Handler<AsyncResult<FileSystemProps>> handler)
Returns properties of the file-system being used by the specified
path , asynchronously. |
AsyncFile |
AsyncFile.handler(Handler<Buffer> handler) |
FileSystem |
FileSystem.link(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a hard link on the file system from
link to existing , asynchronously. |
FileSystem |
FileSystem.lprops(String path,
Handler<AsyncResult<FileProps>> handler)
Obtain properties for the link represented by
path , asynchronously. |
FileSystem |
FileSystem.mkdir(String path,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path , asynchronously. |
FileSystem |
FileSystem.mkdir(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path , asynchronously. |
FileSystem |
FileSystem.mkdirs(String path,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
FileSystem.mkdirs(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
FileSystem.move(String from,
String to,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to , asynchronously. |
FileSystem |
FileSystem.open(String path,
OpenOptions options,
Handler<AsyncResult<AsyncFile>> handler)
Open the file represented by
path , asynchronously. |
FileSystem |
FileSystem.props(String path,
Handler<AsyncResult<FileProps>> handler)
Obtain properties for the file represented by
path , asynchronously. |
AsyncFile |
AsyncFile.read(Buffer buffer,
int offset,
long position,
int length,
Handler<AsyncResult<Buffer>> handler)
Reads
length bytes of data from the file at position position in the file, asynchronously. |
FileSystem |
FileSystem.readDir(String path,
Handler<AsyncResult<List<String>>> handler)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
FileSystem.readDir(String path,
String filter,
Handler<AsyncResult<List<String>>> handler)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
FileSystem.readFile(String path,
Handler<AsyncResult<Buffer>> handler)
Reads the entire file as represented by the path
path as a Buffer , asynchronously. |
FileSystem |
FileSystem.readSymlink(String link,
Handler<AsyncResult<String>> handler)
Returns the path representing the file that the symbolic link specified by
link points to, asynchronously. |
FileSystem |
FileSystem.symlink(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a symbolic link on the file system from
link to existing , asynchronously. |
FileSystem |
FileSystem.truncate(String path,
long len,
Handler<AsyncResult<Void>> handler)
Truncate the file represented by
path to length len in bytes, asynchronously. |
FileSystem |
FileSystem.unlink(String link,
Handler<AsyncResult<Void>> handler)
Unlinks the link on the file system represented by the path
link , asynchronously. |
AsyncFile |
AsyncFile.write(Buffer buffer,
long position,
Handler<AsyncResult<Void>> handler)
Write a
Buffer to the file at position position in the file, asynchronously. |
FileSystem |
FileSystem.writeFile(String path,
Buffer data,
Handler<AsyncResult<Void>> handler)
Creates the file, and writes the specified
Buffer data to the file represented by the path path ,
asynchronously. |
Modifier and Type | Method and Description |
---|---|
Handler<HttpServerRequest> |
HttpServer.requestHandler() |
Handler<ServerWebSocket> |
HttpServer.websocketHandler() |
Modifier and Type | Method and Description |
---|---|
HttpServerResponse |
HttpServerResponse.bodyEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the last part of the body is written to the wire
and the response is ended.
|
HttpClientResponse |
HttpClientResponse.bodyHandler(Handler<Buffer> bodyHandler)
Convenience method for receiving the entire request body in one piece.
|
default HttpServerRequest |
HttpServerRequest.bodyHandler(Handler<Buffer> bodyHandler)
Convenience method for receiving the entire request body in one piece.
|
void |
HttpServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
HttpServer.close() but supplying a handler that will be called when the server is actually closed (or has failed). |
HttpConnection |
HttpConnection.closeHandler(Handler<Void> handler)
Set a close handler.
|
HttpServerResponse |
HttpServerResponse.closeHandler(Handler<Void> handler)
Set a close handler for the response.
|
ServerWebSocket |
ServerWebSocket.closeHandler(Handler<Void> handler) |
WebSocket |
WebSocket.closeHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.closeHandler(Handler<Void> handler)
Set a close handler.
|
HttpClientRequest |
HttpClientRequest.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler called when an HTTP connection has been established.
|
HttpServer |
HttpServer.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the server.
|
HttpClientRequest |
HttpClientRequest.continueHandler(Handler<Void> handler)
If you send an HTTP request with the header
Expect set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100 and a continue handler
has been set using this method, then the handler will be called. |
HttpClientResponse |
HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)
Set an custom frame handler.
|
HttpServerRequest |
HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)
Set a custom frame handler.
|
HttpClientRequest |
HttpClient.delete(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.delete(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.delete(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.deleteAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClientRequest.drainHandler(Handler<Void> handler) |
HttpServerResponse |
HttpServerResponse.drainHandler(Handler<Void> handler) |
ServerWebSocket |
ServerWebSocket.drainHandler(Handler<Void> handler) |
WebSocket |
WebSocket.drainHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.drainHandler(Handler<Void> handler) |
HttpClientRequest |
HttpClientRequest.endHandler(Handler<Void> endHandler) |
HttpClientResponse |
HttpClientResponse.endHandler(Handler<Void> endHandler) |
HttpServerFileUpload |
HttpServerFileUpload.endHandler(Handler<Void> endHandler) |
HttpServerRequest |
HttpServerRequest.endHandler(Handler<Void> endHandler) |
HttpServerRequestStream |
HttpServerRequestStream.endHandler(Handler<Void> endHandler) |
ServerWebSocket |
ServerWebSocket.endHandler(Handler<Void> endHandler) |
ServerWebSocketStream |
ServerWebSocketStream.endHandler(Handler<Void> endHandler) |
WebSocket |
WebSocket.endHandler(Handler<Void> endHandler) |
WebSocketBase |
WebSocketBase.endHandler(Handler<Void> endHandler) |
WebSocketStream |
WebSocketStream.endHandler(Handler<Void> endHandler) |
HttpClientRequest |
HttpClientRequest.exceptionHandler(Handler<Throwable> handler) |
HttpClientResponse |
HttpClientResponse.exceptionHandler(Handler<Throwable> handler) |
HttpConnection |
HttpConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called when a connection error happens
|
HttpServerFileUpload |
HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequest |
HttpServerRequest.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequestStream |
HttpServerRequestStream.exceptionHandler(Handler<Throwable> handler) |
HttpServerResponse |
HttpServerResponse.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocketStream |
ServerWebSocketStream.exceptionHandler(Handler<Throwable> handler) |
WebSocket |
WebSocket.exceptionHandler(Handler<Throwable> handler) |
WebSocketBase |
WebSocketBase.exceptionHandler(Handler<Throwable> handler) |
WebSocketStream |
WebSocketStream.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.frameHandler(Handler<WebSocketFrame> handler) |
WebSocket |
WebSocket.frameHandler(Handler<WebSocketFrame> handler) |
WebSocketBase |
WebSocketBase.frameHandler(Handler<WebSocketFrame> handler)
Set a frame handler on the connection.
|
HttpClientRequest |
HttpClient.get(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.get(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.get(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.getAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.getNow(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.getNow(String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.getNow(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpConnection |
HttpConnection.goAwayHandler(Handler<GoAway> handler)
Set an handler called when a GOAWAY frame is received.
|
HttpClientResponse |
HttpClientResponse.handler(Handler<Buffer> handler) |
HttpServerFileUpload |
HttpServerFileUpload.handler(Handler<Buffer> handler) |
HttpServerRequest |
HttpServerRequest.handler(Handler<Buffer> handler) |
ServerWebSocket |
ServerWebSocket.handler(Handler<Buffer> handler) |
WebSocket |
WebSocket.handler(Handler<Buffer> handler) |
WebSocketBase |
WebSocketBase.handler(Handler<Buffer> handler) |
HttpClientRequest |
HttpClientRequest.handler(Handler<HttpClientResponse> handler) |
HttpServerRequestStream |
HttpServerRequestStream.handler(Handler<HttpServerRequest> handler) |
ServerWebSocketStream |
ServerWebSocketStream.handler(Handler<ServerWebSocket> handler) |
WebSocketStream |
WebSocketStream.handler(Handler<WebSocket> handler) |
HttpClientRequest |
HttpClient.head(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.head(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.head(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.headAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpServerResponse |
HttpServerResponse.headersEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the headers are written to the wire.
|
HttpClient |
HttpClient.headNow(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.headNow(String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.headNow(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpServer |
HttpServer.listen(Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen() but supplying a handler that will be called when the server is actually listening (or has failed). |
HttpServer |
HttpServer.listen(int port,
Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen(int) but supplying a handler that will be called when the server is actually listening (or has failed). |
HttpServer |
HttpServer.listen(int port,
String host,
Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen(int, String) but supplying a handler that will be called when the server is actually
listening (or has failed). |
HttpClientRequest |
HttpClient.options(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.options(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.options(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.optionsAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.optionsNow(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.optionsNow(String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP OPTIONS request to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.optionsNow(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpConnection |
HttpConnection.ping(Buffer data,
Handler<AsyncResult<Buffer>> pongHandler)
Send a PING frame to the remote endpoint.
|
HttpConnection |
HttpConnection.pingHandler(Handler<Buffer> handler)
Set an handler notified when a PING frame is received from the remote endpoint.
|
HttpClientRequest |
HttpClient.post(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.post(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.post(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.postAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with no headers. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Push a response to the client.
The
handler will be notified with a success when the push can be sent and with
a failure when the client has disabled push or reset the push before it has been sent.
The handler may be queued if the client has reduced the maximum number of streams the server can push
concurrently.
Push can be sent only for peer initiated streams and if the response is not ended. |
HttpClientRequest |
HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)
Set a push handler for this request.
The handler is called when the client receives a push promise from the server.
|
HttpClientRequest |
HttpClient.put(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.put(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.put(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.putAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpConnection |
HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)
Set an handler that is called when remote endpoint
Http2Settings are updated. |
HttpClientRequest |
HttpClient.request(HttpMethod method,
int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.request(HttpMethod method,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.request(HttpMethod method,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.requestAbs(HttpMethod method,
String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpServer |
HttpServer.requestHandler(Handler<HttpServerRequest> handler)
Set the request handler for the server to
requestHandler . |
default HttpServerResponse |
HttpServerResponse.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(String) but providing a handler which will be notified once the file has been completely
written to the wire. |
default HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(String, long) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(String, long, long) but providing a handler which will be notified once the file has been
completely written to the wire. |
HttpClientRequest |
HttpClientRequest.sendHead(Handler<HttpVersion> completionHandler)
Like
HttpClientRequest.sendHead() but with an handler after headers have been sent. |
HttpConnection |
HttpConnection.shutdownHandler(Handler<Void> handler)
Set an handler called when a GOAWAY frame has been sent or received and all connections are closed.
|
HttpConnection |
HttpConnection.updateSettings(Http2Settings settings,
Handler<AsyncResult<Void>> completionHandler)
Send to the remote endpoint an update of this endpoint settings
The
completionHandler will be notified when the remote endpoint has acknowledged the settings. |
HttpServerRequest |
HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)
Set an upload handler.
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(String requestURI,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port
|
HttpClient |
HttpClient.websocket(String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port
|
HttpClient |
HttpClient.websocket(String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the host and relative request URI and default port
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the host and relative request URI and default port
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the host and relative request URI and default port
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpServer |
HttpServer.websocketHandler(Handler<ServerWebSocket> handler)
Set the websocket handler for the server to
wsHandler . |
Modifier and Type | Method and Description |
---|---|
Handler<NetSocket> |
NetServer.connectHandler() |
Modifier and Type | Method and Description |
---|---|
void |
NetServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
NetServer.close() but supplying a handler that will be notified when close is complete. |
NetSocket |
NetSocket.closeHandler(Handler<Void> handler)
Set a handler that will be called when the NetSocket is closed
|
NetClient |
NetClient.connect(int port,
String host,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
port and host . |
NetServer |
NetServer.connectHandler(Handler<NetSocket> handler)
Supply a connect handler for this server.
|
NetSocket |
NetSocket.drainHandler(Handler<Void> handler) |
NetSocket |
NetSocket.endHandler(Handler<Void> endHandler) |
NetSocketStream |
NetSocketStream.endHandler(Handler<Void> endHandler) |
NetSocket |
NetSocket.exceptionHandler(Handler<Throwable> handler) |
NetSocketStream |
NetSocketStream.exceptionHandler(Handler<Throwable> handler) |
NetSocket |
NetSocket.handler(Handler<Buffer> handler) |
NetSocketStream |
NetSocketStream.handler(Handler<NetSocket> handler) |
NetServer |
NetServer.listen(Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen() but providing a handler that will be notified when the server is listening, or fails. |
NetServer |
NetServer.listen(int port,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(int) but providing a handler that will be notified when the server is listening, or fails. |
NetServer |
NetServer.listen(int port,
String host,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(int, String) but providing a handler that will be notified when the server is listening, or fails. |
default NetSocket |
NetSocket.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
default NetSocket |
NetSocket.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(String, long) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(String, long, long) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.upgradeToSsl(Handler<Void> handler)
Upgrade channel to use SSL/TLS.
|
Modifier and Type | Interface and Description |
---|---|
interface |
RecordParser
A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed
size records.
|
Modifier and Type | Method and Description |
---|---|
static RecordParser |
RecordParser.newDelimited(Buffer delim,
Handler<Buffer> output)
Create a new
RecordParser instance, initially in delimited mode, and where the delimiter can be represented
by the Buffer delim. |
static RecordParser |
RecordParser.newDelimited(String delim,
Handler<Buffer> output)
Create a new
RecordParser instance, initially in delimited mode, and where the delimiter can be represented
by the String delim endcoded in latin-1 . |
static RecordParser |
RecordParser.newFixed(int size,
Handler<Buffer> output)
Create a new
RecordParser instance, initially in fixed size mode, and where the record size is specified
by the size parameter. |
void |
RecordParser.setOutput(Handler<Buffer> output) |
Modifier and Type | Method and Description |
---|---|
void |
Counter.addAndGet(long value,
Handler<AsyncResult<Long>> resultHandler)
Add the value to the counter atomically and return the new count
|
void |
AsyncMap.clear(Handler<AsyncResult<Void>> resultHandler)
Clear all entries in the map
|
void |
Counter.compareAndSet(long expected,
long value,
Handler<AsyncResult<Boolean>> resultHandler)
Set the counter to the specified value only if the current value is the expectec value.
|
void |
Counter.decrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Decrement the counter atomically and return the new count
|
void |
Counter.get(Handler<AsyncResult<Long>> resultHandler)
Get the current value of the counter
|
void |
AsyncMap.get(K k,
Handler<AsyncResult<V>> resultHandler)
Get a value from the map, asynchronously.
|
void |
Counter.getAndAdd(long value,
Handler<AsyncResult<Long>> resultHandler)
Add the value to the counter atomically and return the value before the add
|
void |
Counter.getAndIncrement(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the value before the increment.
|
<K,V> void |
SharedData.getClusterWideMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the cluster wide map with the specified name.
|
void |
SharedData.getCounter(String name,
Handler<AsyncResult<Counter>> resultHandler)
Get a cluster wide counter.
|
void |
SharedData.getLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get a cluster wide lock with the specified name.
|
void |
SharedData.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
Like
SharedData.getLock(String, Handler) but specifying a timeout. |
void |
Counter.incrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the new count
|
void |
AsyncMap.put(K k,
V v,
Handler<AsyncResult<Void>> completionHandler)
Put a value in the map, asynchronously.
|
void |
AsyncMap.put(K k,
V v,
long ttl,
Handler<AsyncResult<Void>> completionHandler)
Like
AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but specifying a timeout. |
void |
AsyncMap.putIfAbsent(K k,
V v,
Handler<AsyncResult<V>> completionHandler)
Put the entry only if there is no entry with the key already present.
|
void |
AsyncMap.putIfAbsent(K k,
V v,
long ttl,
Handler<AsyncResult<V>> completionHandler)
Link
AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>) but specifying a timeout. |
void |
AsyncMap.remove(K k,
Handler<AsyncResult<V>> resultHandler)
Remove a value from the map, asynchronously.
|
void |
AsyncMap.removeIfPresent(K k,
V v,
Handler<AsyncResult<Boolean>> resultHandler)
Remove a value from the map, only if entry already exists with same value.
|
void |
AsyncMap.replace(K k,
V v,
Handler<AsyncResult<V>> resultHandler)
Replace the entry only if it is currently mapped to some value
|
void |
AsyncMap.replaceIfPresent(K k,
V oldValue,
V newValue,
Handler<AsyncResult<Boolean>> resultHandler)
Replace the entry only if it is currently mapped to a specific value
|
void |
AsyncMap.size(Handler<AsyncResult<Integer>> resultHandler)
Provide the number of entries in the map
|
Modifier and Type | Method and Description |
---|---|
void |
VertxFactory.clusteredVertx(VertxOptions options,
Handler<AsyncResult<Vertx>> resultHandler) |
Modifier and Type | Method and Description |
---|---|
void |
AsyncMultiMap.add(K k,
V v,
Handler<AsyncResult<Void>> completionHandler)
Add a value to the list of values for that key in the map
|
void |
AsyncMultiMap.get(K k,
Handler<AsyncResult<ChoosableIterable<V>>> resultHandler)
Get a list of values from the map for the key
|
<K,V> void |
ClusterManager.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Return an async map for the given name
|
<K,V> void |
ClusterManager.getAsyncMultiMap(String name,
Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)
Return an async multi-map for the given name
|
void |
ClusterManager.getCounter(String name,
Handler<AsyncResult<Counter>> resultHandler) |
void |
ClusterManager.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler) |
void |
ClusterManager.join(Handler<AsyncResult<Void>> resultHandler)
Join the cluster
|
void |
ClusterManager.leave(Handler<AsyncResult<Void>> resultHandler)
Leave the cluster
|
void |
AsyncMultiMap.remove(K k,
V v,
Handler<AsyncResult<Boolean>> completionHandler)
Remove a value from the list of values for that key in the map.
|
void |
AsyncMultiMap.removeAllForValue(V v,
Handler<AsyncResult<Void>> completionHandler)
Remove all the specified values from all keys in the map
|
Modifier and Type | Method and Description |
---|---|
WriteStream<T> |
WriteStream.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
ReadStream<T> |
ReadStream.endHandler(Handler<Void> endHandler)
Set an end handler.
|
ReadStream<T> |
ReadStream.exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the read stream.
|
StreamBase |
StreamBase.exceptionHandler(Handler<Throwable> handler)
Set an exception handler.
|
WriteStream<T> |
WriteStream.exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the write stream.
|
ReadStream<T> |
ReadStream.handler(Handler<T> handler)
Set a data handler.
|
Modifier and Type | Method and Description |
---|---|
void |
AsyncSQLClient.close(Handler<AsyncResult<Void>> whenDone)
Close the client and release all resources.
|
void |
AsyncSQLClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
Modifier and Type | Method and Description |
---|---|
void |
AuthProvider.authenticate(JsonObject authInfo,
Handler<AsyncResult<User>> resultHandler)
Authenticate a user.
|
protected abstract void |
AbstractUser.doIsPermitted(String permission,
Handler<AsyncResult<Boolean>> resultHandler) |
User |
AbstractUser.isAuthorised(String authority,
Handler<AsyncResult<Boolean>> resultHandler) |
User |
User.isAuthorised(String authority,
Handler<AsyncResult<Boolean>> resultHandler)
Is the user authorised to
|
Modifier and Type | Method and Description |
---|---|
void |
MongoAuth.insertUser(String username,
String password,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Insert a new user into mongo in the convenient way
|
Modifier and Type | Method and Description |
---|---|
OAuth2Auth |
OAuth2Auth.api(HttpMethod method,
String path,
JsonObject params,
Handler<AsyncResult<JsonObject>> handler)
Call OAuth2 APIs.
|
void |
OAuth2Auth.getToken(JsonObject params,
Handler<AsyncResult<AccessToken>> handler)
Returns the Access Token object.
|
AccessToken |
AccessToken.logout(Handler<AsyncResult<Void>> callback)
Revoke refresh token and calls the logout endpoint.
|
AccessToken |
AccessToken.refresh(Handler<AsyncResult<Void>> callback)
Refresh the access token
|
AccessToken |
AccessToken.revoke(String token_type,
Handler<AsyncResult<Void>> callback)
Revoke access or refresh token
|
Modifier and Type | Method and Description |
---|---|
void |
TcpEventBusBridge.close(Handler<AsyncResult<Void>> handler)
Close the current socket.
|
TcpEventBusBridge |
TcpEventBusBridge.listen(Handler<AsyncResult<TcpEventBusBridge>> handler)
Listen on default port 7000 with a handler to report the state of the socket listen operation.
|
TcpEventBusBridge |
TcpEventBusBridge.listen(int port,
Handler<AsyncResult<TcpEventBusBridge>> handler)
Listen on specific port
|
TcpEventBusBridge |
TcpEventBusBridge.listen(int port,
String address,
Handler<AsyncResult<TcpEventBusBridge>> handler)
Listen on specific port and bind to specific address
|
Modifier and Type | Method and Description |
---|---|
protected void |
HttpServiceFactory.doRequest(HttpClient client,
File file,
URI url,
File signatureFile,
URI signatureURL,
Handler<AsyncResult<io.vertx.ext.httpservicefactory.HttpServiceFactory.Result>> handler) |
Modifier and Type | Method and Description |
---|---|
JDBCClient |
JDBCClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
Modifier and Type | Class and Description |
---|---|
class |
MailServiceVertxProxyHandler |
Modifier and Type | Method and Description |
---|---|
MailClient |
MailClient.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler)
send a single mail via MailClient
|
MailService |
MailService.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler) |
MailService |
MailServiceVertxEBProxy.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler) |
Modifier and Type | Method and Description |
---|---|
MongoClient |
MongoClient.count(String collection,
JsonObject query,
Handler<AsyncResult<Long>> resultHandler)
Count matching documents in a collection.
|
MongoClient |
MongoClient.createCollection(String collectionName,
Handler<AsyncResult<Void>> resultHandler)
Create a new collection
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinctBatch(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonObject>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.dropCollection(String collection,
Handler<AsyncResult<Void>> resultHandler)
Drop a collection
|
MongoClient |
MongoClient.find(String collection,
JsonObject query,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection
|
MongoClient |
MongoClient.findBatch(String collection,
JsonObject query,
Handler<AsyncResult<JsonObject>> resultHandler)
Find matching documents in the specified collection.
|
MongoClient |
MongoClient.findBatchWithOptions(String collection,
JsonObject query,
FindOptions options,
Handler<AsyncResult<JsonObject>> resultHandler)
Find matching documents in the specified collection, specifying options.
|
MongoClient |
MongoClient.findOne(String collection,
JsonObject query,
JsonObject fields,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection
|
MongoClient |
MongoClient.findWithOptions(String collection,
JsonObject query,
FindOptions options,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection, specifying options
|
MongoClient |
MongoClient.getCollections(Handler<AsyncResult<List<String>>> resultHandler)
Get a list of all collections in the database.
|
MongoClient |
MongoClient.insert(String collection,
JsonObject document,
Handler<AsyncResult<String>> resultHandler)
Insert a document in the specified collection
|
MongoClient |
MongoClient.insertWithOptions(String collection,
JsonObject document,
WriteOption writeOption,
Handler<AsyncResult<String>> resultHandler)
Insert a document in the specified collection with the specified write option
|
MongoClient |
MongoClient.remove(String collection,
JsonObject query,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.removeDocument(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeDocuments(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeDocumentsWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeDocumentWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeOne(String collection,
JsonObject query,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.removeOneWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.removeWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.replace(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.replaceDocuments(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.replaceDocumentsWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.replaceWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.runCommand(String commandName,
JsonObject command,
Handler<AsyncResult<JsonObject>> resultHandler)
Run an arbitrary MongoDB command.
|
MongoClient |
MongoClient.save(String collection,
JsonObject document,
Handler<AsyncResult<String>> resultHandler)
Save a document in the specified collection
|
MongoClient |
MongoClient.saveWithOptions(String collection,
JsonObject document,
WriteOption writeOption,
Handler<AsyncResult<String>> resultHandler)
Save a document in the specified collection with the specified write option
|
MongoClient |
MongoClient.update(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
MongoClient |
MongoClient.updateCollection(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.updateWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
void |
TcpEventBusBridge.close(Handler<AsyncResult<Void>> handler)
Close the current socket.
|
TcpEventBusBridge |
TcpEventBusBridge.listen(Handler<AsyncResult<TcpEventBusBridge>> handler)
Listen on default port 7000 with a handler to report the state of the socket listen operation.
|
TcpEventBusBridge |
TcpEventBusBridge.listen(int port,
Handler<AsyncResult<TcpEventBusBridge>> handler)
Listen on specific port
|
TcpEventBusBridge |
TcpEventBusBridge.listen(int port,
String address,
Handler<AsyncResult<TcpEventBusBridge>> handler)
Listen on specific port and bind to specific address
|
Modifier and Type | Method and Description |
---|---|
void |
ShellServer.close(Handler<AsyncResult<Void>> completionHandler)
Close the shell server, this is an asynchronous close.
|
ShellServer |
ShellServer.listen(Handler<AsyncResult<Void>> listenHandler)
Start the shell service, this is an asynchronous start.
|
void |
ShellService.start(Handler<AsyncResult<Void>> startHandler)
Start the shell service, this is an asynchronous start.
|
void |
ShellService.stop(Handler<AsyncResult<Void>> stopHandler)
Stop the shell service, this is an asynchronous start.
|
Modifier and Type | Method and Description |
---|---|
CommandProcess |
CommandProcess.backgroundHandler(Handler<Void> handler)
Set a background handler, this handler is called when the command is running and put to background.
|
CommandBuilder |
CommandBuilder.completionHandler(Handler<Completion> handler)
Set the command completion handler, the completion handler when the user asks for contextual command line
completion, usually hitting the tab key.
|
CommandProcess |
CommandProcess.endHandler(Handler<Void> handler)
Set an end handler, this handler is called when the command is ended, for instance the command is running
and the shell closes.
|
CommandProcess |
CommandProcess.foregroundHandler(Handler<Void> handler)
Set a foreground handler, this handler is called when the command is running and put to foreground.
|
CommandProcess |
CommandProcess.interruptHandler(Handler<Void> handler)
Set an interrupt handler, this handler is called when the command is interrupted, for instance user
press
Ctrl-C . |
CommandBuilder |
CommandBuilder.processHandler(Handler<CommandProcess> handler)
Set the command process handler, the process handler is called when the command is executed.
|
CommandRegistry |
CommandRegistry.registerCommand(Class<? extends AnnotatedCommand> command,
Handler<AsyncResult<Command>> completionHandler)
Register a single command.
|
CommandRegistry |
CommandRegistry.registerCommand(Command command,
Handler<AsyncResult<Command>> completionHandler)
Register a command
|
CommandRegistry |
CommandRegistry.registerCommands(List<Command> commands,
Handler<AsyncResult<List<Command>>> completionHandler)
Register a list of commands.
|
CommandProcess |
CommandProcess.resizehandler(Handler<Void> handler) |
CommandProcess |
CommandProcess.resumeHandler(Handler<Void> handler)
Set a resume handler, this handler is called when the command is resumed, for instance user
types
bg or fg to resume the command. |
CommandProcess |
CommandProcess.stdinHandler(Handler<String> handler) |
CommandProcess |
CommandProcess.suspendHandler(Handler<Void> handler)
Set a suspend handler, this handler is called when the command is suspended, for instance user
press
Ctrl-Z . |
CommandRegistry |
CommandRegistry.unregisterCommand(String commandName,
Handler<AsyncResult<Void>> completionHandler)
Unregister a command.
|
Modifier and Type | Method and Description |
---|---|
void |
CommandResolverFactory.resolver(Vertx vertx,
Handler<AsyncResult<CommandResolver>> resolveHandler)
Obtain a command resolver for a Vert.x instance.
|
Modifier and Type | Method and Description |
---|---|
void |
JobController.close(Handler<Void> completionHandler)
Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
|
boolean |
Process.interrupt(Handler<Void> completionHandler)
Attempt to interrupt the process.
|
void |
Process.resume(boolean foreground,
Handler<Void> completionHandler)
Suspend the process.
|
default void |
Process.resume(Handler<Void> completionHandler)
Suspend the process.
|
void |
Process.run(boolean foregraound,
Handler<Void> completionHandler)
Run the process.
|
default void |
Process.run(Handler<Void> completionHandler)
Run the process.
|
Job |
Job.statusUpdateHandler(Handler<ExecStatus> handler)
Set an handler called when the job terminates.
|
void |
Process.suspend(Handler<Void> completionHandler)
Resume the process.
|
void |
Process.terminate(Handler<Void> completionHandler)
Terminate the process.
|
Process |
Process.terminatedHandler(Handler<Integer> handler)
Set an handler for being notified when the process terminates.
|
void |
Process.toBackground(Handler<Void> completionHandler)
Set the process in background.
|
void |
Process.toForeground(Handler<Void> completionHandler)
Set the process in foreground.
|
Modifier and Type | Interface and Description |
---|---|
interface |
SockJSTermHandler |
Modifier and Type | Method and Description |
---|---|
void |
TermServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
TermServer.close() but supplying a handler that will be notified when close is complete. |
Term |
Term.closeHandler(Handler<Void> handler)
Set a handler that will be called when the terminal is closed.
|
TermServer |
TermServer.listen(Handler<AsyncResult<TermServer>> listenHandler)
Bind the term server, the
TermServer.termHandler(Handler) must be set before. |
void |
Term.readline(String prompt,
Handler<String> lineHandler)
Prompt the user a line of text.
|
void |
Term.readline(String prompt,
Handler<String> lineHandler,
Handler<Completion> completionHandler)
Prompt the user a line of text, providing a completion handler to handle user's completion.
|
void |
Term.readline(String prompt,
Handler<String> lineHandler,
Handler<Completion> completionHandler)
Prompt the user a line of text, providing a completion handler to handle user's completion.
|
Term |
Term.resizehandler(Handler<Void> handler) |
Tty |
Tty.resizehandler(Handler<Void> handler)
Set a resize handler, the handler is called when the tty size changes.
|
Term |
Term.stdinHandler(Handler<String> handler) |
Tty |
Tty.stdinHandler(Handler<String> handler)
Set a stream handler on the standard input to read the data.
|
Pty |
Pty.stdoutHandler(Handler<String> handler)
Set the standard out handler of the pseudo terminal.
|
SockJSTermHandler |
SockJSTermHandler.termHandler(Handler<Term> handler) |
TermServer |
TermServer.termHandler(Handler<Term> handler)
Set the term handler that will receive incoming client connections.
|
Modifier and Type | Method and Description |
---|---|
SQLConnection |
SQLConnection.batch(List<String> sqlStatements,
Handler<AsyncResult<List<Integer>>> handler)
Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
|
SQLConnection |
SQLConnection.batchCallableWithParams(String sqlStatement,
List<JsonArray> inArgs,
List<JsonArray> outArgs,
Handler<AsyncResult<List<Integer>>> handler)
Batch a callable statement with all entries from the args list.
|
SQLConnection |
SQLConnection.batchWithParams(String sqlStatement,
List<JsonArray> args,
Handler<AsyncResult<List<Integer>>> handler)
Batch a prepared statement with all entries from the args list.
|
SQLConnection |
SQLConnection.call(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLConnection |
SQLConnection.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
void |
SQLConnection.close(Handler<AsyncResult<Void>> handler)
Closes the connection.
|
SQLConnection |
SQLConnection.commit(Handler<AsyncResult<Void>> handler)
Commits all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.execute(String sql,
Handler<AsyncResult<Void>> resultHandler)
Executes the given SQL statement
|
SQLConnection |
SQLConnection.getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)
Attempts to return the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
SQLConnection |
SQLConnection.queryWithParams(String sql,
JsonArray params,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT prepared statement which returns the results of the query. |
SQLConnection |
SQLConnection.rollback(Handler<AsyncResult<Void>> handler)
Rolls back all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.setAutoCommit(boolean autoCommit,
Handler<AsyncResult<Void>> resultHandler)
Sets the auto commit flag for this connection.
|
SQLConnection |
SQLConnection.setTransactionIsolation(TransactionIsolation isolation,
Handler<AsyncResult<Void>> handler)
Attempts to change the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.update(String sql,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given SQL statement which may be an
INSERT , UPDATE , or DELETE
statement. |
SQLConnection |
SQLConnection.updateWithParams(String sql,
JsonArray params,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given prepared statement which may be an
INSERT , UPDATE , or DELETE
statement with the given parameters |
Modifier and Type | Interface and Description |
---|---|
interface |
StompServerHandler
STOMP server handler implements the behavior of the STOMP server when a specific event occurs.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultAbortHandler
STOMP compliant actions executed when receiving a
ABORT frame. |
class |
DefaultAckHandler
STOMP compliant actions executed when receiving a
ACK frame. |
class |
DefaultBeginHandler
STOMP compliant actions executed when receiving a
BEGIN frame. |
class |
DefaultCommitHandler
STOMP compliant actions executed when receiving a
COMMIT frame. |
class |
DefaultConnectHandler
STOMP compliant actions executed when receiving a
CONNECT frame. |
class |
DefaultNackHandler
STOMP compliant actions executed when receiving a
NACK sf.frame(). |
class |
DefaultSendHandler
STOMP compliant actions executed when receiving a
SEND sf.frame(). |
class |
DefaultSubscribeHandler
STOMP compliant actions executed when receiving a
SUBSCRIBE frame. |
class |
DefaultUnsubscribeHandler
STOMP compliant actions executed when receiving a
UNSUBSCRIBE frame. |
Modifier and Type | Method and Description |
---|---|
Handler<ServerWebSocket> |
StompServer.webSocketHandler()
Gets the
Handler able to manage web socket connections. |
Modifier and Type | Method and Description |
---|---|
StompClientConnection |
StompClientConnection.abort(String id,
Handler<Frame> receiptHandler)
Aborts a transaction.
|
StompClientConnection |
StompClientConnection.abort(String id,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Aborts a transaction.
|
StompServerHandler |
StompServerHandler.abortHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
ABORT frame is received. |
StompClientConnection |
StompClientConnection.ack(String id,
Handler<Frame> receiptHandler)
Sends an acknowledgement for a specific message.
|
StompClientConnection |
StompClientConnection.ack(String id,
String txId,
Handler<Frame> receiptHandler)
Sends an acknowledgement for the given frame.
|
StompServerHandler |
StompServerHandler.ackHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
ACK frame is received. |
StompServerHandler |
StompServerHandler.beginHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
BEGIN frame is received. |
StompClientConnection |
StompClientConnection.beginTX(String id,
Handler<Frame> receiptHandler)
Begins a transaction.
|
StompClientConnection |
StompClientConnection.beginTX(String id,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Begins a transaction.
|
void |
StompServer.close(Handler<AsyncResult<Void>> completionHandler)
Closes the server.
|
StompClientConnection |
StompClientConnection.closeHandler(Handler<StompClientConnection> handler)
Sets a handler notified when the STOMP connection is closed.
|
StompServerHandler |
StompServerHandler.closeHandler(Handler<StompServerConnection> handler)
Configures the action to execute when a connection with the client is closed.
|
StompClientConnection |
StompClientConnection.commit(String id,
Handler<Frame> receiptHandler)
Commits a transaction.
|
StompClientConnection |
StompClientConnection.commit(String id,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Commits a transaction.
|
StompServerHandler |
StompServerHandler.commitHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
COMMIT frame is received. |
void |
StompServerConnection.configureHeartbeat(long ping,
long pong,
Handler<StompServerConnection> pingHandler)
Configures the heartbeat.
|
StompClient |
StompClient.connect(Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server using the host and port configured in the client's options.
|
StompClient |
StompClient.connect(int port,
String host,
Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server.
|
StompClient |
StompClient.connect(int port,
String host,
NetClient net,
Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server.
|
StompClient |
StompClient.connect(NetClient net,
Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server.
|
StompServerHandler |
StompServerHandler.connectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
CONNECT frame is received. |
StompClientConnection |
StompClientConnection.connectionDroppedHandler(Handler<StompClientConnection> handler)
Sets a handler notified when the server does not respond to a
ping request in time. |
StompClientConnection |
StompClientConnection.disconnect(Frame frame,
Handler<Frame> receiptHandler)
Disconnects the client.
|
StompClientConnection |
StompClientConnection.disconnect(Handler<Frame> receiptHandler)
Disconnects the client.
|
StompServerHandler |
StompServerHandler.disconnectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
DISCONNECT frame is received. |
StompClient |
StompClient.errorFrameHandler(Handler<Frame> handler)
A general error frame handler.
|
StompClientConnection |
StompClientConnection.errorHandler(Handler<Frame> handler)
Sets a handler notified when an
ERROR frame is received by the client. |
StompServer |
StompServer.listen(Handler<AsyncResult<StompServer>> handler)
Connects the STOMP server default port (61613) and network interface (
0.0.0.0 ). |
StompServer |
StompServer.listen(int port,
Handler<AsyncResult<StompServer>> handler)
Connects the STOMP server to the given port.
|
StompServer |
StompServer.listen(int port,
String host,
Handler<AsyncResult<StompServer>> handler)
Connects the STOMP server to the given port / interface.
|
StompClientConnection |
StompClientConnection.nack(String id,
Handler<Frame> receiptHandler)
Sends a non-acknowledgement for the given message.
|
StompClientConnection |
StompClientConnection.nack(String id,
String txId,
Handler<Frame> receiptHandler)
Sends a non-acknowledgement for the given frame.
|
StompServerHandler |
StompServerHandler.nackHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
NACK frame is received. |
StompServerHandler |
StompServerHandler.onAckHandler(Handler<Acknowledgement> handler)
Configures the action to execute when messages are acknowledged.
|
StompServerHandler |
StompServerHandler.onAuthenticationRequest(StompServer server,
String login,
String passcode,
Handler<AsyncResult<Boolean>> handler)
Called when the client connects to a server requiring authentication.
|
StompServerHandler |
StompServerHandler.onNackHandler(Handler<Acknowledgement> handler)
Configures the action to execute when messages are not acknowledged.
|
StompClientConnection |
StompClientConnection.pingHandler(Handler<StompClientConnection> handler)
Sets a handler that let customize the behavior when a ping needs to be sent to the server.
|
StompServerHandler |
StompServerHandler.pingHandler(Handler<StompServerConnection> handler)
Allows customizing the action to do when the server needs to send a `PING` to the client.
|
StompClient |
StompClient.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that gets notified when a STOMP frame is received by the client.
|
StompClientConnection |
StompClientConnection.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that get notified when a STOMP frame is received by the client.
|
StompServerHandler |
StompServerHandler.receivedFrameHandler(Handler<ServerFrame> handler)
Configures a handler that get notified when a STOMP frame is received by the server.
|
StompClientConnection |
StompClientConnection.send(Frame frame,
Handler<Frame> receiptHandler)
Sends the given frame to the server.
|
StompClientConnection |
StompClientConnection.send(Map<String,String> headers,
Buffer body,
Handler<Frame> receiptHandler)
Sends a
SEND frame to the server. |
StompClientConnection |
StompClientConnection.send(String destination,
Buffer body,
Handler<Frame> receiptHandler)
Sends a
SEND frame to the server to the given destination. |
StompClientConnection |
StompClientConnection.send(String destination,
Map<String,String> headers,
Buffer body,
Handler<Frame> receiptHandler)
Sends a
SEND frame to the server to the given destination. |
StompServerHandler |
StompServerHandler.sendHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
SEND frame is received. |
StompServerHandler |
StompServerHandler.stompHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
STOMP frame is received. |
String |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
StompServerHandler |
StompServerHandler.subscribeHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
SUBSCRIBE frame is received. |
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Handler<Frame> receiptHandler)
Un-subscribes from the given destination.
|
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Un-subscribes from the given destination.
|
StompServerHandler |
StompServerHandler.unsubscribeHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
UNSUBSCRIBE frame is received. |
StompClient |
StompClient.writingFrameHandler(Handler<Frame> handler)
Configures a writing handler that gets notified when a STOMP frame is written on the wire.
|
StompClientConnection |
StompClientConnection.writingFrameHandler(Handler<Frame> handler)
Configures a handler notified when a frame is going to be written on the wire.
|
StompServer |
StompServer.writingFrameHandler(Handler<ServerFrame> handler)
Configures the handler that is invoked every time a frame is going to be written to the "wire".
|
Modifier and Type | Interface and Description |
---|---|
interface |
HandlerReceiverAdaptor<T>
Represents an object that is both a handler of a particular event and also a receiver of that event.
|
Modifier and Type | Method and Description |
---|---|
static <T> Handler<T> |
Sync.fiberHandler(Handler<T> handler)
Convert a standard handler to a handler which runs on a fiber.
|
Modifier and Type | Method and Description |
---|---|
static <T> Handler<T> |
Sync.fiberHandler(Handler<T> handler)
Convert a standard handler to a handler which runs on a fiber.
|
Modifier and Type | Method and Description |
---|---|
static <T> T |
Sync.awaitEvent(java.util.function.Consumer<Handler<T>> consumer)
Receive a single event from a handler synchronously.
|
static <T> T |
Sync.awaitEvent(java.util.function.Consumer<Handler<T>> consumer,
long timeout)
Receive a single event from a handler synchronously.
|
static <T> T |
Sync.awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)
Invoke an asynchronous operation and obtain the result synchronous.
|
static <T> T |
Sync.awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer,
long timeout)
Invoke an asynchronous operation and obtain the result synchronous.
|
Modifier and Type | Method and Description |
---|---|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it completes the async operation.
When the returned handler is called back with a failed result it fails the test with the cause of the failure.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
Handler<Throwable> |
TestContext.exceptionHandler() |
Modifier and Type | Method and Description |
---|---|
TestSuite |
TestSuite.after(Handler<TestContext> callback)
Set a callback executed after the tests.
|
TestSuite |
TestSuite.afterEach(Handler<TestContext> callback)
Set a callback executed after each test and before the suite
after callback. |
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
TestSuite |
TestSuite.before(Handler<TestContext> callback)
Set a callback executed before the tests.
|
TestSuite |
TestSuite.beforeEach(Handler<TestContext> callback)
Set a callback executed before each test and after the suite
before callback. |
static TestCase |
TestCase.create(String name,
Handler<TestContext> testCase)
Create a test case.
|
void |
Completion.handler(Handler<AsyncResult<T>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
TestSuite |
TestSuite.test(String name,
Handler<TestContext> testCase)
Add a new test case to the suite.
|
TestSuite |
TestSuite.test(String name,
int repeat,
Handler<TestContext> testCase)
Add a new test case to the suite.
|
Modifier and Type | Method and Description |
---|---|
Handler<Message<JsonObject>> |
EventBusCollector.asMessageHandler() |
Modifier and Type | Method and Description |
---|---|
static EventBusCollector |
EventBusCollector.create(Vertx vertx,
Handler<TestSuiteReport> reporter) |
Modifier and Type | Method and Description |
---|---|
TestCaseReport |
TestCaseReport.endHandler(Handler<TestResult> handler)
Set a callback for completion, the specified
handler is invoked when the test exec has completed. |
TestSuiteReport |
TestSuiteReport.endHandler(Handler<Void> endHandler) |
TestSuiteReport |
TestSuiteReport.exceptionHandler(Handler<Throwable> handler)
Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple
times before the test ends.
|
TestSuiteReport |
TestSuiteReport.handler(Handler<TestCaseReport> handler) |
Modifier and Type | Method and Description |
---|---|
int |
RoutingContext.addBodyEndHandler(Handler<Void> handler)
Add a handler that will be called just before the response body has been completely written.
|
int |
RoutingContext.addHeadersEndHandler(Handler<Void> handler)
Add a handler that will be called just before headers are written to the response.
|
Route |
Route.blockingHandler(Handler<RoutingContext> requestHandler)
Like
Route.blockingHandler(Handler, boolean) called with ordered = true |
Route |
Route.blockingHandler(Handler<RoutingContext> requestHandler,
boolean ordered)
Specify a blocking request handler for the route.
|
Router |
Router.exceptionHandler(Handler<Throwable> exceptionHandler)
Specify a handler for any unhandled exceptions on this router.
|
Route |
Route.failureHandler(Handler<RoutingContext> failureHandler)
Specify a failure handler for the route.
|
Route |
Route.handler(Handler<RoutingContext> requestHandler)
Specify a request handler for the route.
|
Modifier and Type | Interface and Description |
---|---|
interface |
AuthHandler
Base interface for auth handlers.
|
interface |
BasicAuthHandler
An auth handler that provides HTTP Basic Authentication support.
|
interface |
BodyHandler
A handler which gathers the entire request body and sets it on the
RoutingContext . |
interface |
CookieHandler
A handler which decodes cookies from the request, makes them available in the
RoutingContext
and writes them back in the response. |
interface |
CorsHandler
A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
|
interface |
CSRFHandler
This handler adds a CSRF token to requests which mutate state.
|
interface |
ErrorHandler
A pretty error handler for rendering error pages.
|
interface |
FaviconHandler
A handler that serves favicons.
|
interface |
FormLoginHandler
Handler that handles login from a form on a custom login page.
|
interface |
JWTAuthHandler
An auth handler that provides JWT Authentication support.
|
interface |
LoggerHandler
A handler which logs request information to the Vert.x logger.
|
interface |
OAuth2AuthHandler
An auth handler that provides OAuth2 Authentication support.
|
interface |
RedirectAuthHandler
An auth handler that's used to handle auth by redirecting user to a custom login page.
|
interface |
ResponseTimeHandler
Handler which adds a header `x-response-time` in the response of matching requests containing the time taken
in ms to process the request.
|
interface |
SessionHandler
A handler that maintains a
Session for each browser session. |
interface |
StaticHandler
A handler for serving static resources from the file system or classpath.
|
interface |
TemplateHandler
A handler which renders responses using a template engine and where the template name is selected from the URI
path.
|
interface |
TimeoutHandler
Handler that will timeout requests if the response has not been written after a certain time.
|
interface |
UserSessionHandler
This handler should be used if you want to store the User object in the Session so it's available between
different requests, without you having re-authenticate each time.
|
interface |
VirtualHostHandler
Handler that will filter requests based on the request Host name.
|
Modifier and Type | Method and Description |
---|---|
static VirtualHostHandler |
VirtualHostHandler.create(String hostname,
Handler<RoutingContext> handler)
Create a handler
|
Modifier and Type | Interface and Description |
---|---|
interface |
SockJSHandler
A handler that allows you to handle SockJS connections from clients.
|
Modifier and Type | Method and Description |
---|---|
SockJSHandler |
SockJSHandler.bridge(BridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(BridgeOptions) but specifying a handler
that will receive bridge events. |
SockJSSocket |
SockJSSocket.drainHandler(Handler<Void> handler) |
SockJSSocket |
SockJSSocket.endHandler(Handler<Void> endHandler) |
SockJSSocket |
SockJSSocket.exceptionHandler(Handler<Throwable> handler) |
SockJSSocket |
SockJSSocket.handler(Handler<Buffer> handler) |
SockJSHandler |
SockJSHandler.socketHandler(Handler<SockJSSocket> handler)
Set a SockJS socket handler.
|
Modifier and Type | Method and Description |
---|---|
void |
SessionStore.clear(Handler<AsyncResult<Boolean>> resultHandler)
Remove all sessions from the store
|
void |
SessionStore.delete(String id,
Handler<AsyncResult<Boolean>> resultHandler)
Delete the session with the specified ID
|
void |
SessionStore.get(String id,
Handler<AsyncResult<Session>> resultHandler)
Get the session with the specified ID
|
void |
SessionStore.put(Session session,
Handler<AsyncResult<Boolean>> resultHandler)
Add a session with the specified ID
|
void |
SessionStore.size(Handler<AsyncResult<Integer>> resultHandler)
Get the number of sessions in the store
|
Modifier and Type | Method and Description |
---|---|
void |
TemplateEngine.render(RoutingContext context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render
|
Modifier and Type | Class and Description |
---|---|
class |
ReadStreamAdapter<J,R> |
Modifier and Type | Method and Description |
---|---|
void |
RabbitMQClient.basicAck(long deliveryTag,
boolean multiple,
Handler<AsyncResult<JsonObject>> resultHandler)
Acknowledge one or several received messages.
|
void |
RabbitMQClient.basicConsume(String queue,
String address,
boolean autoAck,
Handler<AsyncResult<Void>> resultHandler)
Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
|
void |
RabbitMQClient.basicConsume(String queue,
String address,
Handler<AsyncResult<Void>> resultHandler)
Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
|
void |
RabbitMQClient.basicGet(String queue,
boolean autoAck,
Handler<AsyncResult<JsonObject>> resultHandler)
Retrieve a message from a queue using AMQP.Basic.Get
|
void |
RabbitMQClient.basicNack(long deliveryTag,
boolean multiple,
boolean requeue,
Handler<AsyncResult<JsonObject>> resultHandler)
Reject one or several received messages.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
JsonObject message,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicQos(int prefetchCount,
Handler<AsyncResult<Void>> resultHandler)
Request specific "quality of service" settings, Limiting the number of unacknowledged messages on
a channel (or connection).
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange.
|
void |
RabbitMQClient.exchangeDelete(String exchange,
Handler<AsyncResult<Void>> resultHandler)
Delete an exchange, without regard for whether it is in use or not.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
void |
RabbitMQClient.messageCount(String queue,
Handler<AsyncResult<JsonObject>> resultHandler)
Returns the number of messages in a queue ready to be delivered.
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Handler<AsyncResult<JsonObject>> resultHandler)
Declare a queue
|
void |
RabbitMQClient.queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)
Actively declare a server-named exclusive, autodelete, non-durable queue.
|
void |
RabbitMQClient.queueDelete(String queue,
Handler<AsyncResult<JsonObject>> resultHandler)
Delete a queue, without regard for whether it is in use or has messages on it
|
void |
RabbitMQClient.queueDeleteIf(String queue,
boolean ifUnused,
boolean ifEmpty,
Handler<AsyncResult<JsonObject>> resultHandler)
Delete a queue
|
void |
RabbitMQClient.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ client.
|
void |
RabbitMQClient.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ client.
|
Modifier and Type | Method and Description |
---|---|
RedisClient |
RedisClient.append(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append a value to a key
|
RedisTransaction |
RedisTransaction.append(String key,
String value,
Handler<AsyncResult<String>> handler)
Append a value to a key
|
RedisClient |
RedisClient.auth(String password,
Handler<AsyncResult<String>> handler)
Authenticate to the server
|
RedisTransaction |
RedisTransaction.auth(String password,
Handler<AsyncResult<String>> handler)
Authenticate to the server
|
RedisClient |
RedisClient.bgrewriteaof(Handler<AsyncResult<String>> handler)
Asynchronously rewrite the append-only file
|
RedisTransaction |
RedisTransaction.bgrewriteaof(Handler<AsyncResult<String>> handler)
Asynchronously rewrite the append-only file
|
RedisClient |
RedisClient.bgsave(Handler<AsyncResult<String>> handler)
Asynchronously save the dataset to disk
|
RedisTransaction |
RedisTransaction.bgsave(Handler<AsyncResult<String>> handler)
Asynchronously save the dataset to disk
|
RedisClient |
RedisClient.bitcount(String key,
Handler<AsyncResult<Long>> handler)
Count set bits in a string
|
RedisTransaction |
RedisTransaction.bitcount(String key,
Handler<AsyncResult<String>> handler)
Count set bits in a string
|
RedisClient |
RedisClient.bitcountRange(String key,
long start,
long end,
Handler<AsyncResult<Long>> handler)
Count set bits in a string
|
RedisTransaction |
RedisTransaction.bitcountRange(String key,
long start,
long end,
Handler<AsyncResult<String>> handler)
Count set bits in a string
|
RedisClient |
RedisClient.bitop(BitOperation operation,
String destkey,
List<String> keys,
Handler<AsyncResult<Long>> handler)
Perform bitwise operations between strings
|
RedisTransaction |
RedisTransaction.bitop(BitOperation operation,
String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Perform bitwise operations between strings
|
RedisClient |
RedisClient.bitpos(String key,
int bit,
Handler<AsyncResult<Long>> handler)
Find first bit set or clear in a string
|
RedisTransaction |
RedisTransaction.bitpos(String key,
int bit,
Handler<AsyncResult<String>> handler)
Find first bit set or clear in a string
|
RedisClient |
RedisClient.bitposFrom(String key,
int bit,
int start,
Handler<AsyncResult<Long>> handler)
Find first bit set or clear in a string
See also bitposRange() method, which takes start, and stop offset.
|
RedisTransaction |
RedisTransaction.bitposFrom(String key,
int bit,
int start,
Handler<AsyncResult<String>> handler)
Find first bit set or clear in a string
|
RedisClient |
RedisClient.bitposRange(String key,
int bit,
int start,
int stop,
Handler<AsyncResult<Long>> handler)
Find first bit set or clear in a string
Note: when both start, and stop offsets are specified,
behaviour is slightly different than if only start is specified
|
RedisTransaction |
RedisTransaction.bitposRange(String key,
int bit,
int start,
int stop,
Handler<AsyncResult<String>> handler)
Find first bit set or clear in a string
|
RedisClient |
RedisClient.blpop(String key,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the first element in a list, or block until one is available
|
RedisTransaction |
RedisTransaction.blpop(String key,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the first element in a list, or block until one is available
|
RedisClient |
RedisClient.blpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the first element in any of the lists, or block until one is available
|
RedisTransaction |
RedisTransaction.blpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the first element in any of the lists, or block until one is available
|
RedisClient |
RedisClient.brpop(String key,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the last element in a list, or block until one is available
|
RedisTransaction |
RedisTransaction.brpop(String key,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the last element in a list, or block until one is available
|
RedisClient |
RedisClient.brpoplpush(String key,
String destkey,
int seconds,
Handler<AsyncResult<String>> handler)
Pop a value from a list, push it to another list and return it; or block until one is available
|
RedisTransaction |
RedisTransaction.brpoplpush(String key,
String destkey,
int seconds,
Handler<AsyncResult<String>> handler)
Pop a value from a list, push it to another list and return it; or block until one is available
|
RedisClient |
RedisClient.brpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the last element in any of the lists, or block until one is available
|
RedisTransaction |
RedisTransaction.brpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the last element in any of the lists, or block until one is available
|
RedisClient |
RedisClient.clientGetname(Handler<AsyncResult<String>> handler)
Get the current connection name
|
RedisTransaction |
RedisTransaction.clientGetname(Handler<AsyncResult<String>> handler)
Get the current connection name
|
RedisClient |
RedisClient.clientKill(KillFilter filter,
Handler<AsyncResult<Long>> handler)
Kill the connection of a client
|
RedisTransaction |
RedisTransaction.clientKill(KillFilter filter,
Handler<AsyncResult<String>> handler)
Kill the connection of a client
|
RedisClient |
RedisClient.clientList(Handler<AsyncResult<String>> handler)
Get the list of client connections
|
RedisTransaction |
RedisTransaction.clientList(Handler<AsyncResult<String>> handler)
Get the list of client connections
|
RedisClient |
RedisClient.clientPause(long millis,
Handler<AsyncResult<String>> handler)
Stop processing commands from clients for some time
|
RedisTransaction |
RedisTransaction.clientPause(long millis,
Handler<AsyncResult<String>> handler)
Stop processing commands from clients for some time
|
RedisClient |
RedisClient.clientSetname(String name,
Handler<AsyncResult<String>> handler)
Set the current connection name
|
RedisTransaction |
RedisTransaction.clientSetname(String name,
Handler<AsyncResult<String>> handler)
Set the current connection name
|
void |
RedisClient.close(Handler<AsyncResult<Void>> handler)
Close the client - when it is fully closed the handler will be called.
|
void |
RedisTransaction.close(Handler<AsyncResult<Void>> handler)
Close the client - when it is fully closed the handler will be called.
|
RedisClient |
RedisClient.clusterAddslots(List<Long> slots,
Handler<AsyncResult<Void>> handler)
Assign new hash slots to receiving node.
|
RedisTransaction |
RedisTransaction.clusterAddslots(List<String> slots,
Handler<AsyncResult<String>> handler)
Assign new hash slots to receiving node.
|
RedisClient |
RedisClient.clusterCountFailureReports(String nodeId,
Handler<AsyncResult<Long>> handler)
Return the number of failure reports active for a given node.
|
RedisTransaction |
RedisTransaction.clusterCountFailureReports(String nodeId,
Handler<AsyncResult<String>> handler)
Return the number of failure reports active for a given node.
|
RedisClient |
RedisClient.clusterCountkeysinslot(long slot,
Handler<AsyncResult<Long>> handler)
Return the number of local keys in the specified hash slot.
|
RedisTransaction |
RedisTransaction.clusterCountkeysinslot(long slot,
Handler<AsyncResult<String>> handler)
Return the number of local keys in the specified hash slot.
|
RedisTransaction |
RedisTransaction.clusterDelslots(long slot,
Handler<AsyncResult<String>> handler)
Set hash slots as unbound in receiving node.
|
RedisClient |
RedisClient.clusterDelslots(long slot,
Handler<AsyncResult<Void>> handler)
Set hash slots as unbound in receiving node.
|
RedisClient |
RedisClient.clusterDelslotsMany(List<Long> slots,
Handler<AsyncResult<Void>> handler)
Set hash slots as unbound in receiving node.
|
RedisTransaction |
RedisTransaction.clusterDelslotsMany(List<String> slots,
Handler<AsyncResult<String>> handler)
Set hash slots as unbound in receiving node.
|
RedisTransaction |
RedisTransaction.clusterFailover(Handler<AsyncResult<String>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisClient |
RedisClient.clusterFailover(Handler<AsyncResult<Void>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisTransaction |
RedisTransaction.clusterFailOverWithOptions(FailoverOptions options,
Handler<AsyncResult<String>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisClient |
RedisClient.clusterFailOverWithOptions(FailoverOptions options,
Handler<AsyncResult<Void>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisTransaction |
RedisTransaction.clusterForget(String nodeId,
Handler<AsyncResult<String>> handler)
Remove a node from the nodes table.
|
RedisClient |
RedisClient.clusterForget(String nodeId,
Handler<AsyncResult<Void>> handler)
Remove a node from the nodes table.
|
RedisClient |
RedisClient.clusterGetkeysinslot(long slot,
long count,
Handler<AsyncResult<JsonArray>> handler)
Return local key names in the specified hash slot.
|
RedisTransaction |
RedisTransaction.clusterGetkeysinslot(long slot,
long count,
Handler<AsyncResult<String>> handler)
Return local key names in the specified hash slot.
|
RedisClient |
RedisClient.clusterInfo(Handler<AsyncResult<JsonArray>> handler)
Provides info about Redis Cluster node state.
|
RedisTransaction |
RedisTransaction.clusterInfo(Handler<AsyncResult<String>> handler)
Provides info about Redis Cluster node state.
|
RedisClient |
RedisClient.clusterKeyslot(String key,
Handler<AsyncResult<Long>> handler)
Returns the hash slot of the specified key.
|
RedisTransaction |
RedisTransaction.clusterKeyslot(String key,
Handler<AsyncResult<String>> handler)
Returns the hash slot of the specified key.
|
RedisTransaction |
RedisTransaction.clusterMeet(String ip,
long port,
Handler<AsyncResult<String>> handler)
Force a node cluster to handshake with another node.
|
RedisClient |
RedisClient.clusterMeet(String ip,
long port,
Handler<AsyncResult<Void>> handler)
Force a node cluster to handshake with another node.
|
RedisClient |
RedisClient.clusterNodes(Handler<AsyncResult<JsonArray>> handler)
Get Cluster config for the node.
|
RedisTransaction |
RedisTransaction.clusterNodes(Handler<AsyncResult<String>> handler)
Get Cluster config for the node.
|
RedisTransaction |
RedisTransaction.clusterReplicate(String nodeId,
Handler<AsyncResult<String>> handler)
Reconfigure a node as a slave of the specified master node.
|
RedisClient |
RedisClient.clusterReplicate(String nodeId,
Handler<AsyncResult<Void>> handler)
Reconfigure a node as a slave of the specified master node.
|
RedisTransaction |
RedisTransaction.clusterReset(Handler<AsyncResult<String>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterReset(Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisTransaction |
RedisTransaction.clusterResetWithOptions(ResetOptions options,
Handler<AsyncResult<String>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterResetWithOptions(ResetOptions options,
Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisTransaction |
RedisTransaction.clusterSaveconfig(Handler<AsyncResult<String>> handler)
Forces the node to save cluster state on disk.
|
RedisClient |
RedisClient.clusterSaveconfig(Handler<AsyncResult<Void>> handler)
Forces the node to save cluster state on disk.
|
RedisTransaction |
RedisTransaction.clusterSetConfigEpoch(long epoch,
Handler<AsyncResult<String>> handler)
Set the configuration epoch in a new node.
|
RedisClient |
RedisClient.clusterSetConfigEpoch(long epoch,
Handler<AsyncResult<Void>> handler)
Set the configuration epoch in a new node.
|
RedisTransaction |
RedisTransaction.clusterSetslot(long slot,
SlotCmd subcommand,
Handler<AsyncResult<String>> handler)
Bind an hash slot to a specific node.
|
RedisClient |
RedisClient.clusterSetslot(long slot,
SlotCmd subcommand,
Handler<AsyncResult<Void>> handler)
Bind an hash slot to a specific node.
|
RedisTransaction |
RedisTransaction.clusterSetslotWithNode(long slot,
SlotCmd subcommand,
String nodeId,
Handler<AsyncResult<String>> handler)
Bind an hash slot to a specific node.
|
RedisClient |
RedisClient.clusterSetslotWithNode(long slot,
SlotCmd subcommand,
String nodeId,
Handler<AsyncResult<Void>> handler)
Bind an hash slot to a specific node.
|
RedisClient |
RedisClient.clusterSlaves(String nodeId,
Handler<AsyncResult<JsonArray>> handler)
List slave nodes of the specified master node.
|
RedisTransaction |
RedisTransaction.clusterSlaves(String nodeId,
Handler<AsyncResult<String>> handler)
List slave nodes of the specified master node.
|
RedisClient |
RedisClient.clusterSlots(Handler<AsyncResult<JsonArray>> handler)
Get array of Cluster slot to node mappings
|
RedisTransaction |
RedisTransaction.clusterSlots(Handler<AsyncResult<String>> handler)
Get array of Cluster slot to node mappings
|
RedisClient |
RedisClient.command(Handler<AsyncResult<JsonArray>> handler)
Get array of Redis command details
|
RedisTransaction |
RedisTransaction.command(Handler<AsyncResult<String>> handler)
Get array of Redis command details
|
RedisClient |
RedisClient.commandCount(Handler<AsyncResult<Long>> handler)
Get total number of Redis commands
|
RedisTransaction |
RedisTransaction.commandCount(Handler<AsyncResult<String>> handler)
Get total number of Redis commands
|
RedisClient |
RedisClient.commandGetkeys(Handler<AsyncResult<JsonArray>> handler)
Extract keys given a full Redis command
|
RedisTransaction |
RedisTransaction.commandGetkeys(Handler<AsyncResult<String>> handler)
Extract keys given a full Redis command
|
RedisClient |
RedisClient.commandInfo(List<String> commands,
Handler<AsyncResult<JsonArray>> handler)
Get array of specific Redis command details
|
RedisTransaction |
RedisTransaction.commandInfo(List<String> commands,
Handler<AsyncResult<String>> handler)
Get array of specific Redis command details
|
RedisClient |
RedisClient.configGet(String parameter,
Handler<AsyncResult<JsonArray>> handler)
Get the value of a configuration parameter
|
RedisTransaction |
RedisTransaction.configGet(String parameter,
Handler<AsyncResult<String>> handler)
Get the value of a configuration parameter
|
RedisClient |
RedisClient.configResetstat(Handler<AsyncResult<String>> handler)
Reset the stats returned by INFO
|
RedisTransaction |
RedisTransaction.configResetstat(Handler<AsyncResult<String>> handler)
Reset the stats returned by INFO
|
RedisClient |
RedisClient.configRewrite(Handler<AsyncResult<String>> handler)
Rewrite the configuration file with the in memory configuration
|
RedisTransaction |
RedisTransaction.configRewrite(Handler<AsyncResult<String>> handler)
Rewrite the configuration file with the in memory configuration
|
RedisClient |
RedisClient.configSet(String parameter,
String value,
Handler<AsyncResult<String>> handler)
Set a configuration parameter to the given value
|
RedisTransaction |
RedisTransaction.configSet(String parameter,
String value,
Handler<AsyncResult<String>> handler)
Set a configuration parameter to the given value
|
RedisClient |
RedisClient.dbsize(Handler<AsyncResult<Long>> handler)
Return the number of keys in the selected database
|
RedisTransaction |
RedisTransaction.dbsize(Handler<AsyncResult<String>> handler)
Return the number of keys in the selected database
|
RedisClient |
RedisClient.debugObject(String key,
Handler<AsyncResult<String>> handler)
Get debugging information about a key
|
RedisTransaction |
RedisTransaction.debugObject(String key,
Handler<AsyncResult<String>> handler)
Get debugging information about a key
|
RedisClient |
RedisClient.debugSegfault(Handler<AsyncResult<String>> handler)
Make the server crash
|
RedisTransaction |
RedisTransaction.debugSegfault(Handler<AsyncResult<String>> handler)
Make the server crash
|
RedisClient |
RedisClient.decr(String key,
Handler<AsyncResult<Long>> handler)
Decrement the integer value of a key by one
|
RedisTransaction |
RedisTransaction.decr(String key,
Handler<AsyncResult<String>> handler)
Decrement the integer value of a key by one
|
RedisClient |
RedisClient.decrby(String key,
long decrement,
Handler<AsyncResult<Long>> handler)
Decrement the integer value of a key by the given number
|
RedisTransaction |
RedisTransaction.decrby(String key,
long decrement,
Handler<AsyncResult<String>> handler)
Decrement the integer value of a key by the given number
|
RedisClient |
RedisClient.del(String key,
Handler<AsyncResult<Long>> handler)
Delete a key
|
RedisTransaction |
RedisTransaction.del(String key,
Handler<AsyncResult<String>> handler)
Delete a key
|
RedisClient |
RedisClient.delMany(List<String> keys,
Handler<AsyncResult<Long>> handler)
Delete many keys
|
RedisTransaction |
RedisTransaction.delMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Delete many keys
|
RedisTransaction |
RedisTransaction.discard(Handler<AsyncResult<String>> handler)
Discard all commands issued after MULTI
|
RedisClient |
RedisClient.dump(String key,
Handler<AsyncResult<String>> handler)
Return a serialized version of the value stored at the specified key.
|
RedisTransaction |
RedisTransaction.dump(String key,
Handler<AsyncResult<String>> handler)
Return a serialized version of the value stored at the specified key.
|
RedisClient |
RedisClient.echo(String message,
Handler<AsyncResult<String>> handler)
Echo the given string
|
RedisTransaction |
RedisTransaction.echo(String message,
Handler<AsyncResult<String>> handler)
Echo the given string
|
RedisClient |
RedisClient.eval(String script,
List<String> keys,
List<String> args,
Handler<AsyncResult<JsonArray>> handler)
Execute a Lua script server side.
|
RedisTransaction |
RedisTransaction.eval(String script,
List<String> keys,
List<String> args,
Handler<AsyncResult<String>> handler)
Execute a Lua script server side.
|
RedisClient |
RedisClient.evalsha(String sha1,
List<String> keys,
List<String> values,
Handler<AsyncResult<JsonArray>> handler)
Execute a Lua script server side.
|
RedisTransaction |
RedisTransaction.evalsha(String sha1,
List<String> keys,
List<String> values,
Handler<AsyncResult<String>> handler)
Execute a Lua script server side.
|
RedisTransaction |
RedisTransaction.exec(Handler<AsyncResult<JsonArray>> handler)
Execute all commands issued after MULTI
|
RedisClient |
RedisClient.exists(String key,
Handler<AsyncResult<Long>> handler)
Determine if a key exists
|
RedisTransaction |
RedisTransaction.exists(String key,
Handler<AsyncResult<String>> handler)
Determine if a key exists
|
RedisClient |
RedisClient.expire(String key,
int seconds,
Handler<AsyncResult<Long>> handler)
Set a key's time to live in seconds
|
RedisTransaction |
RedisTransaction.expire(String key,
int seconds,
Handler<AsyncResult<String>> handler)
Set a key's time to live in seconds
|
RedisClient |
RedisClient.expireat(String key,
long seconds,
Handler<AsyncResult<Long>> handler)
Set the expiration for a key as a UNIX timestamp
|
RedisTransaction |
RedisTransaction.expireat(String key,
long seconds,
Handler<AsyncResult<String>> handler)
Set the expiration for a key as a UNIX timestamp
|
RedisClient |
RedisClient.flushall(Handler<AsyncResult<String>> handler)
Remove all keys from all databases
|
RedisTransaction |
RedisTransaction.flushall(Handler<AsyncResult<String>> handler)
Remove all keys from all databases
|
RedisClient |
RedisClient.flushdb(Handler<AsyncResult<String>> handler)
Remove all keys from the current database
|
RedisTransaction |
RedisTransaction.flushdb(Handler<AsyncResult<String>> handler)
Remove all keys from the current database
|
RedisClient |
RedisClient.geoadd(String key,
double longitude,
double latitude,
String member,
Handler<AsyncResult<Long>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisTransaction |
RedisTransaction.geoadd(String key,
double longitude,
double latitude,
String member,
Handler<AsyncResult<String>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisClient |
RedisClient.geoaddMany(String key,
List<GeoMember> members,
Handler<AsyncResult<Long>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisTransaction |
RedisTransaction.geoaddMany(String key,
List<GeoMember> members,
Handler<AsyncResult<String>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisClient |
RedisClient.geodist(String key,
String member1,
String member2,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.geodist(String key,
String member1,
String member2,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisClient |
RedisClient.geodistWithUnit(String key,
String member1,
String member2,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.geodistWithUnit(String key,
String member1,
String member2,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisClient |
RedisClient.geohash(String key,
String member,
Handler<AsyncResult<JsonArray>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisTransaction |
RedisTransaction.geohash(String key,
String member,
Handler<AsyncResult<String>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisClient |
RedisClient.geohashMany(String key,
List<String> members,
Handler<AsyncResult<JsonArray>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisTransaction |
RedisTransaction.geohashMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisClient |
RedisClient.geopos(String key,
String member,
Handler<AsyncResult<JsonArray>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisTransaction |
RedisTransaction.geopos(String key,
String member,
Handler<AsyncResult<String>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisClient |
RedisClient.geoposMany(String key,
List<String> members,
Handler<AsyncResult<JsonArray>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisTransaction |
RedisTransaction.geoposMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisClient |
RedisClient.georadius(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
Handler<AsyncResult<JsonArray>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisTransaction |
RedisTransaction.georadius(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisClient |
RedisClient.georadiusbymember(String key,
String member,
double radius,
GeoUnit unit,
Handler<AsyncResult<JsonArray>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.georadiusbymember(String key,
String member,
double radius,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisClient |
RedisClient.georadiusbymemberWithOptions(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<JsonArray>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.georadiusbymemberWithOptions(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<String>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisClient |
RedisClient.georadiusWithOptions(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisTransaction |
RedisTransaction.georadiusWithOptions(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<String>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisClient |
RedisClient.get(String key,
Handler<AsyncResult<String>> handler)
Get the value of a key
|
RedisTransaction |
RedisTransaction.get(String key,
Handler<AsyncResult<String>> handler)
Get the value of a key
|
RedisClient |
RedisClient.getBinary(String key,
Handler<AsyncResult<Buffer>> handler)
Get the value of a key - without decoding as utf-8
|
RedisTransaction |
RedisTransaction.getBinary(String key,
Handler<AsyncResult<String>> handler)
Get the value of a key - without decoding as utf-8
|
RedisClient |
RedisClient.getbit(String key,
long offset,
Handler<AsyncResult<Long>> handler)
Returns the bit value at offset in the string value stored at key
|
RedisTransaction |
RedisTransaction.getbit(String key,
long offset,
Handler<AsyncResult<String>> handler)
Returns the bit value at offset in the string value stored at key
|
RedisClient |
RedisClient.getrange(String key,
long start,
long end,
Handler<AsyncResult<String>> handler)
Get a substring of the string stored at a key
|
RedisTransaction |
RedisTransaction.getrange(String key,
long start,
long end,
Handler<AsyncResult<String>> handler)
Get a substring of the string stored at a key
|
RedisClient |
RedisClient.getset(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a key and return its old value
|
RedisTransaction |
RedisTransaction.getset(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a key and return its old value
|
RedisClient |
RedisClient.hdel(String key,
String field,
Handler<AsyncResult<Long>> handler)
Delete one or more hash fields
|
RedisTransaction |
RedisTransaction.hdel(String key,
String field,
Handler<AsyncResult<String>> handler)
Delete one or more hash fields
|
RedisClient |
RedisClient.hdelMany(String key,
List<String> fields,
Handler<AsyncResult<Long>> handler)
Delete one or more hash fields
|
RedisTransaction |
RedisTransaction.hdelMany(String key,
List<String> fields,
Handler<AsyncResult<String>> handler)
Delete one or more hash fields
|
RedisClient |
RedisClient.hexists(String key,
String field,
Handler<AsyncResult<Long>> handler)
Determine if a hash field exists
|
RedisTransaction |
RedisTransaction.hexists(String key,
String field,
Handler<AsyncResult<String>> handler)
Determine if a hash field exists
|
RedisClient |
RedisClient.hget(String key,
String field,
Handler<AsyncResult<String>> handler)
Get the value of a hash field
|
RedisTransaction |
RedisTransaction.hget(String key,
String field,
Handler<AsyncResult<String>> handler)
Get the value of a hash field
|
RedisClient |
RedisClient.hgetall(String key,
Handler<AsyncResult<JsonObject>> handler)
Get all the fields and values in a hash
|
RedisTransaction |
RedisTransaction.hgetall(String key,
Handler<AsyncResult<String>> handler)
Get all the fields and values in a hash
|
RedisClient |
RedisClient.hincrby(String key,
String field,
long increment,
Handler<AsyncResult<Long>> handler)
Increment the integer value of a hash field by the given number
|
RedisTransaction |
RedisTransaction.hincrby(String key,
String field,
long increment,
Handler<AsyncResult<String>> handler)
Increment the integer value of a hash field by the given number
|
RedisClient |
RedisClient.hincrbyfloat(String key,
String field,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a hash field by the given amount
|
RedisTransaction |
RedisTransaction.hincrbyfloat(String key,
String field,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a hash field by the given amount
|
RedisClient |
RedisClient.hkeys(String key,
Handler<AsyncResult<JsonArray>> handler)
Get all the fields in a hash
|
RedisTransaction |
RedisTransaction.hkeys(String key,
Handler<AsyncResult<String>> handler)
Get all the fields in a hash
|
RedisClient |
RedisClient.hlen(String key,
Handler<AsyncResult<Long>> handler)
Get the number of fields in a hash
|
RedisTransaction |
RedisTransaction.hlen(String key,
Handler<AsyncResult<String>> handler)
Get the number of fields in a hash
|
RedisClient |
RedisClient.hmget(String key,
List<String> fields,
Handler<AsyncResult<JsonArray>> handler)
Get the values of all the given hash fields
|
RedisTransaction |
RedisTransaction.hmget(String key,
List<String> fields,
Handler<AsyncResult<String>> handler)
Get the values of all the given hash fields
|
RedisClient |
RedisClient.hmset(String key,
JsonObject values,
Handler<AsyncResult<String>> handler)
Set multiple hash fields to multiple values
|
RedisTransaction |
RedisTransaction.hmset(String key,
JsonObject values,
Handler<AsyncResult<String>> handler)
Set multiple hash fields to multiple values
|
RedisClient |
RedisClient.hscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate hash fields and associated values
|
RedisTransaction |
RedisTransaction.hscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate hash fields and associated values
|
RedisClient |
RedisClient.hset(String key,
String field,
String value,
Handler<AsyncResult<Long>> handler)
Set the string value of a hash field
|
RedisTransaction |
RedisTransaction.hset(String key,
String field,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a hash field
|
RedisClient |
RedisClient.hsetnx(String key,
String field,
String value,
Handler<AsyncResult<Long>> handler)
Set the value of a hash field, only if the field does not exist
|
RedisTransaction |
RedisTransaction.hsetnx(String key,
String field,
String value,
Handler<AsyncResult<String>> handler)
Set the value of a hash field, only if the field does not exist
|
RedisClient |
RedisClient.hvals(String key,
Handler<AsyncResult<JsonArray>> handler)
Get all the values in a hash
|
RedisTransaction |
RedisTransaction.hvals(String key,
Handler<AsyncResult<String>> handler)
Get all the values in a hash
|
RedisClient |
RedisClient.incr(String key,
Handler<AsyncResult<Long>> handler)
Increment the integer value of a key by one
|
RedisTransaction |
RedisTransaction.incr(String key,
Handler<AsyncResult<String>> handler)
Increment the integer value of a key by one
|
RedisClient |
RedisClient.incrby(String key,
long increment,
Handler<AsyncResult<Long>> handler)
Increment the integer value of a key by the given amount
|
RedisTransaction |
RedisTransaction.incrby(String key,
long increment,
Handler<AsyncResult<String>> handler)
Increment the integer value of a key by the given amount
|
RedisClient |
RedisClient.incrbyfloat(String key,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a key by the given amount
|
RedisTransaction |
RedisTransaction.incrbyfloat(String key,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a key by the given amount
|
RedisClient |
RedisClient.info(Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisTransaction |
RedisTransaction.info(Handler<AsyncResult<String>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.infoSection(String section,
Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisTransaction |
RedisTransaction.infoSection(String section,
Handler<AsyncResult<String>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.keys(String pattern,
Handler<AsyncResult<JsonArray>> handler)
Find all keys matching the given pattern
|
RedisTransaction |
RedisTransaction.keys(String pattern,
Handler<AsyncResult<String>> handler)
Find all keys matching the given pattern
|
RedisClient |
RedisClient.lastsave(Handler<AsyncResult<Long>> handler)
Get the UNIX time stamp of the last successful save to disk
|
RedisTransaction |
RedisTransaction.lastsave(Handler<AsyncResult<String>> handler)
Get the UNIX time stamp of the last successful save to disk
|
RedisClient |
RedisClient.lindex(String key,
int index,
Handler<AsyncResult<String>> handler)
Get an element from a list by its index
|
RedisTransaction |
RedisTransaction.lindex(String key,
int index,
Handler<AsyncResult<String>> handler)
Get an element from a list by its index
|
RedisClient |
RedisClient.linsert(String key,
InsertOptions option,
String pivot,
String value,
Handler<AsyncResult<Long>> handler)
Insert an element before or after another element in a list
|
RedisTransaction |
RedisTransaction.linsert(String key,
InsertOptions option,
String pivot,
String value,
Handler<AsyncResult<String>> handler)
Insert an element before or after another element in a list
|
RedisClient |
RedisClient.llen(String key,
Handler<AsyncResult<Long>> handler)
Get the length of a list
|
RedisTransaction |
RedisTransaction.llen(String key,
Handler<AsyncResult<String>> handler)
Get the length of a list
|
RedisClient |
RedisClient.lpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the first element in a list
|
RedisTransaction |
RedisTransaction.lpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the first element in a list
|
RedisClient |
RedisClient.lpush(String key,
String value,
Handler<AsyncResult<Long>> handler)
Prepend one value to a list
|
RedisTransaction |
RedisTransaction.lpush(String key,
String value,
Handler<AsyncResult<String>> handler)
Prepend one value to a list
|
RedisClient |
RedisClient.lpushMany(String key,
List<String> values,
Handler<AsyncResult<Long>> handler)
Prepend one or multiple values to a list
|
RedisTransaction |
RedisTransaction.lpushMany(String key,
List<String> values,
Handler<AsyncResult<String>> handler)
Prepend one or multiple values to a list
|
RedisClient |
RedisClient.lpushx(String key,
String value,
Handler<AsyncResult<Long>> handler)
Prepend a value to a list, only if the list exists
|
RedisTransaction |
RedisTransaction.lpushx(String key,
String value,
Handler<AsyncResult<String>> handler)
Prepend a value to a list, only if the list exists
|
RedisClient |
RedisClient.lrange(String key,
long from,
long to,
Handler<AsyncResult<JsonArray>> handler)
Get a range of elements from a list
|
RedisTransaction |
RedisTransaction.lrange(String key,
long from,
long to,
Handler<AsyncResult<String>> handler)
Get a range of elements from a list
|
RedisClient |
RedisClient.lrem(String key,
long count,
String value,
Handler<AsyncResult<Long>> handler)
Remove elements from a list
|
RedisTransaction |
RedisTransaction.lrem(String key,
long count,
String value,
Handler<AsyncResult<String>> handler)
Remove elements from a list
|
RedisClient |
RedisClient.lset(String key,
long index,
String value,
Handler<AsyncResult<String>> handler)
Set the value of an element in a list by its index
|
RedisTransaction |
RedisTransaction.lset(String key,
long index,
String value,
Handler<AsyncResult<String>> handler)
Set the value of an element in a list by its index
|
RedisClient |
RedisClient.ltrim(String key,
long from,
long to,
Handler<AsyncResult<String>> handler)
Trim a list to the specified range
|
RedisTransaction |
RedisTransaction.ltrim(String key,
long from,
long to,
Handler<AsyncResult<String>> handler)
Trim a list to the specified range
|
RedisClient |
RedisClient.mget(String key,
Handler<AsyncResult<JsonArray>> handler)
Get the value of the given key
|
RedisTransaction |
RedisTransaction.mget(String key,
Handler<AsyncResult<String>> handler)
Get the value of the given key
|
RedisClient |
RedisClient.mgetMany(List<String> keys,
Handler<AsyncResult<JsonArray>> handler)
Get the values of all the given keys
|
RedisTransaction |
RedisTransaction.mgetMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Get the values of all the given keys
|
RedisClient |
RedisClient.migrate(String host,
int port,
String key,
int destdb,
long timeout,
MigrateOptions options,
Handler<AsyncResult<String>> handler)
Atomically transfer a key from a Redis instance to another one.
|
RedisTransaction |
RedisTransaction.migrate(String host,
int port,
String key,
int destdb,
long timeout,
MigrateOptions options,
Handler<AsyncResult<String>> handler)
Atomically transfer a key from a Redis instance to another one.
|
RedisTransaction |
RedisTransaction.monitor(Handler<AsyncResult<String>> handler)
Listen for all requests received by the server in real time
|
RedisClient |
RedisClient.monitor(Handler<AsyncResult<Void>> handler)
Listen for all requests received by the server in real time
|
RedisClient |
RedisClient.move(String key,
int destdb,
Handler<AsyncResult<Long>> handler)
Move a key to another database
|
RedisTransaction |
RedisTransaction.move(String key,
int destdb,
Handler<AsyncResult<String>> handler)
Move a key to another database
|
RedisClient |
RedisClient.mset(JsonObject keyvals,
Handler<AsyncResult<String>> handler)
Set multiple keys to multiple values
|
RedisTransaction |
RedisTransaction.mset(JsonObject keyvals,
Handler<AsyncResult<String>> handler)
Set multiple keys to multiple values
|
RedisClient |
RedisClient.msetnx(JsonObject keyvals,
Handler<AsyncResult<Long>> handler)
Set multiple keys to multiple values, only if none of the keys exist
|
RedisTransaction |
RedisTransaction.msetnx(JsonObject keyvals,
Handler<AsyncResult<String>> handler)
Set multiple keys to multiple values, only if none of the keys exist
|
RedisTransaction |
RedisTransaction.multi(Handler<AsyncResult<String>> handler)
Mark the start of a RedisTransaction block
|
RedisTransaction |
RedisTransaction.object(String key,
ObjectCmd cmd,
Handler<AsyncResult<String>> handler)
Inspect the internals of Redis objects
|
RedisClient |
RedisClient.object(String key,
ObjectCmd cmd,
Handler<AsyncResult<Void>> handler)
Inspect the internals of Redis objects
|
RedisClient |
RedisClient.persist(String key,
Handler<AsyncResult<Long>> handler)
Remove the expiration from a key
|
RedisTransaction |
RedisTransaction.persist(String key,
Handler<AsyncResult<String>> handler)
Remove the expiration from a key
|
RedisClient |
RedisClient.pexpire(String key,
long millis,
Handler<AsyncResult<Long>> handler)
Set a key's time to live in milliseconds
|
RedisTransaction |
RedisTransaction.pexpire(String key,
long millis,
Handler<AsyncResult<String>> handler)
Set a key's time to live in milliseconds
|
RedisClient |
RedisClient.pexpireat(String key,
long millis,
Handler<AsyncResult<Long>> handler)
Set the expiration for a key as a UNIX timestamp specified in milliseconds
|
RedisTransaction |
RedisTransaction.pexpireat(String key,
long millis,
Handler<AsyncResult<String>> handler)
Set the expiration for a key as a UNIX timestamp specified in milliseconds
|
RedisClient |
RedisClient.pfadd(String key,
String element,
Handler<AsyncResult<Long>> handler)
Adds the specified element to the specified HyperLogLog.
|
RedisTransaction |
RedisTransaction.pfadd(String key,
String element,
Handler<AsyncResult<String>> handler)
Adds the specified element to the specified HyperLogLog.
|
RedisClient |
RedisClient.pfaddMany(String key,
List<String> elements,
Handler<AsyncResult<Long>> handler)
Adds the specified elements to the specified HyperLogLog.
|
RedisTransaction |
RedisTransaction.pfaddMany(String key,
List<String> elements,
Handler<AsyncResult<String>> handler)
Adds the specified elements to the specified HyperLogLog.
|
RedisClient |
RedisClient.pfcount(String key,
Handler<AsyncResult<Long>> handler)
Return the approximated cardinality of the set observed by the HyperLogLog at key.
|
RedisTransaction |
RedisTransaction.pfcount(String key,
Handler<AsyncResult<String>> handler)
Return the approximated cardinality of the set observed by the HyperLogLog at key.
|
RedisClient |
RedisClient.pfcountMany(List<String> keys,
Handler<AsyncResult<Long>> handler)
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
|
RedisTransaction |
RedisTransaction.pfcountMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
|
RedisClient |
RedisClient.pfmerge(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Merge N different HyperLogLogs into a single one.
|
RedisTransaction |
RedisTransaction.pfmerge(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Merge N different HyperLogLogs into a single one.
|
RedisClient |
RedisClient.ping(Handler<AsyncResult<String>> handler)
Ping the server
|
RedisTransaction |
RedisTransaction.ping(Handler<AsyncResult<String>> handler)
Ping the server
|
RedisTransaction |
RedisTransaction.psetex(String key,
long millis,
String value,
Handler<AsyncResult<String>> handler)
Set the value and expiration in milliseconds of a key
|
RedisClient |
RedisClient.psetex(String key,
long millis,
String value,
Handler<AsyncResult<Void>> handler)
Set the value and expiration in milliseconds of a key
|
RedisClient |
RedisClient.psubscribe(String pattern,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to channels matching the given pattern
|
RedisTransaction |
RedisTransaction.psubscribe(String pattern,
Handler<AsyncResult<String>> handler)
Listen for messages published to channels matching the given pattern
|
RedisClient |
RedisClient.psubscribeMany(List<String> patterns,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to channels matching the given patterns
|
RedisTransaction |
RedisTransaction.psubscribeMany(List<String> patterns,
Handler<AsyncResult<String>> handler)
Listen for messages published to channels matching the given patterns
|
RedisClient |
RedisClient.pttl(String key,
Handler<AsyncResult<Long>> handler)
Get the time to live for a key in milliseconds
|
RedisTransaction |
RedisTransaction.pttl(String key,
Handler<AsyncResult<String>> handler)
Get the time to live for a key in milliseconds
|
RedisClient |
RedisClient.publish(String channel,
String message,
Handler<AsyncResult<Long>> handler)
Post a message to a channel
|
RedisTransaction |
RedisTransaction.publish(String channel,
String message,
Handler<AsyncResult<String>> handler)
Post a message to a channel
|
RedisClient |
RedisClient.pubsubChannels(String pattern,
Handler<AsyncResult<JsonArray>> handler)
Lists the currently active channels - only those matching the pattern
|
RedisTransaction |
RedisTransaction.pubsubChannels(String pattern,
Handler<AsyncResult<String>> handler)
Lists the currently active channels - only those matching the pattern
|
RedisClient |
RedisClient.pubsubNumpat(Handler<AsyncResult<Long>> handler)
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
|
RedisTransaction |
RedisTransaction.pubsubNumpat(Handler<AsyncResult<String>> handler)
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
|
RedisClient |
RedisClient.pubsubNumsub(List<String> channels,
Handler<AsyncResult<JsonArray>> handler)
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
|
RedisTransaction |
RedisTransaction.pubsubNumsub(List<String> channels,
Handler<AsyncResult<String>> handler)
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
|
RedisTransaction |
RedisTransaction.punsubscribe(List<String> patterns,
Handler<AsyncResult<String>> handler)
Stop listening for messages posted to channels matching the given patterns
|
RedisClient |
RedisClient.punsubscribe(List<String> patterns,
Handler<AsyncResult<Void>> handler)
Stop listening for messages posted to channels matching the given patterns
|
RedisClient |
RedisClient.randomkey(Handler<AsyncResult<String>> handler)
Return a random key from the keyspace
|
RedisTransaction |
RedisTransaction.randomkey(Handler<AsyncResult<String>> handler)
Return a random key from the keyspace
|
RedisClient |
RedisClient.rename(String key,
String newkey,
Handler<AsyncResult<String>> handler)
Rename a key
|
RedisTransaction |
RedisTransaction.rename(String key,
String newkey,
Handler<AsyncResult<String>> handler)
Rename a key
|
RedisClient |
RedisClient.renamenx(String key,
String newkey,
Handler<AsyncResult<Long>> handler)
Rename a key, only if the new key does not exist
|
RedisTransaction |
RedisTransaction.renamenx(String key,
String newkey,
Handler<AsyncResult<String>> handler)
Rename a key, only if the new key does not exist
|
RedisClient |
RedisClient.restore(String key,
long millis,
String serialized,
Handler<AsyncResult<String>> handler)
Create a key using the provided serialized value, previously obtained using DUMP.
|
RedisTransaction |
RedisTransaction.restore(String key,
long millis,
String serialized,
Handler<AsyncResult<String>> handler)
Create a key using the provided serialized value, previously obtained using DUMP.
|
RedisClient |
RedisClient.role(Handler<AsyncResult<JsonArray>> handler)
Return the role of the instance in the context of replication
|
RedisTransaction |
RedisTransaction.role(Handler<AsyncResult<String>> handler)
Return the role of the instance in the context of replication
|
RedisClient |
RedisClient.rpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the last element in a list
|
RedisTransaction |
RedisTransaction.rpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the last element in a list
|
RedisClient |
RedisClient.rpoplpush(String key,
String destkey,
Handler<AsyncResult<String>> handler)
Remove the last element in a list, append it to another list and return it
|
RedisTransaction |
RedisTransaction.rpoplpush(String key,
String destkey,
Handler<AsyncResult<String>> handler)
Remove the last element in a list, append it to another list and return it
|
RedisClient |
RedisClient.rpush(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append one or multiple values to a list
|
RedisTransaction |
RedisTransaction.rpush(String key,
String value,
Handler<AsyncResult<String>> handler)
Append one or multiple values to a list
|
RedisClient |
RedisClient.rpushMany(String key,
List<String> values,
Handler<AsyncResult<Long>> handler)
Append one or multiple values to a list
|
RedisTransaction |
RedisTransaction.rpushMany(String key,
List<String> values,
Handler<AsyncResult<String>> handler)
Append one or multiple values to a list
|
RedisClient |
RedisClient.rpushx(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append a value to a list, only if the list exists
|
RedisTransaction |
RedisTransaction.rpushx(String key,
String value,
Handler<AsyncResult<String>> handler)
Append a value to a list, only if the list exists
|
RedisClient |
RedisClient.sadd(String key,
String member,
Handler<AsyncResult<Long>> handler)
Add a member to a set
|
RedisTransaction |
RedisTransaction.sadd(String key,
String member,
Handler<AsyncResult<String>> handler)
Add a member to a set
|
RedisClient |
RedisClient.saddMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Add one or more members to a set
|
RedisTransaction |
RedisTransaction.saddMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Add one or more members to a set
|
RedisClient |
RedisClient.save(Handler<AsyncResult<String>> handler)
Synchronously save the dataset to disk
|
RedisTransaction |
RedisTransaction.save(Handler<AsyncResult<String>> handler)
Synchronously save the dataset to disk
|
RedisClient |
RedisClient.scan(String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate the keys space
|
RedisTransaction |
RedisTransaction.scan(String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate the keys space
|
RedisClient |
RedisClient.scard(String key,
Handler<AsyncResult<Long>> handler)
Get the number of members in a set
|
RedisTransaction |
RedisTransaction.scard(String key,
Handler<AsyncResult<String>> handler)
Get the number of members in a set
|
RedisClient |
RedisClient.scriptExists(String script,
Handler<AsyncResult<JsonArray>> handler)
Check existence of script in the script cache.
|
RedisTransaction |
RedisTransaction.scriptExists(String script,
Handler<AsyncResult<String>> handler)
Check existence of script in the script cache.
|
RedisClient |
RedisClient.scriptExistsMany(List<String> scripts,
Handler<AsyncResult<JsonArray>> handler)
Check existence of scripts in the script cache.
|
RedisTransaction |
RedisTransaction.scriptExistsMany(List<String> scripts,
Handler<AsyncResult<String>> handler)
Check existence of scripts in the script cache.
|
RedisClient |
RedisClient.scriptFlush(Handler<AsyncResult<String>> handler)
Remove all the scripts from the script cache.
|
RedisTransaction |
RedisTransaction.scriptFlush(Handler<AsyncResult<String>> handler)
Remove all the scripts from the script cache.
|
RedisClient |
RedisClient.scriptKill(Handler<AsyncResult<String>> handler)
Kill the script currently in execution.
|
RedisTransaction |
RedisTransaction.scriptKill(Handler<AsyncResult<String>> handler)
Kill the script currently in execution.
|
RedisClient |
RedisClient.scriptLoad(String script,
Handler<AsyncResult<String>> handler)
Load the specified Lua script into the script cache.
|
RedisTransaction |
RedisTransaction.scriptLoad(String script,
Handler<AsyncResult<String>> handler)
Load the specified Lua script into the script cache.
|
RedisClient |
RedisClient.sdiff(String key,
List<String> cmpkeys,
Handler<AsyncResult<JsonArray>> handler)
Subtract multiple sets
|
RedisTransaction |
RedisTransaction.sdiff(String key,
List<String> cmpkeys,
Handler<AsyncResult<String>> handler)
Subtract multiple sets
|
RedisClient |
RedisClient.sdiffstore(String destkey,
String key,
List<String> cmpkeys,
Handler<AsyncResult<Long>> handler)
Subtract multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sdiffstore(String destkey,
String key,
List<String> cmpkeys,
Handler<AsyncResult<String>> handler)
Subtract multiple sets and store the resulting set in a key
|
RedisClient |
RedisClient.select(int dbindex,
Handler<AsyncResult<String>> handler)
Change the selected database for the current connection
|
RedisTransaction |
RedisTransaction.select(int dbindex,
Handler<AsyncResult<String>> handler)
Change the selected database for the current connection
|
RedisTransaction |
RedisTransaction.set(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.set(String key,
String value,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisTransaction |
RedisTransaction.setBinary(String key,
Buffer value,
Handler<AsyncResult<String>> handler)
Set the binary string value of a key - without encoding as utf-8
|
RedisClient |
RedisClient.setBinary(String key,
Buffer value,
Handler<AsyncResult<Void>> handler)
Set the binary string value of a key - without encoding as utf-8
|
RedisTransaction |
RedisTransaction.setBinaryWithOptions(String key,
Buffer value,
SetOptions options,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.setBinaryWithOptions(String key,
Buffer value,
SetOptions options,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.setbit(String key,
long offset,
int bit,
Handler<AsyncResult<Long>> handler)
Sets or clears the bit at offset in the string value stored at key
|
RedisTransaction |
RedisTransaction.setbit(String key,
long offset,
int bit,
Handler<AsyncResult<String>> handler)
Sets or clears the bit at offset in the string value stored at key
|
RedisClient |
RedisClient.setex(String key,
long seconds,
String value,
Handler<AsyncResult<String>> handler)
Set the value and expiration of a key
|
RedisTransaction |
RedisTransaction.setex(String key,
long seconds,
String value,
Handler<AsyncResult<String>> handler)
Set the value and expiration of a key
|
RedisClient |
RedisClient.setnx(String key,
String value,
Handler<AsyncResult<Long>> handler)
Set the value of a key, only if the key does not exist
|
RedisTransaction |
RedisTransaction.setnx(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the value of a key, only if the key does not exist
|
RedisClient |
RedisClient.setrange(String key,
int offset,
String value,
Handler<AsyncResult<Long>> handler)
Overwrite part of a string at key starting at the specified offset
|
RedisTransaction |
RedisTransaction.setrange(String key,
int offset,
String value,
Handler<AsyncResult<String>> handler)
Overwrite part of a string at key starting at the specified offset
|
RedisClient |
RedisClient.setWithOptions(String key,
String value,
SetOptions options,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisTransaction |
RedisTransaction.setWithOptions(String key,
String value,
SetOptions options,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.sinter(List<String> keys,
Handler<AsyncResult<JsonArray>> handler)
Intersect multiple sets
|
RedisTransaction |
RedisTransaction.sinter(List<String> keys,
Handler<AsyncResult<String>> handler)
Intersect multiple sets
|
RedisClient |
RedisClient.sinterstore(String destkey,
List<String> keys,
Handler<AsyncResult<Long>> handler)
Intersect multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sinterstore(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Intersect multiple sets and store the resulting set in a key
|
RedisClient |
RedisClient.sismember(String key,
String member,
Handler<AsyncResult<Long>> handler)
Determine if a given value is a member of a set
|
RedisTransaction |
RedisTransaction.sismember(String key,
String member,
Handler<AsyncResult<String>> handler)
Determine if a given value is a member of a set
|
RedisClient |
RedisClient.slaveof(String host,
int port,
Handler<AsyncResult<String>> handler)
Make the server a slave of another instance
|
RedisTransaction |
RedisTransaction.slaveof(String host,
int port,
Handler<AsyncResult<String>> handler)
Make the server a slave of another instance
|
RedisClient |
RedisClient.slaveofNoone(Handler<AsyncResult<String>> handler)
Make this server a master
|
RedisTransaction |
RedisTransaction.slaveofNoone(Handler<AsyncResult<String>> handler)
Make this server a master
|
RedisClient |
RedisClient.slowlogGet(int limit,
Handler<AsyncResult<JsonArray>> handler)
Read the Redis slow queries log
|
RedisTransaction |
RedisTransaction.slowlogGet(int limit,
Handler<AsyncResult<String>> handler)
Read the Redis slow queries log
|
RedisClient |
RedisClient.slowlogLen(Handler<AsyncResult<Long>> handler)
Get the length of the Redis slow queries log
|
RedisTransaction |
RedisTransaction.slowlogLen(Handler<AsyncResult<String>> handler)
Get the length of the Redis slow queries log
|
RedisTransaction |
RedisTransaction.slowlogReset(Handler<AsyncResult<String>> handler)
Reset the Redis slow queries log
|
RedisClient |
RedisClient.slowlogReset(Handler<AsyncResult<Void>> handler)
Reset the Redis slow queries log
|
RedisClient |
RedisClient.smembers(String key,
Handler<AsyncResult<JsonArray>> handler)
Get all the members in a set
|
RedisTransaction |
RedisTransaction.smembers(String key,
Handler<AsyncResult<String>> handler)
Get all the members in a set
|
RedisClient |
RedisClient.smove(String key,
String destkey,
String member,
Handler<AsyncResult<Long>> handler)
Move a member from one set to another
|
RedisTransaction |
RedisTransaction.smove(String key,
String destkey,
String member,
Handler<AsyncResult<String>> handler)
Move a member from one set to another
|
RedisClient |
RedisClient.sort(String key,
SortOptions options,
Handler<AsyncResult<JsonArray>> handler)
Sort the elements in a list, set or sorted set
|
RedisTransaction |
RedisTransaction.sort(String key,
SortOptions options,
Handler<AsyncResult<String>> handler)
Sort the elements in a list, set or sorted set
|
RedisClient |
RedisClient.spop(String key,
Handler<AsyncResult<String>> handler)
Remove and return a random member from a set
|
RedisTransaction |
RedisTransaction.spop(String key,
Handler<AsyncResult<String>> handler)
Remove and return a random member from a set
|
RedisClient |
RedisClient.spopMany(String key,
int count,
Handler<AsyncResult<JsonArray>> handler)
Remove and return random members from a set
|
RedisTransaction |
RedisTransaction.spopMany(String key,
int count,
Handler<AsyncResult<String>> handler)
Remove and return random members from a set
|
RedisClient |
RedisClient.srandmember(String key,
Handler<AsyncResult<String>> handler)
Get one or multiple random members from a set
|
RedisTransaction |
RedisTransaction.srandmember(String key,
Handler<AsyncResult<String>> handler)
Get one or multiple random members from a set
|
RedisClient |
RedisClient.srandmemberCount(String key,
int count,
Handler<AsyncResult<JsonArray>> handler)
Get one or multiple random members from a set
|
RedisTransaction |
RedisTransaction.srandmemberCount(String key,
int count,
Handler<AsyncResult<String>> handler)
Get one or multiple random members from a set
|
RedisClient |
RedisClient.srem(String key,
String member,
Handler<AsyncResult<Long>> handler)
Remove one member from a set
|
RedisTransaction |
RedisTransaction.srem(String key,
String member,
Handler<AsyncResult<String>> handler)
Remove one member from a set
|
RedisClient |
RedisClient.sremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Remove one or more members from a set
|
RedisTransaction |
RedisTransaction.sremMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Remove one or more members from a set
|
RedisClient |
RedisClient.sscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate Set elements
|
RedisTransaction |
RedisTransaction.sscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate Set elements
|
RedisClient |
RedisClient.strlen(String key,
Handler<AsyncResult<Long>> handler)
Get the length of the value stored in a key
|
RedisTransaction |
RedisTransaction.strlen(String key,
Handler<AsyncResult<String>> handler)
Get the length of the value stored in a key
|
RedisClient |
RedisClient.subscribe(String channel,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to the given channels
|
RedisTransaction |
RedisTransaction.subscribe(String channel,
Handler<AsyncResult<String>> handler)
Listen for messages published to the given channels
|
RedisClient |
RedisClient.subscribeMany(List<String> channels,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to the given channels
|
RedisTransaction |
RedisTransaction.subscribeMany(List<String> channels,
Handler<AsyncResult<String>> handler)
Listen for messages published to the given channels
|
RedisClient |
RedisClient.sunion(List<String> keys,
Handler<AsyncResult<JsonArray>> handler)
Add multiple sets
|
RedisTransaction |
RedisTransaction.sunion(List<String> keys,
Handler<AsyncResult<String>> handler)
Add multiple sets
|
RedisClient |
RedisClient.sunionstore(String destkey,
List<String> keys,
Handler<AsyncResult<Long>> handler)
Add multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sunionstore(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Add multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sync(Handler<AsyncResult<String>> handler)
Internal command used for replication
|
RedisClient |
RedisClient.sync(Handler<AsyncResult<Void>> handler)
Internal command used for replication
|
RedisClient |
RedisClient.time(Handler<AsyncResult<JsonArray>> handler)
Return the current server time
|
RedisTransaction |
RedisTransaction.time(Handler<AsyncResult<String>> handler)
Return the current server time
|
RedisClient |
RedisClient.ttl(String key,
Handler<AsyncResult<Long>> handler)
Get the time to live for a key
|
RedisTransaction |
RedisTransaction.ttl(String key,
Handler<AsyncResult<String>> handler)
Get the time to live for a key
|
RedisClient |
RedisClient.type(String key,
Handler<AsyncResult<String>> handler)
Determine the type stored at key
|
RedisTransaction |
RedisTransaction.type(String key,
Handler<AsyncResult<String>> handler)
Determine the type stored at key
|
RedisTransaction |
RedisTransaction.unsubscribe(List<String> channels,
Handler<AsyncResult<String>> handler)
Stop listening for messages posted to the given channels
|
RedisClient |
RedisClient.unsubscribe(List<String> channels,
Handler<AsyncResult<Void>> handler)
Stop listening for messages posted to the given channels
|
RedisTransaction |
RedisTransaction.unwatch(Handler<AsyncResult<String>> handler)
Forget about all watched keys
|
RedisClient |
RedisClient.wait(long numSlaves,
long timeout,
Handler<AsyncResult<String>> handler)
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
|
RedisTransaction |
RedisTransaction.wait(long numSlaves,
long timeout,
Handler<AsyncResult<String>> handler)
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
|
RedisTransaction |
RedisTransaction.watch(String key,
Handler<AsyncResult<String>> handler)
Watch the given keys to determine execution of the MULTI/EXEC block
|
RedisTransaction |
RedisTransaction.watchMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Watch the given keys to determine execution of the MULTI/EXEC block
|
RedisClient |
RedisClient.zadd(String key,
double score,
String member,
Handler<AsyncResult<Long>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisTransaction |
RedisTransaction.zadd(String key,
double score,
String member,
Handler<AsyncResult<String>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisClient |
RedisClient.zaddMany(String key,
Map<String,Double> members,
Handler<AsyncResult<Long>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisTransaction |
RedisTransaction.zaddMany(String key,
Map<String,Double> members,
Handler<AsyncResult<String>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisClient |
RedisClient.zcard(String key,
Handler<AsyncResult<Long>> handler)
Get the number of members in a sorted set
|
RedisTransaction |
RedisTransaction.zcard(String key,
Handler<AsyncResult<String>> handler)
Get the number of members in a sorted set
|
RedisClient |
RedisClient.zcount(String key,
double min,
double max,
Handler<AsyncResult<Long>> handler)
Count the members in a sorted set with scores within the given values
|
RedisTransaction |
RedisTransaction.zcount(String key,
double min,
double max,
Handler<AsyncResult<String>> handler)
Count the members in a sorted set with scores within the given values
|
RedisClient |
RedisClient.zincrby(String key,
double increment,
String member,
Handler<AsyncResult<String>> handler)
Increment the score of a member in a sorted set
|
RedisTransaction |
RedisTransaction.zincrby(String key,
double increment,
String member,
Handler<AsyncResult<String>> handler)
Increment the score of a member in a sorted set
|
RedisClient |
RedisClient.zinterstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key
|
RedisTransaction |
RedisTransaction.zinterstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key
|
RedisClient |
RedisClient.zinterstoreWeighed(String destkey,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
|
RedisTransaction |
RedisTransaction.zinterstoreWeighed(String destkey,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
|
RedisClient |
RedisClient.zlexcount(String key,
String min,
String max,
Handler<AsyncResult<Long>> handler)
Count the number of members in a sorted set between a given lexicographical range
|
RedisTransaction |
RedisTransaction.zlexcount(String key,
String min,
String max,
Handler<AsyncResult<String>> handler)
Count the number of members in a sorted set between a given lexicographical range
|
RedisClient |
RedisClient.zrange(String key,
long start,
long stop,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by index
|
RedisTransaction |
RedisTransaction.zrange(String key,
long start,
long stop,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by index
|
RedisClient |
RedisClient.zrangebylex(String key,
String min,
String max,
LimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by lexicographical range
|
RedisTransaction |
RedisTransaction.zrangebylex(String key,
String min,
String max,
LimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by lexicographical range
|
RedisClient |
RedisClient.zrangebyscore(String key,
String min,
String max,
RangeLimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by score
|
RedisTransaction |
RedisTransaction.zrangebyscore(String key,
String min,
String max,
RangeLimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by score
|
RedisClient |
RedisClient.zrangeWithOptions(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by index
|
RedisTransaction |
RedisTransaction.zrangeWithOptions(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by index
|
RedisClient |
RedisClient.zrank(String key,
String member,
Handler<AsyncResult<Long>> handler)
Determine the index of a member in a sorted set
|
RedisTransaction |
RedisTransaction.zrank(String key,
String member,
Handler<AsyncResult<String>> handler)
Determine the index of a member in a sorted set
|
RedisClient |
RedisClient.zrem(String key,
String member,
Handler<AsyncResult<Long>> handler)
Remove one member from a sorted set
|
RedisTransaction |
RedisTransaction.zrem(String key,
String member,
Handler<AsyncResult<String>> handler)
Remove one member from a sorted set
|
RedisClient |
RedisClient.zremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Remove one or more members from a sorted set
|
RedisTransaction |
RedisTransaction.zremMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Remove one or more members from a sorted set
|
RedisClient |
RedisClient.zremrangebylex(String key,
String min,
String max,
Handler<AsyncResult<Long>> handler)
Remove all members in a sorted set between the given lexicographical range
|
RedisTransaction |
RedisTransaction.zremrangebylex(String key,
String min,
String max,
Handler<AsyncResult<String>> handler)
Remove all members in a sorted set between the given lexicographical range
|
RedisClient |
RedisClient.zremrangebyrank(String key,
long start,
long stop,
Handler<AsyncResult<Long>> handler)
Remove all members in a sorted set within the given indexes
|
RedisTransaction |
RedisTransaction.zremrangebyrank(String key,
long start,
long stop,
Handler<AsyncResult<String>> handler)
Remove all members in a sorted set within the given indexes
|
RedisClient |
RedisClient.zremrangebyscore(String key,
String min,
String max,
Handler<AsyncResult<Long>> handler)
Remove all members in a sorted set within the given scores
|
RedisTransaction |
RedisTransaction.zremrangebyscore(String key,
String min,
String max,
Handler<AsyncResult<String>> handler)
Remove all members in a sorted set within the given scores
|
RedisClient |
RedisClient.zrevrange(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by index, with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrange(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by index, with scores ordered from high to low
|
RedisClient |
RedisClient.zrevrangebylex(String key,
String max,
String min,
LimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrangebylex(String key,
String max,
String min,
LimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
|
RedisClient |
RedisClient.zrevrangebyscore(String key,
String max,
String min,
RangeLimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by score, with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrangebyscore(String key,
String max,
String min,
RangeLimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by score, with scores ordered from high to low
|
RedisClient |
RedisClient.zrevrank(String key,
String member,
Handler<AsyncResult<Long>> handler)
Determine the index of a member in a sorted set, with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrank(String key,
String member,
Handler<AsyncResult<String>> handler)
Determine the index of a member in a sorted set, with scores ordered from high to low
|
RedisClient |
RedisClient.zscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate sorted sets elements and associated scores
|
RedisTransaction |
RedisTransaction.zscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate sorted sets elements and associated scores
|
RedisClient |
RedisClient.zscore(String key,
String member,
Handler<AsyncResult<String>> handler)
Get the score associated with the given member in a sorted set
|
RedisTransaction |
RedisTransaction.zscore(String key,
String member,
Handler<AsyncResult<String>> handler)
Get the score associated with the given member in a sorted set
|
RedisClient |
RedisClient.zunionstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Add multiple sorted sets and store the resulting sorted set in a new key
|
RedisTransaction |
RedisTransaction.zunionstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Add multiple sorted sets and store the resulting sorted set in a new key
|
RedisClient |
RedisClient.zunionstoreWeighed(String key,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
|
RedisTransaction |
RedisTransaction.zunionstoreWeighed(String key,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
|
Modifier and Type | Method and Description |
---|---|
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Action1<T> onNext)
Adapt an item callback as a
Handler<AsyncResult<T>> . |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Action1<T> onNext,
Action1<Throwable> onError)
Adapt an item callback and an error callback as a
Handler<AsyncResult<T>> . |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Action1<T> onNext,
Action1<Throwable> onError,
Action0 onComplete)
Adapt an item callback and an error callback as a
Handler<AsyncResult<T>> . |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Observer<T> observer)
Adapt a
Subscriber as a Handler<AsyncResult<T>>; . |
Handler<AsyncResult<T>> |
ObservableFuture.toHandler() |
Handler<T> |
ObservableHandler.toHandler() |
static <T> Handler<T> |
RxHelper.toHandler(Action1<T> onNext)
Adapt an item callback as a
Handler<T> . |
static <T> Handler<T> |
RxHelper.toHandler(Observer<T> observer)
Adapt a
Subscriber as a Handler<T>; .
When the event handler completes, the observer
will complete immediatly after the event is received, as a single event is expected. |
static <T> Handler<T> |
RxHelper.toHandler(Observer<T> observer,
boolean multi)
Adapt a
Subscriber as a Handler<T>; .
When parameter is false and the event handler completes, the observer
will complete immediatly after the event is received, as a single event is expected. |
Modifier and Type | Method and Description |
---|---|
void |
AmqpBridge.close(Handler<AsyncResult<Void>> resultHandler)
Shuts the bridge down, closing the underlying connection.
|
void |
AmqpBridge.start(String hostname,
int port,
Handler<AsyncResult<AmqpBridge>> resultHandler)
Starts the bridge, establishing the underlying connection.
|
void |
AmqpBridge.start(String hostname,
int port,
String username,
String password,
Handler<AsyncResult<AmqpBridge>> resultHandler)
Starts the bridge, establishing the underlying connection.
|
Modifier and Type | Method and Description |
---|---|
CircuitBreaker |
CircuitBreaker.closeHandler(Handler<Void> handler)
Sets a invoked when the circuit breaker state switches to close.
|
<T> Future<T> |
CircuitBreaker.execute(Handler<Future<T>> operation)
Same as
CircuitBreaker.executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>) but using the circuit breaker default fallback. |
<T> CircuitBreaker |
CircuitBreaker.executeAndReport(Future<T> resultFuture,
Handler<Future<T>> operation)
Same as
CircuitBreaker.executeAndReportWithFallback(io.vertx.rxjava.core.Future<T>, io.vertx.core.Handler<io.vertx.rxjava.core.Future<T>>, java.util.function.Function<java.lang.Throwable, T>) but using the circuit breaker default
fallback. |
<T> CircuitBreaker |
CircuitBreaker.executeAndReportWithFallback(Future<T> resultFuture,
Handler<Future<T>> operation,
java.util.function.Function<Throwable,T> fallback)
Executes the given operation with the circuit breaker control.
|
<T> Future<T> |
CircuitBreaker.executeWithFallback(Handler<Future<T>> operation,
java.util.function.Function<Throwable,T> fallback)
Executes the given operation with the circuit breaker control.
|
CircuitBreaker |
CircuitBreaker.halfOpenHandler(Handler<Void> handler)
Sets a invoked when the circuit breaker state switches to half-open.
|
CircuitBreaker |
CircuitBreaker.openHandler(Handler<Void> handler)
Sets a invoked when the circuit breaker state switches to open.
|
Modifier and Type | Method and Description |
---|---|
Handler<AsyncResult<T>> |
Future.completer() |
Modifier and Type | Method and Description |
---|---|
void |
Vertx.close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.close() but the completionHandler will be called when the close is complete |
static void |
Vertx.clusteredVertx(VertxOptions options,
Handler<AsyncResult<Vertx>> resultHandler)
Creates a clustered instance using the specified options.
|
<U> Future<U> |
Future.compose(Handler<T> handler,
Future<U> composed)
Compose this future with a provided
next future. |
void |
Vertx.deployVerticle(String name,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(String name,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String) but the completionHandler will be notified when the deployment is complete. |
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
Context |
Context.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called when the context runs an action throwing an uncaught throwable.
When this handler is called,
Vertx.currentContext() will return this context. |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
Vertx |
Vertx.exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context , set on at creation. |
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> Observable<T> |
Context.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)
|
<T> Observable<T> |
Vertx.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)
|
<T> Observable<T> |
WorkerExecutor.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)
|
<T> Observable<T> |
Context.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Observable<T> |
Vertx.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Observable<T> |
WorkerExecutor.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
TimeoutStream |
TimeoutStream.handler(Handler<Long> handler) |
void |
Context.runOnContext(Handler<Void> action)
Run the specified action asynchronously on the same context, some time after the current execution has completed.
|
void |
Vertx.runOnContext(Handler<Void> action)
Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all
preceeding events have been handled.
|
CompositeFuture |
CompositeFuture.setHandler(Handler<AsyncResult<CompositeFuture>> handler) |
Future<T> |
Future.setHandler(Handler<AsyncResult<T>> handler)
Set a handler for the result.
|
long |
Vertx.setPeriodic(long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds, at which point handler will be called with
the id of the timer. |
long |
Vertx.setTimer(long delay,
Handler<Long> handler)
Set a one-shot timer to fire after
delay milliseconds, at which point handler will be called with
the id of the timer. |
void |
Vertx.undeploy(String deploymentID,
Handler<AsyncResult<Void>> completionHandler)
Like
#undeploy(String) but the completionHandler will be notified when the undeployment is complete. |
Modifier and Type | Method and Description |
---|---|
DatagramSocket |
DatagramSocket.blockMulticastGroup(String multicastAddress,
String sourceToBlock,
Handler<AsyncResult<DatagramSocket>> handler)
Block the given address for the given multicast address and notifies the once
the operation completes.
|
DatagramSocket |
DatagramSocket.blockMulticastGroup(String multicastAddress,
String networkInterface,
String sourceToBlock,
Handler<AsyncResult<DatagramSocket>> handler)
Block the given address for the given multicast address on the given network interface and notifies
the once the operation completes.
|
void |
DatagramSocket.close(Handler<AsyncResult<Void>> handler)
Closes the
DatagramSocket implementation asynchronous
and notifies the handler once done. |
PacketWritestream |
PacketWritestream.drainHandler(Handler<Void> handler) |
DatagramSocket |
DatagramSocket.endHandler(Handler<Void> endHandler) |
DatagramSocket |
DatagramSocket.exceptionHandler(Handler<Throwable> handler) |
PacketWritestream |
PacketWritestream.exceptionHandler(Handler<Throwable> handler) |
DatagramSocket |
DatagramSocket.handler(Handler<DatagramPacket> handler) |
DatagramSocket |
DatagramSocket.listen(int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Start listening on the given port and host.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
Handler<AsyncResult<DatagramSocket>> handler)
Joins a multicast group and listens for packets send to it.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<DatagramSocket>> handler)
Joins a multicast group and listens for packets send to it on the given network interface.
|
DatagramSocket |
DatagramSocket.send(Buffer packet,
int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Write the given
Buffer to the SocketAddress . |
DatagramSocket |
DatagramSocket.send(String str,
int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Write the given
String to the SocketAddress using UTF8 encoding. |
DatagramSocket |
DatagramSocket.send(String str,
String enc,
int port,
String host,
Handler<AsyncResult<DatagramSocket>> handler)
Write the given
String to the SocketAddress using the given encoding. |
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
Handler<AsyncResult<DatagramSocket>> handler)
Leaves a multicast group and stops listening for packets send to it.
|
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<DatagramSocket>> handler)
Leaves a multicast group and stops listening for packets send to it on the given network interface.
|
Modifier and Type | Method and Description |
---|---|
DnsClient |
DnsClient.lookup(String name,
Handler<AsyncResult<String>> handler)
Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name.
|
DnsClient |
DnsClient.lookup4(String name,
Handler<AsyncResult<String>> handler)
Try to lookup the A (ipv4) record for the given name.
|
DnsClient |
DnsClient.lookup6(String name,
Handler<AsyncResult<String>> handler)
Try to lookup the AAAA (ipv6) record for the given name.
|
DnsClient |
DnsClient.resolveA(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve all A (ipv4) records for the given name.
|
DnsClient |
DnsClient.resolveAAAA(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve all AAAA (ipv6) records for the given name.
|
DnsClient |
DnsClient.resolveCNAME(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve the CNAME record for the given name.
|
DnsClient |
DnsClient.resolveMX(String name,
Handler<AsyncResult<List<MxRecord>>> handler)
Try to resolve the MX records for the given name.
|
DnsClient |
DnsClient.resolveNS(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve the NS records for the given name.
|
DnsClient |
DnsClient.resolvePTR(String name,
Handler<AsyncResult<String>> handler)
Try to resolve the PTR record for the given name.
|
DnsClient |
DnsClient.resolveSRV(String name,
Handler<AsyncResult<List<SrvRecord>>> handler)
Try to resolve the SRV records for the given name.
|
DnsClient |
DnsClient.resolveTXT(String name,
Handler<AsyncResult<List<String>>> handler)
Try to resolve the TXT records for the given name.
|
DnsClient |
DnsClient.reverseLookup(String ipaddress,
Handler<AsyncResult<String>> handler)
Try to do a reverse lookup of an IP address.
|
Modifier and Type | Method and Description |
---|---|
EventBus |
EventBus.addInterceptor(Handler<SendContext> interceptor)
Add an interceptor that will be called whenever a message is sent from Vert.x
|
void |
MessageConsumer.completionHandler(Handler<AsyncResult<Void>> completionHandler)
Optional method which can be called to indicate when the registration has been propagated across the cluster.
|
<T> MessageConsumer<T> |
EventBus.consumer(String address,
Handler<Message<T>> handler)
Create a consumer and register it against the specified address.
|
MessageProducer<T> |
MessageProducer.drainHandler(Handler<Void> handler) |
MessageConsumer<T> |
MessageConsumer.endHandler(Handler<Void> endHandler) |
MessageConsumer<T> |
MessageConsumer.exceptionHandler(Handler<Throwable> handler) |
MessageProducer<T> |
MessageProducer.exceptionHandler(Handler<Throwable> handler) |
MessageConsumer<T> |
MessageConsumer.handler(Handler<Message<T>> handler) |
<T> MessageConsumer<T> |
EventBus.localConsumer(String address,
Handler<Message<T>> handler)
Like
EventBus.consumer(java.lang.String) but the address won't be propagated across the cluster. |
EventBus |
EventBus.removeInterceptor(Handler<SendContext> interceptor)
Remove an interceptor
|
<R> void |
Message.reply(Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<R>>> replyHandler)
The same as
reply(R message, DeliveryOptions) but you can specify handler for the reply - i.e. |
<R> void |
Message.reply(Object message,
Handler<AsyncResult<Message<R>>> replyHandler)
The same as
reply(R message) but you can specify handler for the reply - i.e. |
<T> EventBus |
EventBus.send(String address,
Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.send(java.lang.String, java.lang.Object) but specifying a replyHandler that will be called if the recipient
subsequently replies to the message. |
<T> EventBus |
EventBus.send(String address,
Object message,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.send(java.lang.String, java.lang.Object) but specifying a replyHandler that will be called if the recipient
subsequently replies to the message. |
<R> MessageProducer<T> |
MessageProducer.send(T message,
Handler<AsyncResult<Message<R>>> replyHandler) |
void |
MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler)
Unregisters the handler which created this registration
|
Modifier and Type | Method and Description |
---|---|
FileSystem |
FileSystem.chmod(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
FileSystem.chmodRecursive(String path,
String perms,
String dirPerms,
Handler<AsyncResult<Void>> handler)
Change the permissions on the file represented by
path to perms , asynchronously. |
FileSystem |
FileSystem.chown(String path,
String user,
String group,
Handler<AsyncResult<Void>> handler)
Change the ownership on the file represented by
path to user and {code group}, asynchronously. |
void |
AsyncFile.close(Handler<AsyncResult<Void>> handler)
Close the file.
|
FileSystem |
FileSystem.copy(String from,
String to,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
FileSystem.copyRecursive(String from,
String to,
boolean recursive,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to , asynchronously. |
FileSystem |
FileSystem.createFile(String path,
Handler<AsyncResult<Void>> handler)
Creates an empty file with the specified
path , asynchronously. |
FileSystem |
FileSystem.createFile(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Creates an empty file with the specified
path and permissions perms , asynchronously. |
FileSystem |
FileSystem.delete(String path,
Handler<AsyncResult<Void>> handler)
Deletes the file represented by the specified
path , asynchronously. |
FileSystem |
FileSystem.deleteRecursive(String path,
boolean recursive,
Handler<AsyncResult<Void>> handler)
Deletes the file represented by the specified
path , asynchronously. |
AsyncFile |
AsyncFile.drainHandler(Handler<Void> handler) |
AsyncFile |
AsyncFile.endHandler(Handler<Void> endHandler) |
AsyncFile |
AsyncFile.exceptionHandler(Handler<Throwable> handler) |
FileSystem |
FileSystem.exists(String path,
Handler<AsyncResult<Boolean>> handler)
Determines whether the file as specified by the path
path exists, asynchronously. |
AsyncFile |
AsyncFile.flush(Handler<AsyncResult<Void>> handler)
Same as
AsyncFile.flush() but the handler will be called when the flush is complete or if an error occurs |
FileSystem |
FileSystem.fsProps(String path,
Handler<AsyncResult<FileSystemProps>> handler)
Returns properties of the file-system being used by the specified
path , asynchronously. |
AsyncFile |
AsyncFile.handler(Handler<Buffer> handler) |
FileSystem |
FileSystem.link(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a hard link on the file system from
link to existing , asynchronously. |
FileSystem |
FileSystem.lprops(String path,
Handler<AsyncResult<FileProps>> handler)
Obtain properties for the link represented by
path , asynchronously. |
FileSystem |
FileSystem.mkdir(String path,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path , asynchronously. |
FileSystem |
FileSystem.mkdir(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path , asynchronously. |
FileSystem |
FileSystem.mkdirs(String path,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
FileSystem.mkdirs(String path,
String perms,
Handler<AsyncResult<Void>> handler)
Create the directory represented by
path and any non existent parents, asynchronously. |
FileSystem |
FileSystem.move(String from,
String to,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to , asynchronously. |
FileSystem |
FileSystem.open(String path,
OpenOptions options,
Handler<AsyncResult<AsyncFile>> handler)
Open the file represented by
path , asynchronously. |
FileSystem |
FileSystem.props(String path,
Handler<AsyncResult<FileProps>> handler)
Obtain properties for the file represented by
path , asynchronously. |
AsyncFile |
AsyncFile.read(Buffer buffer,
int offset,
long position,
int length,
Handler<AsyncResult<Buffer>> handler)
Reads
length bytes of data from the file at position position in the file, asynchronously. |
FileSystem |
FileSystem.readDir(String path,
Handler<AsyncResult<List<String>>> handler)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
FileSystem.readDir(String path,
String filter,
Handler<AsyncResult<List<String>>> handler)
Read the contents of the directory specified by
path , asynchronously. |
FileSystem |
FileSystem.readFile(String path,
Handler<AsyncResult<Buffer>> handler)
Reads the entire file as represented by the path
path as a , asynchronously. |
FileSystem |
FileSystem.readSymlink(String link,
Handler<AsyncResult<String>> handler)
Returns the path representing the file that the symbolic link specified by
link points to, asynchronously. |
FileSystem |
FileSystem.symlink(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a symbolic link on the file system from
link to existing , asynchronously. |
FileSystem |
FileSystem.truncate(String path,
long len,
Handler<AsyncResult<Void>> handler)
Truncate the file represented by
path to length len in bytes, asynchronously. |
FileSystem |
FileSystem.unlink(String link,
Handler<AsyncResult<Void>> handler)
Unlinks the link on the file system represented by the path
link , asynchronously. |
AsyncFile |
AsyncFile.write(Buffer buffer,
long position,
Handler<AsyncResult<Void>> handler)
Write a
Buffer to the file at position position in the file, asynchronously. |
FileSystem |
FileSystem.writeFile(String path,
Buffer data,
Handler<AsyncResult<Void>> handler)
Creates the file, and writes the specified
Buffer data to the file represented by the path path ,
asynchronously. |
Modifier and Type | Method and Description |
---|---|
HttpServerResponse |
HttpServerResponse.bodyEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the last part of the body is written to the wire
and the response is ended.
|
HttpClientResponse |
HttpClientResponse.bodyHandler(Handler<Buffer> bodyHandler)
Convenience method for receiving the entire request body in one piece.
|
HttpServerRequest |
HttpServerRequest.bodyHandler(Handler<Buffer> bodyHandler)
Convenience method for receiving the entire request body in one piece.
|
void |
HttpServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
HttpServer.close() but supplying a handler that will be called when the server is actually closed (or has failed). |
HttpConnection |
HttpConnection.closeHandler(Handler<Void> handler)
Set a close handler.
|
HttpServerResponse |
HttpServerResponse.closeHandler(Handler<Void> handler)
Set a close handler for the response.
|
ServerWebSocket |
ServerWebSocket.closeHandler(Handler<Void> handler) |
WebSocket |
WebSocket.closeHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.closeHandler(Handler<Void> handler)
Set a close handler.
|
HttpClientRequest |
HttpClientRequest.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler called when an HTTP connection has been established.
|
HttpServer |
HttpServer.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the server.
|
HttpClientRequest |
HttpClientRequest.continueHandler(Handler<Void> handler)
If you send an HTTP request with the header
Expect set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100 and a continue handler
has been set using this method, then the handler will be called. |
HttpClientResponse |
HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)
Set an custom frame handler.
|
HttpServerRequest |
HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)
Set a custom frame handler.
|
HttpClientRequest |
HttpClient.delete(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.delete(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.delete(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.deleteAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP DELETE request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClientRequest.drainHandler(Handler<Void> handler) |
HttpServerResponse |
HttpServerResponse.drainHandler(Handler<Void> handler) |
ServerWebSocket |
ServerWebSocket.drainHandler(Handler<Void> handler) |
WebSocket |
WebSocket.drainHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.drainHandler(Handler<Void> handler) |
HttpClientRequest |
HttpClientRequest.endHandler(Handler<Void> endHandler) |
HttpClientResponse |
HttpClientResponse.endHandler(Handler<Void> endHandler) |
HttpServerFileUpload |
HttpServerFileUpload.endHandler(Handler<Void> endHandler) |
HttpServerRequest |
HttpServerRequest.endHandler(Handler<Void> endHandler) |
HttpServerRequestStream |
HttpServerRequestStream.endHandler(Handler<Void> endHandler) |
ServerWebSocket |
ServerWebSocket.endHandler(Handler<Void> endHandler) |
ServerWebSocketStream |
ServerWebSocketStream.endHandler(Handler<Void> endHandler) |
WebSocket |
WebSocket.endHandler(Handler<Void> endHandler) |
WebSocketBase |
WebSocketBase.endHandler(Handler<Void> endHandler) |
WebSocketStream |
WebSocketStream.endHandler(Handler<Void> endHandler) |
HttpClientRequest |
HttpClientRequest.exceptionHandler(Handler<Throwable> handler) |
HttpClientResponse |
HttpClientResponse.exceptionHandler(Handler<Throwable> handler) |
HttpConnection |
HttpConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called when a connection error happens
|
HttpServerFileUpload |
HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequest |
HttpServerRequest.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequestStream |
HttpServerRequestStream.exceptionHandler(Handler<Throwable> handler) |
HttpServerResponse |
HttpServerResponse.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocketStream |
ServerWebSocketStream.exceptionHandler(Handler<Throwable> handler) |
WebSocket |
WebSocket.exceptionHandler(Handler<Throwable> handler) |
WebSocketBase |
WebSocketBase.exceptionHandler(Handler<Throwable> handler) |
WebSocketStream |
WebSocketStream.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.frameHandler(Handler<WebSocketFrame> handler) |
WebSocket |
WebSocket.frameHandler(Handler<WebSocketFrame> handler) |
WebSocketBase |
WebSocketBase.frameHandler(Handler<WebSocketFrame> handler)
Set a frame handler on the connection.
|
HttpClientRequest |
HttpClient.get(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.get(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.get(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.getAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.getNow(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP GET request to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.getNow(String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP GET request to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.getNow(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP GET request to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpConnection |
HttpConnection.goAwayHandler(Handler<GoAway> handler)
Set an handler called when a frame is received.
|
HttpClientResponse |
HttpClientResponse.handler(Handler<Buffer> handler) |
HttpServerFileUpload |
HttpServerFileUpload.handler(Handler<Buffer> handler) |
HttpServerRequest |
HttpServerRequest.handler(Handler<Buffer> handler) |
ServerWebSocket |
ServerWebSocket.handler(Handler<Buffer> handler) |
WebSocket |
WebSocket.handler(Handler<Buffer> handler) |
WebSocketBase |
WebSocketBase.handler(Handler<Buffer> handler) |
HttpClientRequest |
HttpClientRequest.handler(Handler<HttpClientResponse> handler) |
HttpServerRequestStream |
HttpServerRequestStream.handler(Handler<HttpServerRequest> handler) |
ServerWebSocketStream |
ServerWebSocketStream.handler(Handler<ServerWebSocket> handler) |
WebSocketStream |
WebSocketStream.handler(Handler<WebSocket> handler) |
HttpClientRequest |
HttpClient.head(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.head(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.head(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.headAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP HEAD request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpServerResponse |
HttpServerResponse.headersEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the headers are written to the wire.
|
HttpClient |
HttpClient.headNow(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP HEAD request to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.headNow(String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP HEAD request to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.headNow(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP HEAD request to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpServer |
HttpServer.listen(Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen() but supplying a handler that will be called when the server is actually listening (or has failed). |
HttpServer |
HttpServer.listen(int port,
Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen() but supplying a handler that will be called when the server is actually listening (or has failed). |
HttpServer |
HttpServer.listen(int port,
String host,
Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen() but supplying a handler that will be called when the server is actually
listening (or has failed). |
HttpClientRequest |
HttpClient.options(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.options(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.options(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.optionsAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP OPTIONS request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.optionsNow(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP OPTIONS request to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.optionsNow(String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP OPTIONS request to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClient |
HttpClient.optionsNow(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Sends an HTTP OPTIONS request to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpConnection |
HttpConnection.ping(Buffer data,
Handler<AsyncResult<Buffer>> pongHandler)
Send a frame to the remote endpoint.
|
HttpConnection |
HttpConnection.pingHandler(Handler<Buffer> handler)
Set an handler notified when a frame is received from the remote endpoint.
|
HttpClientRequest |
HttpClient.post(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.post(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.post(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.postAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP POST request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Push a response to the client.
The
handler will be notified with a success when the push can be sent and with
a failure when the client has disabled push or reset the push before it has been sent.
The handler may be queued if the client has reduced the maximum number of streams the server can push
concurrently.
Push can be sent only for peer initiated streams and if the response is not ended. |
HttpClientRequest |
HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)
Set a push handler for this request.
The handler is called when the client receives a push promise from the server.
|
HttpClientRequest |
HttpClient.put(int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.put(String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.put(String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.putAbs(String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP PUT request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpConnection |
HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)
Set an handler that is called when remote endpoint
Http2Settings are updated. |
HttpClientRequest |
HttpClient.request(HttpMethod method,
int port,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server at the specified host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.request(HttpMethod method,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server at the default host and port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.request(HttpMethod method,
String host,
String requestURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server at the specified host and default port, specifying a response handler to receive
the response
|
HttpClientRequest |
HttpClient.requestAbs(HttpMethod method,
String absoluteURI,
Handler<HttpClientResponse> responseHandler)
Create an HTTP request to send to the server using an absolute URI, specifying a response handler to receive
the response
|
HttpServer |
HttpServer.requestHandler(Handler<HttpServerRequest> handler)
Set the request handler for the server to
requestHandler . |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String) but providing a handler which will be notified once the file has been
completely written to the wire. |
HttpClientRequest |
HttpClientRequest.sendHead(Handler<HttpVersion> completionHandler)
Like
HttpClientRequest.sendHead() but with an handler after headers have been sent. |
HttpConnection |
HttpConnection.shutdownHandler(Handler<Void> handler)
Set an handler called when a frame has been sent or received and all connections are closed.
|
HttpConnection |
HttpConnection.updateSettings(Http2Settings settings,
Handler<AsyncResult<Void>> completionHandler)
Send to the remote endpoint an update of this endpoint settings
The
completionHandler will be notified when the remote endpoint has acknowledged the settings. |
HttpServerRequest |
HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)
Set an upload handler.
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, and with the specified headers
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(int port,
String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified port, host and relative request URI, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(String requestURI,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port
|
HttpClient |
HttpClient.websocket(String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port
|
HttpClient |
HttpClient.websocket(String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port and the specified headers
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers and the
specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
|
HttpClient |
HttpClient.websocket(String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket at the relative request URI using the default host and port, the specified headers, the
specified version of WebSockets and the specified sub protocols
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the host and relative request URI and default port
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the host and relative request URI and default port
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the host and relative request URI and default port
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host,relative request UR, and default port and with the specified headers
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port with the specified headers and using
the specified version of WebSockets
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect)
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpClient |
HttpClient.websocket(String host,
String requestURI,
MultiMap headers,
WebsocketVersion version,
String subProtocols,
Handler<WebSocket> wsConnect,
Handler<Throwable> failureHandler)
Connect a WebSocket to the specified host, relative request URI and default port, with the specified headers, using
the specified version of WebSockets, and the specified websocket sub protocols
|
HttpServer |
HttpServer.websocketHandler(Handler<ServerWebSocket> handler)
Set the websocket handler for the server to
wsHandler . |
Modifier and Type | Method and Description |
---|---|
void |
NetServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
NetServer.close() but supplying a handler that will be notified when close is complete. |
NetSocket |
NetSocket.closeHandler(Handler<Void> handler)
Set a handler that will be called when the NetSocket is closed
|
NetClient |
NetClient.connect(int port,
String host,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
port and host . |
NetServer |
NetServer.connectHandler(Handler<NetSocket> handler)
Supply a connect handler for this server.
|
NetSocket |
NetSocket.drainHandler(Handler<Void> handler) |
NetSocket |
NetSocket.endHandler(Handler<Void> endHandler) |
NetSocketStream |
NetSocketStream.endHandler(Handler<Void> endHandler) |
NetSocket |
NetSocket.exceptionHandler(Handler<Throwable> handler) |
NetSocketStream |
NetSocketStream.exceptionHandler(Handler<Throwable> handler) |
NetSocket |
NetSocket.handler(Handler<Buffer> handler) |
NetSocketStream |
NetSocketStream.handler(Handler<NetSocket> handler) |
NetServer |
NetServer.listen(Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen() but providing a handler that will be notified when the server is listening, or fails. |
NetServer |
NetServer.listen(int port,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen() but providing a handler that will be notified when the server is listening, or fails. |
NetServer |
NetServer.listen(int port,
String host,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen() but providing a handler that will be notified when the server is listening, or fails. |
NetSocket |
NetSocket.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.upgradeToSsl(Handler<Void> handler)
Upgrade channel to use SSL/TLS.
|
Modifier and Type | Class and Description |
---|---|
class |
RecordParser
A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed
size records.
|
Modifier and Type | Method and Description |
---|---|
static RecordParser |
RecordParser.newDelimited(Buffer delim,
Handler<Buffer> output)
Create a new
RecordParser instance, initially in delimited mode, and where the delimiter can be represented
by the Buffer delim. |
static RecordParser |
RecordParser.newDelimited(String delim,
Handler<Buffer> output)
Create a new
RecordParser instance, initially in delimited mode, and where the delimiter can be represented
by the String delim endcoded in latin-1 . |
static RecordParser |
RecordParser.newFixed(int size,
Handler<Buffer> output)
Create a new
RecordParser instance, initially in fixed size mode, and where the record size is specified
by the size parameter. |
void |
RecordParser.setOutput(Handler<Buffer> output) |
Modifier and Type | Method and Description |
---|---|
void |
Counter.addAndGet(long value,
Handler<AsyncResult<Long>> resultHandler)
Add the value to the counter atomically and return the new count
|
void |
AsyncMap.clear(Handler<AsyncResult<Void>> resultHandler)
Clear all entries in the map
|
void |
Counter.compareAndSet(long expected,
long value,
Handler<AsyncResult<Boolean>> resultHandler)
Set the counter to the specified value only if the current value is the expectec value.
|
void |
Counter.decrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Decrement the counter atomically and return the new count
|
void |
Counter.get(Handler<AsyncResult<Long>> resultHandler)
Get the current value of the counter
|
void |
AsyncMap.get(K k,
Handler<AsyncResult<V>> resultHandler)
Get a value from the map, asynchronously.
|
void |
Counter.getAndAdd(long value,
Handler<AsyncResult<Long>> resultHandler)
Add the value to the counter atomically and return the value before the add
|
void |
Counter.getAndIncrement(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the value before the increment.
|
<K,V> void |
SharedData.getClusterWideMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the cluster wide map with the specified name.
|
void |
SharedData.getCounter(String name,
Handler<AsyncResult<Counter>> resultHandler)
Get a cluster wide counter.
|
void |
SharedData.getLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get a cluster wide lock with the specified name.
|
void |
SharedData.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
Like
SharedData.getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. |
void |
Counter.incrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the new count
|
void |
AsyncMap.put(K k,
V v,
Handler<AsyncResult<Void>> completionHandler)
Put a value in the map, asynchronously.
|
void |
AsyncMap.put(K k,
V v,
long ttl,
Handler<AsyncResult<Void>> completionHandler)
Like
AsyncMap.put(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but specifying a timeout. |
void |
AsyncMap.putIfAbsent(K k,
V v,
Handler<AsyncResult<V>> completionHandler)
Put the entry only if there is no entry with the key already present.
|
void |
AsyncMap.putIfAbsent(K k,
V v,
long ttl,
Handler<AsyncResult<V>> completionHandler)
Link
AsyncMap.putIfAbsent(K, V, io.vertx.core.Handler<io.vertx.core.AsyncResult<V>>) but specifying a timeout. |
void |
AsyncMap.remove(K k,
Handler<AsyncResult<V>> resultHandler)
Remove a value from the map, asynchronously.
|
void |
AsyncMap.removeIfPresent(K k,
V v,
Handler<AsyncResult<Boolean>> resultHandler)
Remove a value from the map, only if entry already exists with same value.
|
void |
AsyncMap.replace(K k,
V v,
Handler<AsyncResult<V>> resultHandler)
Replace the entry only if it is currently mapped to some value
|
void |
AsyncMap.replaceIfPresent(K k,
V oldValue,
V newValue,
Handler<AsyncResult<Boolean>> resultHandler)
Replace the entry only if it is currently mapped to a specific value
|
void |
AsyncMap.size(Handler<AsyncResult<Integer>> resultHandler)
Provide the number of entries in the map
|
Modifier and Type | Method and Description |
---|---|
WriteStream<T> |
WriteStream.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
ReadStream<T> |
ReadStream.endHandler(Handler<Void> endHandler)
Set an end handler.
|
ReadStream<T> |
ReadStream.exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the read stream.
|
StreamBase |
StreamBase.exceptionHandler(Handler<Throwable> handler)
Set an exception handler.
|
WriteStream<T> |
WriteStream.exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the write stream.
|
ReadStream<T> |
ReadStream.handler(Handler<T> handler)
Set a data handler.
|
Modifier and Type | Method and Description |
---|---|
void |
AsyncSQLClient.close(Handler<AsyncResult<Void>> whenDone)
Close the client and release all resources.
|
void |
AsyncSQLClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
Modifier and Type | Method and Description |
---|---|
void |
AuthProvider.authenticate(JsonObject authInfo,
Handler<AsyncResult<User>> resultHandler)
Authenticate a user.
|
User |
User.isAuthorised(String authority,
Handler<AsyncResult<Boolean>> resultHandler)
Is the user authorised to
|
Modifier and Type | Method and Description |
---|---|
void |
MongoAuth.insertUser(String username,
String password,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Insert a new user into mongo in the convenient way
|
Modifier and Type | Method and Description |
---|---|
OAuth2Auth |
OAuth2Auth.api(HttpMethod method,
String path,
JsonObject params,
Handler<AsyncResult<JsonObject>> handler)
Call OAuth2 APIs.
|
void |
OAuth2Auth.getToken(JsonObject params,
Handler<AsyncResult<AccessToken>> handler)
Returns the Access Token object.
|
AccessToken |
AccessToken.logout(Handler<AsyncResult<Void>> callback)
Revoke refresh token and calls the logout endpoint.
|
AccessToken |
AccessToken.refresh(Handler<AsyncResult<Void>> callback)
Refresh the access token
|
AccessToken |
AccessToken.revoke(String token_type,
Handler<AsyncResult<Void>> callback)
Revoke access or refresh token
|
Modifier and Type | Method and Description |
---|---|
JDBCClient |
JDBCClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
Modifier and Type | Method and Description |
---|---|
MailClient |
MailClient.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler)
send a single mail via MailClient
|
MailService |
MailService.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler) |
Modifier and Type | Method and Description |
---|---|
MongoClient |
MongoClient.count(String collection,
JsonObject query,
Handler<AsyncResult<Long>> resultHandler)
Count matching documents in a collection.
|
MongoClient |
MongoClient.createCollection(String collectionName,
Handler<AsyncResult<Void>> resultHandler)
Create a new collection
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinctBatch(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonObject>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.dropCollection(String collection,
Handler<AsyncResult<Void>> resultHandler)
Drop a collection
|
MongoClient |
MongoClient.find(String collection,
JsonObject query,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection
|
MongoClient |
MongoClient.findBatch(String collection,
JsonObject query,
Handler<AsyncResult<JsonObject>> resultHandler)
Find matching documents in the specified collection.
|
MongoClient |
MongoClient.findBatchWithOptions(String collection,
JsonObject query,
FindOptions options,
Handler<AsyncResult<JsonObject>> resultHandler)
Find matching documents in the specified collection, specifying options.
|
MongoClient |
MongoClient.findOne(String collection,
JsonObject query,
JsonObject fields,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection
|
MongoClient |
MongoClient.findWithOptions(String collection,
JsonObject query,
FindOptions options,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection, specifying options
|
MongoClient |
MongoClient.getCollections(Handler<AsyncResult<List<String>>> resultHandler)
Get a list of all collections in the database.
|
MongoClient |
MongoClient.insert(String collection,
JsonObject document,
Handler<AsyncResult<String>> resultHandler)
Insert a document in the specified collection
|
MongoClient |
MongoClient.insertWithOptions(String collection,
JsonObject document,
WriteOption writeOption,
Handler<AsyncResult<String>> resultHandler)
Insert a document in the specified collection with the specified write option
|
MongoClient |
MongoClient.remove(String collection,
JsonObject query,
Handler<AsyncResult<Void>> resultHandler)
Remove matching documents from a collection
|
MongoClient |
MongoClient.removeDocument(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeDocuments(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeDocumentsWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection with the specified write option and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeDocumentWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection with the specified write option and return the handler with MongoClientDeleteResult result
|
MongoClient |
MongoClient.removeOne(String collection,
JsonObject query,
Handler<AsyncResult<Void>> resultHandler)
Remove a single matching document from a collection
|
MongoClient |
MongoClient.removeOneWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<Void>> resultHandler)
Remove a single matching document from a collection with the specified write option
|
MongoClient |
MongoClient.removeWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<Void>> resultHandler)
Remove matching documents from a collection with the specified write option
|
MongoClient |
MongoClient.replace(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<Void>> resultHandler)
Replace matching documents in the specified collection
|
MongoClient |
MongoClient.replaceDocuments(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.replaceDocumentsWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.replaceWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<Void>> resultHandler)
Replace matching documents in the specified collection, specifying options
|
MongoClient |
MongoClient.runCommand(String commandName,
JsonObject command,
Handler<AsyncResult<JsonObject>> resultHandler)
Run an arbitrary MongoDB command.
|
MongoClient |
MongoClient.save(String collection,
JsonObject document,
Handler<AsyncResult<String>> resultHandler)
Save a document in the specified collection
|
MongoClient |
MongoClient.saveWithOptions(String collection,
JsonObject document,
WriteOption writeOption,
Handler<AsyncResult<String>> resultHandler)
Save a document in the specified collection with the specified write option
|
MongoClient |
MongoClient.update(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<Void>> resultHandler)
Update matching documents in the specified collection
|
MongoClient |
MongoClient.updateCollection(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection, specifying options and return the handler with MongoClientUpdateResult result
|
MongoClient |
MongoClient.updateWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<Void>> resultHandler)
Update matching documents in the specified collection, specifying options
|
Modifier and Type | Method and Description |
---|---|
void |
ShellServer.close(Handler<AsyncResult<Void>> completionHandler)
Close the shell server, this is an asynchronous close.
|
ShellServer |
ShellServer.listen(Handler<AsyncResult<Void>> listenHandler)
Start the shell service, this is an asynchronous start.
|
void |
ShellService.start(Handler<AsyncResult<Void>> startHandler)
Start the shell service, this is an asynchronous start.
|
void |
ShellService.stop(Handler<AsyncResult<Void>> stopHandler)
Stop the shell service, this is an asynchronous start.
|
Modifier and Type | Method and Description |
---|---|
CommandProcess |
CommandProcess.backgroundHandler(Handler<Void> handler)
Set a background handler, this handler is called when the command is running and put to background.
|
CommandBuilder |
CommandBuilder.completionHandler(Handler<Completion> handler)
Set the command completion handler, the completion handler when the user asks for contextual command line
completion, usually hitting the tab key.
|
CommandProcess |
CommandProcess.endHandler(Handler<Void> handler)
Set an end handler, this handler is called when the command is ended, for instance the command is running
and the shell closes.
|
CommandProcess |
CommandProcess.foregroundHandler(Handler<Void> handler)
Set a foreground handler, this handler is called when the command is running and put to foreground.
|
CommandProcess |
CommandProcess.interruptHandler(Handler<Void> handler)
Set an interrupt handler, this handler is called when the command is interrupted, for instance user
press
Ctrl-C . |
CommandBuilder |
CommandBuilder.processHandler(Handler<CommandProcess> handler)
Set the command process handler, the process handler is called when the command is executed.
|
CommandRegistry |
CommandRegistry.registerCommand(Command command,
Handler<AsyncResult<Command>> completionHandler)
Register a command
|
CommandRegistry |
CommandRegistry.registerCommands(List<Command> commands,
Handler<AsyncResult<List<Command>>> completionHandler)
Register a list of commands.
|
CommandProcess |
CommandProcess.resizehandler(Handler<Void> handler) |
CommandProcess |
CommandProcess.resumeHandler(Handler<Void> handler)
Set a resume handler, this handler is called when the command is resumed, for instance user
types
bg or fg to resume the command. |
CommandProcess |
CommandProcess.stdinHandler(Handler<String> handler) |
CommandProcess |
CommandProcess.suspendHandler(Handler<Void> handler)
Set a suspend handler, this handler is called when the command is suspended, for instance user
press
Ctrl-Z . |
CommandRegistry |
CommandRegistry.unregisterCommand(String commandName,
Handler<AsyncResult<Void>> completionHandler)
Unregister a command.
|
Modifier and Type | Method and Description |
---|---|
void |
JobController.close(Handler<Void> completionHandler)
Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
|
boolean |
Process.interrupt(Handler<Void> completionHandler)
Attempt to interrupt the process.
|
void |
Process.resume(boolean foreground,
Handler<Void> completionHandler)
Suspend the process.
|
void |
Process.resume(Handler<Void> completionHandler)
Suspend the process.
|
void |
Process.run(boolean foregraound,
Handler<Void> completionHandler)
Run the process.
|
void |
Process.run(Handler<Void> completionHandler)
Run the process.
|
Job |
Job.statusUpdateHandler(Handler<ExecStatus> handler)
Set an handler called when the job terminates.
|
void |
Process.suspend(Handler<Void> completionHandler)
Resume the process.
|
void |
Process.terminate(Handler<Void> completionHandler)
Terminate the process.
|
Process |
Process.terminatedHandler(Handler<Integer> handler)
Set an handler for being notified when the process terminates.
|
void |
Process.toBackground(Handler<Void> completionHandler)
Set the process in background.
|
void |
Process.toForeground(Handler<Void> completionHandler)
Set the process in foreground.
|
Modifier and Type | Class and Description |
---|---|
class |
SockJSTermHandler |
Modifier and Type | Method and Description |
---|---|
void |
TermServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
TermServer.close() but supplying a handler that will be notified when close is complete. |
Term |
Term.closeHandler(Handler<Void> handler)
Set a handler that will be called when the terminal is closed.
|
TermServer |
TermServer.listen(Handler<AsyncResult<TermServer>> listenHandler)
Bind the term server, the
TermServer.termHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.shell.term.Term>) must be set before. |
void |
Term.readline(String prompt,
Handler<String> lineHandler)
Prompt the user a line of text.
|
void |
Term.readline(String prompt,
Handler<String> lineHandler,
Handler<Completion> completionHandler)
Prompt the user a line of text, providing a completion handler to handle user's completion.
|
void |
Term.readline(String prompt,
Handler<String> lineHandler,
Handler<Completion> completionHandler)
Prompt the user a line of text, providing a completion handler to handle user's completion.
|
Term |
Term.resizehandler(Handler<Void> handler) |
Tty |
Tty.resizehandler(Handler<Void> handler)
Set a resize handler, the handler is called when the tty size changes.
|
Term |
Term.stdinHandler(Handler<String> handler) |
Tty |
Tty.stdinHandler(Handler<String> handler)
Set a stream handler on the standard input to read the data.
|
Pty |
Pty.stdoutHandler(Handler<String> handler)
Set the standard out handler of the pseudo terminal.
|
SockJSTermHandler |
SockJSTermHandler.termHandler(Handler<Term> handler) |
TermServer |
TermServer.termHandler(Handler<Term> handler)
Set the term handler that will receive incoming client connections.
|
Modifier and Type | Method and Description |
---|---|
SQLConnection |
SQLConnection.batch(List<String> sqlStatements,
Handler<AsyncResult<List<Integer>>> handler)
Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
|
SQLConnection |
SQLConnection.batchCallableWithParams(String sqlStatement,
List<JsonArray> inArgs,
List<JsonArray> outArgs,
Handler<AsyncResult<List<Integer>>> handler)
Batch a callable statement with all entries from the args list.
|
SQLConnection |
SQLConnection.batchWithParams(String sqlStatement,
List<JsonArray> args,
Handler<AsyncResult<List<Integer>>> handler)
Batch a prepared statement with all entries from the args list.
|
SQLConnection |
SQLConnection.call(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLConnection |
SQLConnection.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
void |
SQLConnection.close(Handler<AsyncResult<Void>> handler)
Closes the connection.
|
SQLConnection |
SQLConnection.commit(Handler<AsyncResult<Void>> handler)
Commits all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.execute(String sql,
Handler<AsyncResult<Void>> resultHandler)
Executes the given SQL statement
|
SQLConnection |
SQLConnection.getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)
Attempts to return the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
SQLConnection |
SQLConnection.queryWithParams(String sql,
JsonArray params,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT prepared statement which returns the results of the query. |
SQLConnection |
SQLConnection.rollback(Handler<AsyncResult<Void>> handler)
Rolls back all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.setAutoCommit(boolean autoCommit,
Handler<AsyncResult<Void>> resultHandler)
Sets the auto commit flag for this connection.
|
SQLConnection |
SQLConnection.setTransactionIsolation(TransactionIsolation isolation,
Handler<AsyncResult<Void>> handler)
Attempts to change the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.update(String sql,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given SQL statement which may be an
INSERT , UPDATE , or DELETE
statement. |
SQLConnection |
SQLConnection.updateWithParams(String sql,
JsonArray params,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given prepared statement which may be an
INSERT , UPDATE , or DELETE
statement with the given parameters |
Modifier and Type | Class and Description |
---|---|
class |
StompServerHandler
STOMP server handler implements the behavior of the STOMP server when a specific event occurs.
|
Modifier and Type | Method and Description |
---|---|
Handler<ServerWebSocket> |
StompServer.webSocketHandler()
Gets the able to manage web socket connections.
|
Modifier and Type | Method and Description |
---|---|
StompClientConnection |
StompClientConnection.abort(String id,
Handler<Frame> receiptHandler)
Aborts a transaction.
|
StompClientConnection |
StompClientConnection.abort(String id,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Aborts a transaction.
|
StompServerHandler |
StompServerHandler.abortHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
ABORT frame is received. |
StompClientConnection |
StompClientConnection.ack(String id,
Handler<Frame> receiptHandler)
Sends an acknowledgement for a specific message.
|
StompClientConnection |
StompClientConnection.ack(String id,
String txId,
Handler<Frame> receiptHandler)
Sends an acknowledgement for the given frame.
|
StompServerHandler |
StompServerHandler.ackHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
ACK frame is received. |
StompServerHandler |
StompServerHandler.beginHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
BEGIN frame is received. |
StompClientConnection |
StompClientConnection.beginTX(String id,
Handler<Frame> receiptHandler)
Begins a transaction.
|
StompClientConnection |
StompClientConnection.beginTX(String id,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Begins a transaction.
|
void |
StompServer.close(Handler<AsyncResult<Void>> completionHandler)
Closes the server.
|
StompClientConnection |
StompClientConnection.closeHandler(Handler<StompClientConnection> handler)
Sets a handler notified when the STOMP connection is closed.
|
StompServerHandler |
StompServerHandler.closeHandler(Handler<StompServerConnection> handler)
Configures the action to execute when a connection with the client is closed.
|
StompClientConnection |
StompClientConnection.commit(String id,
Handler<Frame> receiptHandler)
Commits a transaction.
|
StompClientConnection |
StompClientConnection.commit(String id,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Commits a transaction.
|
StompServerHandler |
StompServerHandler.commitHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
COMMIT frame is received. |
void |
StompServerConnection.configureHeartbeat(long ping,
long pong,
Handler<StompServerConnection> pingHandler)
Configures the heartbeat.
|
StompClient |
StompClient.connect(Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server using the host and port configured in the client's options.
|
StompClient |
StompClient.connect(int port,
String host,
Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server.
|
StompClient |
StompClient.connect(int port,
String host,
NetClient net,
Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server.
|
StompClient |
StompClient.connect(NetClient net,
Handler<AsyncResult<StompClientConnection>> resultHandler)
Connects to the server.
|
StompServerHandler |
StompServerHandler.connectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
CONNECT frame is received. |
StompClientConnection |
StompClientConnection.connectionDroppedHandler(Handler<StompClientConnection> handler)
Sets a handler notified when the server does not respond to a
ping request in time. |
StompClientConnection |
StompClientConnection.disconnect(Frame frame,
Handler<Frame> receiptHandler)
Disconnects the client.
|
StompClientConnection |
StompClientConnection.disconnect(Handler<Frame> receiptHandler)
Disconnects the client.
|
StompServerHandler |
StompServerHandler.disconnectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
DISCONNECT frame is received. |
StompClient |
StompClient.errorFrameHandler(Handler<Frame> handler)
A general error frame handler.
|
StompClientConnection |
StompClientConnection.errorHandler(Handler<Frame> handler)
Sets a handler notified when an
ERROR frame is received by the client. |
StompServer |
StompServer.listen(Handler<AsyncResult<StompServer>> handler)
Connects the STOMP server default port (61613) and network interface (
0.0.0.0 ). |
StompServer |
StompServer.listen(int port,
Handler<AsyncResult<StompServer>> handler)
Connects the STOMP server to the given port.
|
StompServer |
StompServer.listen(int port,
String host,
Handler<AsyncResult<StompServer>> handler)
Connects the STOMP server to the given port / interface.
|
StompClientConnection |
StompClientConnection.nack(String id,
Handler<Frame> receiptHandler)
Sends a non-acknowledgement for the given message.
|
StompClientConnection |
StompClientConnection.nack(String id,
String txId,
Handler<Frame> receiptHandler)
Sends a non-acknowledgement for the given frame.
|
StompServerHandler |
StompServerHandler.nackHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
NACK frame is received. |
StompServerHandler |
StompServerHandler.onAckHandler(Handler<Acknowledgement> handler)
Configures the action to execute when messages are acknowledged.
|
StompServerHandler |
StompServerHandler.onAuthenticationRequest(StompServer server,
String login,
String passcode,
Handler<AsyncResult<Boolean>> handler)
Called when the client connects to a server requiring authentication.
|
StompServerHandler |
StompServerHandler.onNackHandler(Handler<Acknowledgement> handler)
Configures the action to execute when messages are not acknowledged.
|
StompClientConnection |
StompClientConnection.pingHandler(Handler<StompClientConnection> handler)
Sets a handler that let customize the behavior when a ping needs to be sent to the server.
|
StompServerHandler |
StompServerHandler.pingHandler(Handler<StompServerConnection> handler)
Allows customizing the action to do when the server needs to send a `PING` to the client.
|
StompClient |
StompClient.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that gets notified when a STOMP frame is received by the client.
|
StompClientConnection |
StompClientConnection.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that get notified when a STOMP frame is received by the client.
|
StompServerHandler |
StompServerHandler.receivedFrameHandler(Handler<ServerFrame> handler)
Configures a handler that get notified when a STOMP frame is received by the server.
|
StompClientConnection |
StompClientConnection.send(Frame frame,
Handler<Frame> receiptHandler)
Sends the given frame to the server.
|
StompClientConnection |
StompClientConnection.send(Map<String,String> headers,
Buffer body,
Handler<Frame> receiptHandler)
Sends a
SEND frame to the server. |
StompClientConnection |
StompClientConnection.send(String destination,
Buffer body,
Handler<Frame> receiptHandler)
Sends a
SEND frame to the server to the given destination. |
StompClientConnection |
StompClientConnection.send(String destination,
Map<String,String> headers,
Buffer body,
Handler<Frame> receiptHandler)
Sends a
SEND frame to the server to the given destination. |
StompServerHandler |
StompServerHandler.sendHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
SEND frame is received. |
StompServerHandler |
StompServerHandler.stompHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
STOMP frame is received. |
String |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
String |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<Frame> receiptHandler)
Subscribes to the given destination.
|
StompServerHandler |
StompServerHandler.subscribeHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
SUBSCRIBE frame is received. |
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Handler<Frame> receiptHandler)
Un-subscribes from the given destination.
|
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Map<String,String> headers,
Handler<Frame> receiptHandler)
Un-subscribes from the given destination.
|
StompServerHandler |
StompServerHandler.unsubscribeHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
UNSUBSCRIBE frame is received. |
StompClient |
StompClient.writingFrameHandler(Handler<Frame> handler)
Configures a writing handler that gets notified when a STOMP frame is written on the wire.
|
StompClientConnection |
StompClientConnection.writingFrameHandler(Handler<Frame> handler)
Configures a handler notified when a frame is going to be written on the wire.
|
StompServer |
StompServer.writingFrameHandler(Handler<ServerFrame> handler)
Configures the handler that is invoked every time a frame is going to be written to the "wire".
|
Modifier and Type | Method and Description |
---|---|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it completes the async operation.
When the returned handler is called back with a failed result it fails the test with the cause of the failure.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
Handler<Throwable> |
TestContext.exceptionHandler() |
Modifier and Type | Method and Description |
---|---|
TestSuite |
TestSuite.after(Handler<TestContext> callback)
Set a callback executed after the tests.
|
TestSuite |
TestSuite.afterEach(Handler<TestContext> callback)
Set a callback executed after each test and before the suite
after callback. |
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
TestSuite |
TestSuite.before(Handler<TestContext> callback)
Set a callback executed before the tests.
|
TestSuite |
TestSuite.beforeEach(Handler<TestContext> callback)
Set a callback executed before each test and after the suite
before callback. |
static TestCase |
TestCase.create(String name,
Handler<TestContext> testCase)
Create a test case.
|
void |
Completion.handler(Handler<AsyncResult<T>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
TestSuite |
TestSuite.test(String name,
Handler<TestContext> testCase)
Add a new test case to the suite.
|
TestSuite |
TestSuite.test(String name,
int repeat,
Handler<TestContext> testCase)
Add a new test case to the suite.
|
Modifier and Type | Method and Description |
---|---|
static EventBusCollector |
EventBusCollector.create(Vertx vertx,
Handler<TestSuiteReport> reporter) |
Modifier and Type | Method and Description |
---|---|
TestCaseReport |
TestCaseReport.endHandler(Handler<TestResult> handler)
Set a callback for completion, the specified
handler is invoked when the test exec has completed. |
TestSuiteReport |
TestSuiteReport.endHandler(Handler<Void> endHandler) |
TestSuiteReport |
TestSuiteReport.exceptionHandler(Handler<Throwable> handler)
Set an exception handler, the exception handler reports the test suite errors, it can be called mulitple
times before the test ends.
|
TestSuiteReport |
TestSuiteReport.handler(Handler<TestCaseReport> handler) |
Modifier and Type | Method and Description |
---|---|
int |
RoutingContext.addBodyEndHandler(Handler<Void> handler)
Add a handler that will be called just before the response body has been completely written.
|
int |
RoutingContext.addHeadersEndHandler(Handler<Void> handler)
Add a handler that will be called just before headers are written to the response.
|
Route |
Route.blockingHandler(Handler<RoutingContext> requestHandler)
Like
Route.blockingHandler(io.vertx.core.Handler<io.vertx.rxjava.ext.web.RoutingContext>) called with ordered = true |
Route |
Route.blockingHandler(Handler<RoutingContext> requestHandler,
boolean ordered)
Specify a blocking request handler for the route.
|
Router |
Router.exceptionHandler(Handler<Throwable> exceptionHandler)
Specify a handler for any unhandled exceptions on this router.
|
Route |
Route.failureHandler(Handler<RoutingContext> failureHandler)
Specify a failure handler for the route.
|
Route |
Route.handler(Handler<RoutingContext> requestHandler)
Specify a request handler for the route.
|
Modifier and Type | Class and Description |
---|---|
class |
BasicAuthHandler
An auth handler that provides HTTP Basic Authentication support.
|
class |
BodyHandler
A handler which gathers the entire request body and sets it on the .
|
class |
CookieHandler
A handler which decodes cookies from the request, makes them available in the
and writes them back in the response.
|
class |
CorsHandler
A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
|
class |
CSRFHandler
This handler adds a CSRF token to requests which mutate state.
|
class |
ErrorHandler
A pretty error handler for rendering error pages.
|
class |
FaviconHandler
A handler that serves favicons.
|
class |
FormLoginHandler
Handler that handles login from a form on a custom login page.
|
class |
JWTAuthHandler
An auth handler that provides JWT Authentication support.
|
class |
LoggerHandler
A handler which logs request information to the Vert.x logger.
|
class |
OAuth2AuthHandler
An auth handler that provides OAuth2 Authentication support.
|
class |
RedirectAuthHandler
An auth handler that's used to handle auth by redirecting user to a custom login page.
|
class |
ResponseTimeHandler
Handler which adds a header `x-response-time` in the response of matching requests containing the time taken
in ms to process the request.
|
class |
SessionHandler
A handler that maintains a
Session for each browser session. |
class |
StaticHandler
A handler for serving static resources from the file system or classpath.
|
class |
TemplateHandler
A handler which renders responses using a template engine and where the template name is selected from the URI
path.
|
class |
TimeoutHandler
Handler that will timeout requests if the response has not been written after a certain time.
|
class |
UserSessionHandler
This handler should be used if you want to store the User object in the Session so it's available between
different requests, without you having re-authenticate each time.
|
class |
VirtualHostHandler
Handler that will filter requests based on the request Host name.
|
Modifier and Type | Method and Description |
---|---|
static VirtualHostHandler |
VirtualHostHandler.create(String hostname,
Handler<RoutingContext> handler)
Create a handler
|
Modifier and Type | Class and Description |
---|---|
class |
SockJSHandler
A handler that allows you to handle SockJS connections from clients.
|
Modifier and Type | Method and Description |
---|---|
SockJSHandler |
SockJSHandler.bridge(BridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.BridgeOptions) but specifying a handler
that will receive bridge events. |
SockJSSocket |
SockJSSocket.drainHandler(Handler<Void> handler) |
SockJSSocket |
SockJSSocket.endHandler(Handler<Void> endHandler) |
SockJSSocket |
SockJSSocket.exceptionHandler(Handler<Throwable> handler) |
SockJSSocket |
SockJSSocket.handler(Handler<Buffer> handler) |
SockJSHandler |
SockJSHandler.socketHandler(Handler<SockJSSocket> handler)
Set a SockJS socket handler.
|
Modifier and Type | Method and Description |
---|---|
void |
SessionStore.clear(Handler<AsyncResult<Boolean>> resultHandler)
Remove all sessions from the store
|
void |
SessionStore.delete(String id,
Handler<AsyncResult<Boolean>> resultHandler)
Delete the session with the specified ID
|
void |
SessionStore.get(String id,
Handler<AsyncResult<Session>> resultHandler)
Get the session with the specified ID
|
void |
SessionStore.put(Session session,
Handler<AsyncResult<Boolean>> resultHandler)
Add a session with the specified ID
|
void |
SessionStore.size(Handler<AsyncResult<Integer>> resultHandler)
Get the number of sessions in the store
|
Modifier and Type | Method and Description |
---|---|
void |
TemplateEngine.render(RoutingContext context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render
|
Modifier and Type | Method and Description |
---|---|
void |
RabbitMQClient.basicAck(long deliveryTag,
boolean multiple,
Handler<AsyncResult<JsonObject>> resultHandler)
Acknowledge one or several received messages.
|
void |
RabbitMQClient.basicConsume(String queue,
String address,
boolean autoAck,
Handler<AsyncResult<Void>> resultHandler)
Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.
|
void |
RabbitMQClient.basicConsume(String queue,
String address,
Handler<AsyncResult<Void>> resultHandler)
Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.
|
void |
RabbitMQClient.basicGet(String queue,
boolean autoAck,
Handler<AsyncResult<JsonObject>> resultHandler)
Retrieve a message from a queue using AMQP.Basic.Get
|
void |
RabbitMQClient.basicNack(long deliveryTag,
boolean multiple,
boolean requeue,
Handler<AsyncResult<JsonObject>> resultHandler)
Reject one or several received messages.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
JsonObject message,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicQos(int prefetchCount,
Handler<AsyncResult<Void>> resultHandler)
Request specific "quality of service" settings, Limiting the number of unacknowledged messages on
a channel (or connection).
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange.
|
void |
RabbitMQClient.exchangeDelete(String exchange,
Handler<AsyncResult<Void>> resultHandler)
Delete an exchange, without regard for whether it is in use or not.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
void |
RabbitMQClient.messageCount(String queue,
Handler<AsyncResult<JsonObject>> resultHandler)
Returns the number of messages in a queue ready to be delivered.
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Handler<AsyncResult<JsonObject>> resultHandler)
Declare a queue
|
void |
RabbitMQClient.queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)
Actively declare a server-named exclusive, autodelete, non-durable queue.
|
void |
RabbitMQClient.queueDelete(String queue,
Handler<AsyncResult<JsonObject>> resultHandler)
Delete a queue, without regard for whether it is in use or has messages on it
|
void |
RabbitMQClient.queueDeleteIf(String queue,
boolean ifUnused,
boolean ifEmpty,
Handler<AsyncResult<JsonObject>> resultHandler)
Delete a queue
|
void |
RabbitMQClient.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ client.
|
void |
RabbitMQClient.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ client.
|
Modifier and Type | Method and Description |
---|---|
RedisClient |
RedisClient.append(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append a value to a key
|
RedisTransaction |
RedisTransaction.append(String key,
String value,
Handler<AsyncResult<String>> handler)
Append a value to a key
|
RedisClient |
RedisClient.auth(String password,
Handler<AsyncResult<String>> handler)
Authenticate to the server
|
RedisTransaction |
RedisTransaction.auth(String password,
Handler<AsyncResult<String>> handler)
Authenticate to the server
|
RedisClient |
RedisClient.bgrewriteaof(Handler<AsyncResult<String>> handler)
Asynchronously rewrite the append-only file
|
RedisTransaction |
RedisTransaction.bgrewriteaof(Handler<AsyncResult<String>> handler)
Asynchronously rewrite the append-only file
|
RedisClient |
RedisClient.bgsave(Handler<AsyncResult<String>> handler)
Asynchronously save the dataset to disk
|
RedisTransaction |
RedisTransaction.bgsave(Handler<AsyncResult<String>> handler)
Asynchronously save the dataset to disk
|
RedisClient |
RedisClient.bitcount(String key,
Handler<AsyncResult<Long>> handler)
Count set bits in a string
|
RedisTransaction |
RedisTransaction.bitcount(String key,
Handler<AsyncResult<String>> handler)
Count set bits in a string
|
RedisClient |
RedisClient.bitcountRange(String key,
long start,
long end,
Handler<AsyncResult<Long>> handler)
Count set bits in a string
|
RedisTransaction |
RedisTransaction.bitcountRange(String key,
long start,
long end,
Handler<AsyncResult<String>> handler)
Count set bits in a string
|
RedisClient |
RedisClient.bitop(BitOperation operation,
String destkey,
List<String> keys,
Handler<AsyncResult<Long>> handler)
Perform bitwise operations between strings
|
RedisTransaction |
RedisTransaction.bitop(BitOperation operation,
String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Perform bitwise operations between strings
|
RedisClient |
RedisClient.bitpos(String key,
int bit,
Handler<AsyncResult<Long>> handler)
Find first bit set or clear in a string
|
RedisTransaction |
RedisTransaction.bitpos(String key,
int bit,
Handler<AsyncResult<String>> handler)
Find first bit set or clear in a string
|
RedisClient |
RedisClient.bitposFrom(String key,
int bit,
int start,
Handler<AsyncResult<Long>> handler)
Find first bit set or clear in a string
See also bitposRange() method, which takes start, and stop offset.
|
RedisTransaction |
RedisTransaction.bitposFrom(String key,
int bit,
int start,
Handler<AsyncResult<String>> handler)
Find first bit set or clear in a string
|
RedisClient |
RedisClient.bitposRange(String key,
int bit,
int start,
int stop,
Handler<AsyncResult<Long>> handler)
Find first bit set or clear in a string
Note: when both start, and stop offsets are specified,
behaviour is slightly different than if only start is specified
|
RedisTransaction |
RedisTransaction.bitposRange(String key,
int bit,
int start,
int stop,
Handler<AsyncResult<String>> handler)
Find first bit set or clear in a string
|
RedisClient |
RedisClient.blpop(String key,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the first element in a list, or block until one is available
|
RedisTransaction |
RedisTransaction.blpop(String key,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the first element in a list, or block until one is available
|
RedisClient |
RedisClient.blpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the first element in any of the lists, or block until one is available
|
RedisTransaction |
RedisTransaction.blpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the first element in any of the lists, or block until one is available
|
RedisClient |
RedisClient.brpop(String key,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the last element in a list, or block until one is available
|
RedisTransaction |
RedisTransaction.brpop(String key,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the last element in a list, or block until one is available
|
RedisClient |
RedisClient.brpoplpush(String key,
String destkey,
int seconds,
Handler<AsyncResult<String>> handler)
Pop a value from a list, push it to another list and return it; or block until one is available
|
RedisTransaction |
RedisTransaction.brpoplpush(String key,
String destkey,
int seconds,
Handler<AsyncResult<String>> handler)
Pop a value from a list, push it to another list and return it; or block until one is available
|
RedisClient |
RedisClient.brpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<JsonArray>> handler)
Remove and get the last element in any of the lists, or block until one is available
|
RedisTransaction |
RedisTransaction.brpopMany(List<String> keys,
int seconds,
Handler<AsyncResult<String>> handler)
Remove and get the last element in any of the lists, or block until one is available
|
RedisClient |
RedisClient.clientGetname(Handler<AsyncResult<String>> handler)
Get the current connection name
|
RedisTransaction |
RedisTransaction.clientGetname(Handler<AsyncResult<String>> handler)
Get the current connection name
|
RedisClient |
RedisClient.clientKill(KillFilter filter,
Handler<AsyncResult<Long>> handler)
Kill the connection of a client
|
RedisTransaction |
RedisTransaction.clientKill(KillFilter filter,
Handler<AsyncResult<String>> handler)
Kill the connection of a client
|
RedisClient |
RedisClient.clientList(Handler<AsyncResult<String>> handler)
Get the list of client connections
|
RedisTransaction |
RedisTransaction.clientList(Handler<AsyncResult<String>> handler)
Get the list of client connections
|
RedisClient |
RedisClient.clientPause(long millis,
Handler<AsyncResult<String>> handler)
Stop processing commands from clients for some time
|
RedisTransaction |
RedisTransaction.clientPause(long millis,
Handler<AsyncResult<String>> handler)
Stop processing commands from clients for some time
|
RedisClient |
RedisClient.clientSetname(String name,
Handler<AsyncResult<String>> handler)
Set the current connection name
|
RedisTransaction |
RedisTransaction.clientSetname(String name,
Handler<AsyncResult<String>> handler)
Set the current connection name
|
void |
RedisClient.close(Handler<AsyncResult<Void>> handler)
Close the client - when it is fully closed the handler will be called.
|
void |
RedisTransaction.close(Handler<AsyncResult<Void>> handler)
Close the client - when it is fully closed the handler will be called.
|
RedisClient |
RedisClient.clusterAddslots(List<Long> slots,
Handler<AsyncResult<Void>> handler)
Assign new hash slots to receiving node.
|
RedisTransaction |
RedisTransaction.clusterAddslots(List<String> slots,
Handler<AsyncResult<String>> handler)
Assign new hash slots to receiving node.
|
RedisClient |
RedisClient.clusterCountFailureReports(String nodeId,
Handler<AsyncResult<Long>> handler)
Return the number of failure reports active for a given node.
|
RedisTransaction |
RedisTransaction.clusterCountFailureReports(String nodeId,
Handler<AsyncResult<String>> handler)
Return the number of failure reports active for a given node.
|
RedisClient |
RedisClient.clusterCountkeysinslot(long slot,
Handler<AsyncResult<Long>> handler)
Return the number of local keys in the specified hash slot.
|
RedisTransaction |
RedisTransaction.clusterCountkeysinslot(long slot,
Handler<AsyncResult<String>> handler)
Return the number of local keys in the specified hash slot.
|
RedisTransaction |
RedisTransaction.clusterDelslots(long slot,
Handler<AsyncResult<String>> handler)
Set hash slots as unbound in receiving node.
|
RedisClient |
RedisClient.clusterDelslots(long slot,
Handler<AsyncResult<Void>> handler)
Set hash slots as unbound in receiving node.
|
RedisClient |
RedisClient.clusterDelslotsMany(List<Long> slots,
Handler<AsyncResult<Void>> handler)
Set hash slots as unbound in receiving node.
|
RedisTransaction |
RedisTransaction.clusterDelslotsMany(List<String> slots,
Handler<AsyncResult<String>> handler)
Set hash slots as unbound in receiving node.
|
RedisTransaction |
RedisTransaction.clusterFailover(Handler<AsyncResult<String>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisClient |
RedisClient.clusterFailover(Handler<AsyncResult<Void>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisTransaction |
RedisTransaction.clusterFailOverWithOptions(FailoverOptions options,
Handler<AsyncResult<String>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisClient |
RedisClient.clusterFailOverWithOptions(FailoverOptions options,
Handler<AsyncResult<Void>> handler)
Forces a slave to perform a manual failover of its master.
|
RedisTransaction |
RedisTransaction.clusterForget(String nodeId,
Handler<AsyncResult<String>> handler)
Remove a node from the nodes table.
|
RedisClient |
RedisClient.clusterForget(String nodeId,
Handler<AsyncResult<Void>> handler)
Remove a node from the nodes table.
|
RedisClient |
RedisClient.clusterGetkeysinslot(long slot,
long count,
Handler<AsyncResult<JsonArray>> handler)
Return local key names in the specified hash slot.
|
RedisTransaction |
RedisTransaction.clusterGetkeysinslot(long slot,
long count,
Handler<AsyncResult<String>> handler)
Return local key names in the specified hash slot.
|
RedisClient |
RedisClient.clusterInfo(Handler<AsyncResult<JsonArray>> handler)
Provides info about Redis Cluster node state.
|
RedisTransaction |
RedisTransaction.clusterInfo(Handler<AsyncResult<String>> handler)
Provides info about Redis Cluster node state.
|
RedisClient |
RedisClient.clusterKeyslot(String key,
Handler<AsyncResult<Long>> handler)
Returns the hash slot of the specified key.
|
RedisTransaction |
RedisTransaction.clusterKeyslot(String key,
Handler<AsyncResult<String>> handler)
Returns the hash slot of the specified key.
|
RedisTransaction |
RedisTransaction.clusterMeet(String ip,
long port,
Handler<AsyncResult<String>> handler)
Force a node cluster to handshake with another node.
|
RedisClient |
RedisClient.clusterMeet(String ip,
long port,
Handler<AsyncResult<Void>> handler)
Force a node cluster to handshake with another node.
|
RedisClient |
RedisClient.clusterNodes(Handler<AsyncResult<JsonArray>> handler)
Get Cluster config for the node.
|
RedisTransaction |
RedisTransaction.clusterNodes(Handler<AsyncResult<String>> handler)
Get Cluster config for the node.
|
RedisTransaction |
RedisTransaction.clusterReplicate(String nodeId,
Handler<AsyncResult<String>> handler)
Reconfigure a node as a slave of the specified master node.
|
RedisClient |
RedisClient.clusterReplicate(String nodeId,
Handler<AsyncResult<Void>> handler)
Reconfigure a node as a slave of the specified master node.
|
RedisTransaction |
RedisTransaction.clusterReset(Handler<AsyncResult<String>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterReset(Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisTransaction |
RedisTransaction.clusterResetWithOptions(ResetOptions options,
Handler<AsyncResult<String>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterResetWithOptions(ResetOptions options,
Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisTransaction |
RedisTransaction.clusterSaveconfig(Handler<AsyncResult<String>> handler)
Forces the node to save cluster state on disk.
|
RedisClient |
RedisClient.clusterSaveconfig(Handler<AsyncResult<Void>> handler)
Forces the node to save cluster state on disk.
|
RedisTransaction |
RedisTransaction.clusterSetConfigEpoch(long epoch,
Handler<AsyncResult<String>> handler)
Set the configuration epoch in a new node.
|
RedisClient |
RedisClient.clusterSetConfigEpoch(long epoch,
Handler<AsyncResult<Void>> handler)
Set the configuration epoch in a new node.
|
RedisTransaction |
RedisTransaction.clusterSetslot(long slot,
SlotCmd subcommand,
Handler<AsyncResult<String>> handler)
Bind an hash slot to a specific node.
|
RedisClient |
RedisClient.clusterSetslot(long slot,
SlotCmd subcommand,
Handler<AsyncResult<Void>> handler)
Bind an hash slot to a specific node.
|
RedisTransaction |
RedisTransaction.clusterSetslotWithNode(long slot,
SlotCmd subcommand,
String nodeId,
Handler<AsyncResult<String>> handler)
Bind an hash slot to a specific node.
|
RedisClient |
RedisClient.clusterSetslotWithNode(long slot,
SlotCmd subcommand,
String nodeId,
Handler<AsyncResult<Void>> handler)
Bind an hash slot to a specific node.
|
RedisClient |
RedisClient.clusterSlaves(String nodeId,
Handler<AsyncResult<JsonArray>> handler)
List slave nodes of the specified master node.
|
RedisTransaction |
RedisTransaction.clusterSlaves(String nodeId,
Handler<AsyncResult<String>> handler)
List slave nodes of the specified master node.
|
RedisClient |
RedisClient.clusterSlots(Handler<AsyncResult<JsonArray>> handler)
Get array of Cluster slot to node mappings
|
RedisTransaction |
RedisTransaction.clusterSlots(Handler<AsyncResult<String>> handler)
Get array of Cluster slot to node mappings
|
RedisClient |
RedisClient.command(Handler<AsyncResult<JsonArray>> handler)
Get array of Redis command details
|
RedisTransaction |
RedisTransaction.command(Handler<AsyncResult<String>> handler)
Get array of Redis command details
|
RedisClient |
RedisClient.commandCount(Handler<AsyncResult<Long>> handler)
Get total number of Redis commands
|
RedisTransaction |
RedisTransaction.commandCount(Handler<AsyncResult<String>> handler)
Get total number of Redis commands
|
RedisClient |
RedisClient.commandGetkeys(Handler<AsyncResult<JsonArray>> handler)
Extract keys given a full Redis command
|
RedisTransaction |
RedisTransaction.commandGetkeys(Handler<AsyncResult<String>> handler)
Extract keys given a full Redis command
|
RedisClient |
RedisClient.commandInfo(List<String> commands,
Handler<AsyncResult<JsonArray>> handler)
Get array of specific Redis command details
|
RedisTransaction |
RedisTransaction.commandInfo(List<String> commands,
Handler<AsyncResult<String>> handler)
Get array of specific Redis command details
|
RedisClient |
RedisClient.configGet(String parameter,
Handler<AsyncResult<JsonArray>> handler)
Get the value of a configuration parameter
|
RedisTransaction |
RedisTransaction.configGet(String parameter,
Handler<AsyncResult<String>> handler)
Get the value of a configuration parameter
|
RedisClient |
RedisClient.configResetstat(Handler<AsyncResult<String>> handler)
Reset the stats returned by INFO
|
RedisTransaction |
RedisTransaction.configResetstat(Handler<AsyncResult<String>> handler)
Reset the stats returned by INFO
|
RedisClient |
RedisClient.configRewrite(Handler<AsyncResult<String>> handler)
Rewrite the configuration file with the in memory configuration
|
RedisTransaction |
RedisTransaction.configRewrite(Handler<AsyncResult<String>> handler)
Rewrite the configuration file with the in memory configuration
|
RedisClient |
RedisClient.configSet(String parameter,
String value,
Handler<AsyncResult<String>> handler)
Set a configuration parameter to the given value
|
RedisTransaction |
RedisTransaction.configSet(String parameter,
String value,
Handler<AsyncResult<String>> handler)
Set a configuration parameter to the given value
|
RedisClient |
RedisClient.dbsize(Handler<AsyncResult<Long>> handler)
Return the number of keys in the selected database
|
RedisTransaction |
RedisTransaction.dbsize(Handler<AsyncResult<String>> handler)
Return the number of keys in the selected database
|
RedisClient |
RedisClient.debugObject(String key,
Handler<AsyncResult<String>> handler)
Get debugging information about a key
|
RedisTransaction |
RedisTransaction.debugObject(String key,
Handler<AsyncResult<String>> handler)
Get debugging information about a key
|
RedisClient |
RedisClient.debugSegfault(Handler<AsyncResult<String>> handler)
Make the server crash
|
RedisTransaction |
RedisTransaction.debugSegfault(Handler<AsyncResult<String>> handler)
Make the server crash
|
RedisClient |
RedisClient.decr(String key,
Handler<AsyncResult<Long>> handler)
Decrement the integer value of a key by one
|
RedisTransaction |
RedisTransaction.decr(String key,
Handler<AsyncResult<String>> handler)
Decrement the integer value of a key by one
|
RedisClient |
RedisClient.decrby(String key,
long decrement,
Handler<AsyncResult<Long>> handler)
Decrement the integer value of a key by the given number
|
RedisTransaction |
RedisTransaction.decrby(String key,
long decrement,
Handler<AsyncResult<String>> handler)
Decrement the integer value of a key by the given number
|
RedisClient |
RedisClient.del(String key,
Handler<AsyncResult<Long>> handler)
Delete a key
|
RedisTransaction |
RedisTransaction.del(String key,
Handler<AsyncResult<String>> handler)
Delete a key
|
RedisClient |
RedisClient.delMany(List<String> keys,
Handler<AsyncResult<Long>> handler)
Delete many keys
|
RedisTransaction |
RedisTransaction.delMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Delete many keys
|
RedisTransaction |
RedisTransaction.discard(Handler<AsyncResult<String>> handler)
Discard all commands issued after MULTI
|
RedisClient |
RedisClient.dump(String key,
Handler<AsyncResult<String>> handler)
Return a serialized version of the value stored at the specified key.
|
RedisTransaction |
RedisTransaction.dump(String key,
Handler<AsyncResult<String>> handler)
Return a serialized version of the value stored at the specified key.
|
RedisClient |
RedisClient.echo(String message,
Handler<AsyncResult<String>> handler)
Echo the given string
|
RedisTransaction |
RedisTransaction.echo(String message,
Handler<AsyncResult<String>> handler)
Echo the given string
|
RedisClient |
RedisClient.eval(String script,
List<String> keys,
List<String> args,
Handler<AsyncResult<JsonArray>> handler)
Execute a Lua script server side.
|
RedisTransaction |
RedisTransaction.eval(String script,
List<String> keys,
List<String> args,
Handler<AsyncResult<String>> handler)
Execute a Lua script server side.
|
RedisClient |
RedisClient.evalsha(String sha1,
List<String> keys,
List<String> values,
Handler<AsyncResult<JsonArray>> handler)
Execute a Lua script server side.
|
RedisTransaction |
RedisTransaction.evalsha(String sha1,
List<String> keys,
List<String> values,
Handler<AsyncResult<String>> handler)
Execute a Lua script server side.
|
RedisTransaction |
RedisTransaction.exec(Handler<AsyncResult<JsonArray>> handler)
Execute all commands issued after MULTI
|
RedisClient |
RedisClient.exists(String key,
Handler<AsyncResult<Long>> handler)
Determine if a key exists
|
RedisTransaction |
RedisTransaction.exists(String key,
Handler<AsyncResult<String>> handler)
Determine if a key exists
|
RedisClient |
RedisClient.expire(String key,
int seconds,
Handler<AsyncResult<Long>> handler)
Set a key's time to live in seconds
|
RedisTransaction |
RedisTransaction.expire(String key,
int seconds,
Handler<AsyncResult<String>> handler)
Set a key's time to live in seconds
|
RedisClient |
RedisClient.expireat(String key,
long seconds,
Handler<AsyncResult<Long>> handler)
Set the expiration for a key as a UNIX timestamp
|
RedisTransaction |
RedisTransaction.expireat(String key,
long seconds,
Handler<AsyncResult<String>> handler)
Set the expiration for a key as a UNIX timestamp
|
RedisClient |
RedisClient.flushall(Handler<AsyncResult<String>> handler)
Remove all keys from all databases
|
RedisTransaction |
RedisTransaction.flushall(Handler<AsyncResult<String>> handler)
Remove all keys from all databases
|
RedisClient |
RedisClient.flushdb(Handler<AsyncResult<String>> handler)
Remove all keys from the current database
|
RedisTransaction |
RedisTransaction.flushdb(Handler<AsyncResult<String>> handler)
Remove all keys from the current database
|
RedisClient |
RedisClient.geoadd(String key,
double longitude,
double latitude,
String member,
Handler<AsyncResult<Long>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisTransaction |
RedisTransaction.geoadd(String key,
double longitude,
double latitude,
String member,
Handler<AsyncResult<String>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisClient |
RedisClient.geoaddMany(String key,
List<GeoMember> members,
Handler<AsyncResult<Long>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisTransaction |
RedisTransaction.geoaddMany(String key,
List<GeoMember> members,
Handler<AsyncResult<String>> handler)
Add one or more geospatial items in the geospatial index represented using a sorted set.
|
RedisClient |
RedisClient.geodist(String key,
String member1,
String member2,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.geodist(String key,
String member1,
String member2,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisClient |
RedisClient.geodistWithUnit(String key,
String member1,
String member2,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.geodistWithUnit(String key,
String member1,
String member2,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
Return the distance between two members in the geospatial index represented by the sorted set.
|
RedisClient |
RedisClient.geohash(String key,
String member,
Handler<AsyncResult<JsonArray>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisTransaction |
RedisTransaction.geohash(String key,
String member,
Handler<AsyncResult<String>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisClient |
RedisClient.geohashMany(String key,
List<String> members,
Handler<AsyncResult<JsonArray>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisTransaction |
RedisTransaction.geohashMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
|
RedisClient |
RedisClient.geopos(String key,
String member,
Handler<AsyncResult<JsonArray>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisTransaction |
RedisTransaction.geopos(String key,
String member,
Handler<AsyncResult<String>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisClient |
RedisClient.geoposMany(String key,
List<String> members,
Handler<AsyncResult<JsonArray>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisTransaction |
RedisTransaction.geoposMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
|
RedisClient |
RedisClient.georadius(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
Handler<AsyncResult<JsonArray>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisTransaction |
RedisTransaction.georadius(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisClient |
RedisClient.georadiusbymember(String key,
String member,
double radius,
GeoUnit unit,
Handler<AsyncResult<JsonArray>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.georadiusbymember(String key,
String member,
double radius,
GeoUnit unit,
Handler<AsyncResult<String>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisClient |
RedisClient.georadiusbymemberWithOptions(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<JsonArray>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisTransaction |
RedisTransaction.georadiusbymemberWithOptions(String key,
String member,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<String>> handler)
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
|
RedisClient |
RedisClient.georadiusWithOptions(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisTransaction |
RedisTransaction.georadiusWithOptions(String key,
double longitude,
double latitude,
double radius,
GeoUnit unit,
GeoRadiusOptions options,
Handler<AsyncResult<String>> handler)
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
|
RedisClient |
RedisClient.get(String key,
Handler<AsyncResult<String>> handler)
Get the value of a key
|
RedisTransaction |
RedisTransaction.get(String key,
Handler<AsyncResult<String>> handler)
Get the value of a key
|
RedisClient |
RedisClient.getBinary(String key,
Handler<AsyncResult<Buffer>> handler)
Get the value of a key - without decoding as utf-8
|
RedisTransaction |
RedisTransaction.getBinary(String key,
Handler<AsyncResult<String>> handler)
Get the value of a key - without decoding as utf-8
|
RedisClient |
RedisClient.getbit(String key,
long offset,
Handler<AsyncResult<Long>> handler)
Returns the bit value at offset in the string value stored at key
|
RedisTransaction |
RedisTransaction.getbit(String key,
long offset,
Handler<AsyncResult<String>> handler)
Returns the bit value at offset in the string value stored at key
|
RedisClient |
RedisClient.getrange(String key,
long start,
long end,
Handler<AsyncResult<String>> handler)
Get a substring of the string stored at a key
|
RedisTransaction |
RedisTransaction.getrange(String key,
long start,
long end,
Handler<AsyncResult<String>> handler)
Get a substring of the string stored at a key
|
RedisClient |
RedisClient.getset(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a key and return its old value
|
RedisTransaction |
RedisTransaction.getset(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a key and return its old value
|
RedisClient |
RedisClient.hdel(String key,
String field,
Handler<AsyncResult<Long>> handler)
Delete one or more hash fields
|
RedisTransaction |
RedisTransaction.hdel(String key,
String field,
Handler<AsyncResult<String>> handler)
Delete one or more hash fields
|
RedisClient |
RedisClient.hdelMany(String key,
List<String> fields,
Handler<AsyncResult<Long>> handler)
Delete one or more hash fields
|
RedisTransaction |
RedisTransaction.hdelMany(String key,
List<String> fields,
Handler<AsyncResult<String>> handler)
Delete one or more hash fields
|
RedisClient |
RedisClient.hexists(String key,
String field,
Handler<AsyncResult<Long>> handler)
Determine if a hash field exists
|
RedisTransaction |
RedisTransaction.hexists(String key,
String field,
Handler<AsyncResult<String>> handler)
Determine if a hash field exists
|
RedisClient |
RedisClient.hget(String key,
String field,
Handler<AsyncResult<String>> handler)
Get the value of a hash field
|
RedisTransaction |
RedisTransaction.hget(String key,
String field,
Handler<AsyncResult<String>> handler)
Get the value of a hash field
|
RedisClient |
RedisClient.hgetall(String key,
Handler<AsyncResult<JsonObject>> handler)
Get all the fields and values in a hash
|
RedisTransaction |
RedisTransaction.hgetall(String key,
Handler<AsyncResult<String>> handler)
Get all the fields and values in a hash
|
RedisClient |
RedisClient.hincrby(String key,
String field,
long increment,
Handler<AsyncResult<Long>> handler)
Increment the integer value of a hash field by the given number
|
RedisTransaction |
RedisTransaction.hincrby(String key,
String field,
long increment,
Handler<AsyncResult<String>> handler)
Increment the integer value of a hash field by the given number
|
RedisClient |
RedisClient.hincrbyfloat(String key,
String field,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a hash field by the given amount
|
RedisTransaction |
RedisTransaction.hincrbyfloat(String key,
String field,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a hash field by the given amount
|
RedisClient |
RedisClient.hkeys(String key,
Handler<AsyncResult<JsonArray>> handler)
Get all the fields in a hash
|
RedisTransaction |
RedisTransaction.hkeys(String key,
Handler<AsyncResult<String>> handler)
Get all the fields in a hash
|
RedisClient |
RedisClient.hlen(String key,
Handler<AsyncResult<Long>> handler)
Get the number of fields in a hash
|
RedisTransaction |
RedisTransaction.hlen(String key,
Handler<AsyncResult<String>> handler)
Get the number of fields in a hash
|
RedisClient |
RedisClient.hmget(String key,
List<String> fields,
Handler<AsyncResult<JsonArray>> handler)
Get the values of all the given hash fields
|
RedisTransaction |
RedisTransaction.hmget(String key,
List<String> fields,
Handler<AsyncResult<String>> handler)
Get the values of all the given hash fields
|
RedisClient |
RedisClient.hmset(String key,
JsonObject values,
Handler<AsyncResult<String>> handler)
Set multiple hash fields to multiple values
|
RedisTransaction |
RedisTransaction.hmset(String key,
JsonObject values,
Handler<AsyncResult<String>> handler)
Set multiple hash fields to multiple values
|
RedisClient |
RedisClient.hscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate hash fields and associated values
|
RedisTransaction |
RedisTransaction.hscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate hash fields and associated values
|
RedisClient |
RedisClient.hset(String key,
String field,
String value,
Handler<AsyncResult<Long>> handler)
Set the string value of a hash field
|
RedisTransaction |
RedisTransaction.hset(String key,
String field,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a hash field
|
RedisClient |
RedisClient.hsetnx(String key,
String field,
String value,
Handler<AsyncResult<Long>> handler)
Set the value of a hash field, only if the field does not exist
|
RedisTransaction |
RedisTransaction.hsetnx(String key,
String field,
String value,
Handler<AsyncResult<String>> handler)
Set the value of a hash field, only if the field does not exist
|
RedisClient |
RedisClient.hvals(String key,
Handler<AsyncResult<JsonArray>> handler)
Get all the values in a hash
|
RedisTransaction |
RedisTransaction.hvals(String key,
Handler<AsyncResult<String>> handler)
Get all the values in a hash
|
RedisClient |
RedisClient.incr(String key,
Handler<AsyncResult<Long>> handler)
Increment the integer value of a key by one
|
RedisTransaction |
RedisTransaction.incr(String key,
Handler<AsyncResult<String>> handler)
Increment the integer value of a key by one
|
RedisClient |
RedisClient.incrby(String key,
long increment,
Handler<AsyncResult<Long>> handler)
Increment the integer value of a key by the given amount
|
RedisTransaction |
RedisTransaction.incrby(String key,
long increment,
Handler<AsyncResult<String>> handler)
Increment the integer value of a key by the given amount
|
RedisClient |
RedisClient.incrbyfloat(String key,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a key by the given amount
|
RedisTransaction |
RedisTransaction.incrbyfloat(String key,
double increment,
Handler<AsyncResult<String>> handler)
Increment the float value of a key by the given amount
|
RedisClient |
RedisClient.info(Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisTransaction |
RedisTransaction.info(Handler<AsyncResult<String>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.infoSection(String section,
Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisTransaction |
RedisTransaction.infoSection(String section,
Handler<AsyncResult<String>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.keys(String pattern,
Handler<AsyncResult<JsonArray>> handler)
Find all keys matching the given pattern
|
RedisTransaction |
RedisTransaction.keys(String pattern,
Handler<AsyncResult<String>> handler)
Find all keys matching the given pattern
|
RedisClient |
RedisClient.lastsave(Handler<AsyncResult<Long>> handler)
Get the UNIX time stamp of the last successful save to disk
|
RedisTransaction |
RedisTransaction.lastsave(Handler<AsyncResult<String>> handler)
Get the UNIX time stamp of the last successful save to disk
|
RedisClient |
RedisClient.lindex(String key,
int index,
Handler<AsyncResult<String>> handler)
Get an element from a list by its index
|
RedisTransaction |
RedisTransaction.lindex(String key,
int index,
Handler<AsyncResult<String>> handler)
Get an element from a list by its index
|
RedisClient |
RedisClient.linsert(String key,
InsertOptions option,
String pivot,
String value,
Handler<AsyncResult<Long>> handler)
Insert an element before or after another element in a list
|
RedisTransaction |
RedisTransaction.linsert(String key,
InsertOptions option,
String pivot,
String value,
Handler<AsyncResult<String>> handler)
Insert an element before or after another element in a list
|
RedisClient |
RedisClient.llen(String key,
Handler<AsyncResult<Long>> handler)
Get the length of a list
|
RedisTransaction |
RedisTransaction.llen(String key,
Handler<AsyncResult<String>> handler)
Get the length of a list
|
RedisClient |
RedisClient.lpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the first element in a list
|
RedisTransaction |
RedisTransaction.lpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the first element in a list
|
RedisClient |
RedisClient.lpush(String key,
String value,
Handler<AsyncResult<Long>> handler)
Prepend one value to a list
|
RedisTransaction |
RedisTransaction.lpush(String key,
String value,
Handler<AsyncResult<String>> handler)
Prepend one value to a list
|
RedisClient |
RedisClient.lpushMany(String key,
List<String> values,
Handler<AsyncResult<Long>> handler)
Prepend one or multiple values to a list
|
RedisTransaction |
RedisTransaction.lpushMany(String key,
List<String> values,
Handler<AsyncResult<String>> handler)
Prepend one or multiple values to a list
|
RedisClient |
RedisClient.lpushx(String key,
String value,
Handler<AsyncResult<Long>> handler)
Prepend a value to a list, only if the list exists
|
RedisTransaction |
RedisTransaction.lpushx(String key,
String value,
Handler<AsyncResult<String>> handler)
Prepend a value to a list, only if the list exists
|
RedisClient |
RedisClient.lrange(String key,
long from,
long to,
Handler<AsyncResult<JsonArray>> handler)
Get a range of elements from a list
|
RedisTransaction |
RedisTransaction.lrange(String key,
long from,
long to,
Handler<AsyncResult<String>> handler)
Get a range of elements from a list
|
RedisClient |
RedisClient.lrem(String key,
long count,
String value,
Handler<AsyncResult<Long>> handler)
Remove elements from a list
|
RedisTransaction |
RedisTransaction.lrem(String key,
long count,
String value,
Handler<AsyncResult<String>> handler)
Remove elements from a list
|
RedisClient |
RedisClient.lset(String key,
long index,
String value,
Handler<AsyncResult<String>> handler)
Set the value of an element in a list by its index
|
RedisTransaction |
RedisTransaction.lset(String key,
long index,
String value,
Handler<AsyncResult<String>> handler)
Set the value of an element in a list by its index
|
RedisClient |
RedisClient.ltrim(String key,
long from,
long to,
Handler<AsyncResult<String>> handler)
Trim a list to the specified range
|
RedisTransaction |
RedisTransaction.ltrim(String key,
long from,
long to,
Handler<AsyncResult<String>> handler)
Trim a list to the specified range
|
RedisClient |
RedisClient.mget(String key,
Handler<AsyncResult<JsonArray>> handler)
Get the value of the given key
|
RedisTransaction |
RedisTransaction.mget(String key,
Handler<AsyncResult<String>> handler)
Get the value of the given key
|
RedisClient |
RedisClient.mgetMany(List<String> keys,
Handler<AsyncResult<JsonArray>> handler)
Get the values of all the given keys
|
RedisTransaction |
RedisTransaction.mgetMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Get the values of all the given keys
|
RedisClient |
RedisClient.migrate(String host,
int port,
String key,
int destdb,
long timeout,
MigrateOptions options,
Handler<AsyncResult<String>> handler)
Atomically transfer a key from a Redis instance to another one.
|
RedisTransaction |
RedisTransaction.migrate(String host,
int port,
String key,
int destdb,
long timeout,
MigrateOptions options,
Handler<AsyncResult<String>> handler)
Atomically transfer a key from a Redis instance to another one.
|
RedisTransaction |
RedisTransaction.monitor(Handler<AsyncResult<String>> handler)
Listen for all requests received by the server in real time
|
RedisClient |
RedisClient.monitor(Handler<AsyncResult<Void>> handler)
Listen for all requests received by the server in real time
|
RedisClient |
RedisClient.move(String key,
int destdb,
Handler<AsyncResult<Long>> handler)
Move a key to another database
|
RedisTransaction |
RedisTransaction.move(String key,
int destdb,
Handler<AsyncResult<String>> handler)
Move a key to another database
|
RedisClient |
RedisClient.mset(JsonObject keyvals,
Handler<AsyncResult<String>> handler)
Set multiple keys to multiple values
|
RedisTransaction |
RedisTransaction.mset(JsonObject keyvals,
Handler<AsyncResult<String>> handler)
Set multiple keys to multiple values
|
RedisClient |
RedisClient.msetnx(JsonObject keyvals,
Handler<AsyncResult<Long>> handler)
Set multiple keys to multiple values, only if none of the keys exist
|
RedisTransaction |
RedisTransaction.msetnx(JsonObject keyvals,
Handler<AsyncResult<String>> handler)
Set multiple keys to multiple values, only if none of the keys exist
|
RedisTransaction |
RedisTransaction.multi(Handler<AsyncResult<String>> handler)
Mark the start of a RedisTransaction block
|
RedisTransaction |
RedisTransaction.object(String key,
ObjectCmd cmd,
Handler<AsyncResult<String>> handler)
Inspect the internals of Redis objects
|
RedisClient |
RedisClient.object(String key,
ObjectCmd cmd,
Handler<AsyncResult<Void>> handler)
Inspect the internals of Redis objects
|
RedisClient |
RedisClient.persist(String key,
Handler<AsyncResult<Long>> handler)
Remove the expiration from a key
|
RedisTransaction |
RedisTransaction.persist(String key,
Handler<AsyncResult<String>> handler)
Remove the expiration from a key
|
RedisClient |
RedisClient.pexpire(String key,
long millis,
Handler<AsyncResult<Long>> handler)
Set a key's time to live in milliseconds
|
RedisTransaction |
RedisTransaction.pexpire(String key,
long millis,
Handler<AsyncResult<String>> handler)
Set a key's time to live in milliseconds
|
RedisClient |
RedisClient.pexpireat(String key,
long millis,
Handler<AsyncResult<Long>> handler)
Set the expiration for a key as a UNIX timestamp specified in milliseconds
|
RedisTransaction |
RedisTransaction.pexpireat(String key,
long millis,
Handler<AsyncResult<String>> handler)
Set the expiration for a key as a UNIX timestamp specified in milliseconds
|
RedisClient |
RedisClient.pfadd(String key,
String element,
Handler<AsyncResult<Long>> handler)
Adds the specified element to the specified HyperLogLog.
|
RedisTransaction |
RedisTransaction.pfadd(String key,
String element,
Handler<AsyncResult<String>> handler)
Adds the specified element to the specified HyperLogLog.
|
RedisClient |
RedisClient.pfaddMany(String key,
List<String> elements,
Handler<AsyncResult<Long>> handler)
Adds the specified elements to the specified HyperLogLog.
|
RedisTransaction |
RedisTransaction.pfaddMany(String key,
List<String> elements,
Handler<AsyncResult<String>> handler)
Adds the specified elements to the specified HyperLogLog.
|
RedisClient |
RedisClient.pfcount(String key,
Handler<AsyncResult<Long>> handler)
Return the approximated cardinality of the set observed by the HyperLogLog at key.
|
RedisTransaction |
RedisTransaction.pfcount(String key,
Handler<AsyncResult<String>> handler)
Return the approximated cardinality of the set observed by the HyperLogLog at key.
|
RedisClient |
RedisClient.pfcountMany(List<String> keys,
Handler<AsyncResult<Long>> handler)
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
|
RedisTransaction |
RedisTransaction.pfcountMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
|
RedisClient |
RedisClient.pfmerge(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Merge N different HyperLogLogs into a single one.
|
RedisTransaction |
RedisTransaction.pfmerge(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Merge N different HyperLogLogs into a single one.
|
RedisClient |
RedisClient.ping(Handler<AsyncResult<String>> handler)
Ping the server
|
RedisTransaction |
RedisTransaction.ping(Handler<AsyncResult<String>> handler)
Ping the server
|
RedisTransaction |
RedisTransaction.psetex(String key,
long millis,
String value,
Handler<AsyncResult<String>> handler)
Set the value and expiration in milliseconds of a key
|
RedisClient |
RedisClient.psetex(String key,
long millis,
String value,
Handler<AsyncResult<Void>> handler)
Set the value and expiration in milliseconds of a key
|
RedisClient |
RedisClient.psubscribe(String pattern,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to channels matching the given pattern
|
RedisTransaction |
RedisTransaction.psubscribe(String pattern,
Handler<AsyncResult<String>> handler)
Listen for messages published to channels matching the given pattern
|
RedisClient |
RedisClient.psubscribeMany(List<String> patterns,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to channels matching the given patterns
|
RedisTransaction |
RedisTransaction.psubscribeMany(List<String> patterns,
Handler<AsyncResult<String>> handler)
Listen for messages published to channels matching the given patterns
|
RedisClient |
RedisClient.pttl(String key,
Handler<AsyncResult<Long>> handler)
Get the time to live for a key in milliseconds
|
RedisTransaction |
RedisTransaction.pttl(String key,
Handler<AsyncResult<String>> handler)
Get the time to live for a key in milliseconds
|
RedisClient |
RedisClient.publish(String channel,
String message,
Handler<AsyncResult<Long>> handler)
Post a message to a channel
|
RedisTransaction |
RedisTransaction.publish(String channel,
String message,
Handler<AsyncResult<String>> handler)
Post a message to a channel
|
RedisClient |
RedisClient.pubsubChannels(String pattern,
Handler<AsyncResult<JsonArray>> handler)
Lists the currently active channels - only those matching the pattern
|
RedisTransaction |
RedisTransaction.pubsubChannels(String pattern,
Handler<AsyncResult<String>> handler)
Lists the currently active channels - only those matching the pattern
|
RedisClient |
RedisClient.pubsubNumpat(Handler<AsyncResult<Long>> handler)
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
|
RedisTransaction |
RedisTransaction.pubsubNumpat(Handler<AsyncResult<String>> handler)
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
|
RedisClient |
RedisClient.pubsubNumsub(List<String> channels,
Handler<AsyncResult<JsonArray>> handler)
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
|
RedisTransaction |
RedisTransaction.pubsubNumsub(List<String> channels,
Handler<AsyncResult<String>> handler)
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
|
RedisTransaction |
RedisTransaction.punsubscribe(List<String> patterns,
Handler<AsyncResult<String>> handler)
Stop listening for messages posted to channels matching the given patterns
|
RedisClient |
RedisClient.punsubscribe(List<String> patterns,
Handler<AsyncResult<Void>> handler)
Stop listening for messages posted to channels matching the given patterns
|
RedisClient |
RedisClient.randomkey(Handler<AsyncResult<String>> handler)
Return a random key from the keyspace
|
RedisTransaction |
RedisTransaction.randomkey(Handler<AsyncResult<String>> handler)
Return a random key from the keyspace
|
RedisClient |
RedisClient.rename(String key,
String newkey,
Handler<AsyncResult<String>> handler)
Rename a key
|
RedisTransaction |
RedisTransaction.rename(String key,
String newkey,
Handler<AsyncResult<String>> handler)
Rename a key
|
RedisClient |
RedisClient.renamenx(String key,
String newkey,
Handler<AsyncResult<Long>> handler)
Rename a key, only if the new key does not exist
|
RedisTransaction |
RedisTransaction.renamenx(String key,
String newkey,
Handler<AsyncResult<String>> handler)
Rename a key, only if the new key does not exist
|
RedisClient |
RedisClient.restore(String key,
long millis,
String serialized,
Handler<AsyncResult<String>> handler)
Create a key using the provided serialized value, previously obtained using DUMP.
|
RedisTransaction |
RedisTransaction.restore(String key,
long millis,
String serialized,
Handler<AsyncResult<String>> handler)
Create a key using the provided serialized value, previously obtained using DUMP.
|
RedisClient |
RedisClient.role(Handler<AsyncResult<JsonArray>> handler)
Return the role of the instance in the context of replication
|
RedisTransaction |
RedisTransaction.role(Handler<AsyncResult<String>> handler)
Return the role of the instance in the context of replication
|
RedisClient |
RedisClient.rpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the last element in a list
|
RedisTransaction |
RedisTransaction.rpop(String key,
Handler<AsyncResult<String>> handler)
Remove and get the last element in a list
|
RedisClient |
RedisClient.rpoplpush(String key,
String destkey,
Handler<AsyncResult<String>> handler)
Remove the last element in a list, append it to another list and return it
|
RedisTransaction |
RedisTransaction.rpoplpush(String key,
String destkey,
Handler<AsyncResult<String>> handler)
Remove the last element in a list, append it to another list and return it
|
RedisClient |
RedisClient.rpush(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append one or multiple values to a list
|
RedisTransaction |
RedisTransaction.rpush(String key,
String value,
Handler<AsyncResult<String>> handler)
Append one or multiple values to a list
|
RedisClient |
RedisClient.rpushMany(String key,
List<String> values,
Handler<AsyncResult<Long>> handler)
Append one or multiple values to a list
|
RedisTransaction |
RedisTransaction.rpushMany(String key,
List<String> values,
Handler<AsyncResult<String>> handler)
Append one or multiple values to a list
|
RedisClient |
RedisClient.rpushx(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append a value to a list, only if the list exists
|
RedisTransaction |
RedisTransaction.rpushx(String key,
String value,
Handler<AsyncResult<String>> handler)
Append a value to a list, only if the list exists
|
RedisClient |
RedisClient.sadd(String key,
String member,
Handler<AsyncResult<Long>> handler)
Add a member to a set
|
RedisTransaction |
RedisTransaction.sadd(String key,
String member,
Handler<AsyncResult<String>> handler)
Add a member to a set
|
RedisClient |
RedisClient.saddMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Add one or more members to a set
|
RedisTransaction |
RedisTransaction.saddMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Add one or more members to a set
|
RedisClient |
RedisClient.save(Handler<AsyncResult<String>> handler)
Synchronously save the dataset to disk
|
RedisTransaction |
RedisTransaction.save(Handler<AsyncResult<String>> handler)
Synchronously save the dataset to disk
|
RedisClient |
RedisClient.scan(String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate the keys space
|
RedisTransaction |
RedisTransaction.scan(String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate the keys space
|
RedisClient |
RedisClient.scard(String key,
Handler<AsyncResult<Long>> handler)
Get the number of members in a set
|
RedisTransaction |
RedisTransaction.scard(String key,
Handler<AsyncResult<String>> handler)
Get the number of members in a set
|
RedisClient |
RedisClient.scriptExists(String script,
Handler<AsyncResult<JsonArray>> handler)
Check existence of script in the script cache.
|
RedisTransaction |
RedisTransaction.scriptExists(String script,
Handler<AsyncResult<String>> handler)
Check existence of script in the script cache.
|
RedisClient |
RedisClient.scriptExistsMany(List<String> scripts,
Handler<AsyncResult<JsonArray>> handler)
Check existence of scripts in the script cache.
|
RedisTransaction |
RedisTransaction.scriptExistsMany(List<String> scripts,
Handler<AsyncResult<String>> handler)
Check existence of scripts in the script cache.
|
RedisClient |
RedisClient.scriptFlush(Handler<AsyncResult<String>> handler)
Remove all the scripts from the script cache.
|
RedisTransaction |
RedisTransaction.scriptFlush(Handler<AsyncResult<String>> handler)
Remove all the scripts from the script cache.
|
RedisClient |
RedisClient.scriptKill(Handler<AsyncResult<String>> handler)
Kill the script currently in execution.
|
RedisTransaction |
RedisTransaction.scriptKill(Handler<AsyncResult<String>> handler)
Kill the script currently in execution.
|
RedisClient |
RedisClient.scriptLoad(String script,
Handler<AsyncResult<String>> handler)
Load the specified Lua script into the script cache.
|
RedisTransaction |
RedisTransaction.scriptLoad(String script,
Handler<AsyncResult<String>> handler)
Load the specified Lua script into the script cache.
|
RedisClient |
RedisClient.sdiff(String key,
List<String> cmpkeys,
Handler<AsyncResult<JsonArray>> handler)
Subtract multiple sets
|
RedisTransaction |
RedisTransaction.sdiff(String key,
List<String> cmpkeys,
Handler<AsyncResult<String>> handler)
Subtract multiple sets
|
RedisClient |
RedisClient.sdiffstore(String destkey,
String key,
List<String> cmpkeys,
Handler<AsyncResult<Long>> handler)
Subtract multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sdiffstore(String destkey,
String key,
List<String> cmpkeys,
Handler<AsyncResult<String>> handler)
Subtract multiple sets and store the resulting set in a key
|
RedisClient |
RedisClient.select(int dbindex,
Handler<AsyncResult<String>> handler)
Change the selected database for the current connection
|
RedisTransaction |
RedisTransaction.select(int dbindex,
Handler<AsyncResult<String>> handler)
Change the selected database for the current connection
|
RedisTransaction |
RedisTransaction.set(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.set(String key,
String value,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisTransaction |
RedisTransaction.setBinary(String key,
Buffer value,
Handler<AsyncResult<String>> handler)
Set the binary string value of a key - without encoding as utf-8
|
RedisClient |
RedisClient.setBinary(String key,
Buffer value,
Handler<AsyncResult<Void>> handler)
Set the binary string value of a key - without encoding as utf-8
|
RedisTransaction |
RedisTransaction.setBinaryWithOptions(String key,
Buffer value,
SetOptions options,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.setBinaryWithOptions(String key,
Buffer value,
SetOptions options,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.setbit(String key,
long offset,
int bit,
Handler<AsyncResult<Long>> handler)
Sets or clears the bit at offset in the string value stored at key
|
RedisTransaction |
RedisTransaction.setbit(String key,
long offset,
int bit,
Handler<AsyncResult<String>> handler)
Sets or clears the bit at offset in the string value stored at key
|
RedisClient |
RedisClient.setex(String key,
long seconds,
String value,
Handler<AsyncResult<String>> handler)
Set the value and expiration of a key
|
RedisTransaction |
RedisTransaction.setex(String key,
long seconds,
String value,
Handler<AsyncResult<String>> handler)
Set the value and expiration of a key
|
RedisClient |
RedisClient.setnx(String key,
String value,
Handler<AsyncResult<Long>> handler)
Set the value of a key, only if the key does not exist
|
RedisTransaction |
RedisTransaction.setnx(String key,
String value,
Handler<AsyncResult<String>> handler)
Set the value of a key, only if the key does not exist
|
RedisClient |
RedisClient.setrange(String key,
int offset,
String value,
Handler<AsyncResult<Long>> handler)
Overwrite part of a string at key starting at the specified offset
|
RedisTransaction |
RedisTransaction.setrange(String key,
int offset,
String value,
Handler<AsyncResult<String>> handler)
Overwrite part of a string at key starting at the specified offset
|
RedisClient |
RedisClient.setWithOptions(String key,
String value,
SetOptions options,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisTransaction |
RedisTransaction.setWithOptions(String key,
String value,
SetOptions options,
Handler<AsyncResult<String>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.sinter(List<String> keys,
Handler<AsyncResult<JsonArray>> handler)
Intersect multiple sets
|
RedisTransaction |
RedisTransaction.sinter(List<String> keys,
Handler<AsyncResult<String>> handler)
Intersect multiple sets
|
RedisClient |
RedisClient.sinterstore(String destkey,
List<String> keys,
Handler<AsyncResult<Long>> handler)
Intersect multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sinterstore(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Intersect multiple sets and store the resulting set in a key
|
RedisClient |
RedisClient.sismember(String key,
String member,
Handler<AsyncResult<Long>> handler)
Determine if a given value is a member of a set
|
RedisTransaction |
RedisTransaction.sismember(String key,
String member,
Handler<AsyncResult<String>> handler)
Determine if a given value is a member of a set
|
RedisClient |
RedisClient.slaveof(String host,
int port,
Handler<AsyncResult<String>> handler)
Make the server a slave of another instance
|
RedisTransaction |
RedisTransaction.slaveof(String host,
int port,
Handler<AsyncResult<String>> handler)
Make the server a slave of another instance
|
RedisClient |
RedisClient.slaveofNoone(Handler<AsyncResult<String>> handler)
Make this server a master
|
RedisTransaction |
RedisTransaction.slaveofNoone(Handler<AsyncResult<String>> handler)
Make this server a master
|
RedisClient |
RedisClient.slowlogGet(int limit,
Handler<AsyncResult<JsonArray>> handler)
Read the Redis slow queries log
|
RedisTransaction |
RedisTransaction.slowlogGet(int limit,
Handler<AsyncResult<String>> handler)
Read the Redis slow queries log
|
RedisClient |
RedisClient.slowlogLen(Handler<AsyncResult<Long>> handler)
Get the length of the Redis slow queries log
|
RedisTransaction |
RedisTransaction.slowlogLen(Handler<AsyncResult<String>> handler)
Get the length of the Redis slow queries log
|
RedisTransaction |
RedisTransaction.slowlogReset(Handler<AsyncResult<String>> handler)
Reset the Redis slow queries log
|
RedisClient |
RedisClient.slowlogReset(Handler<AsyncResult<Void>> handler)
Reset the Redis slow queries log
|
RedisClient |
RedisClient.smembers(String key,
Handler<AsyncResult<JsonArray>> handler)
Get all the members in a set
|
RedisTransaction |
RedisTransaction.smembers(String key,
Handler<AsyncResult<String>> handler)
Get all the members in a set
|
RedisClient |
RedisClient.smove(String key,
String destkey,
String member,
Handler<AsyncResult<Long>> handler)
Move a member from one set to another
|
RedisTransaction |
RedisTransaction.smove(String key,
String destkey,
String member,
Handler<AsyncResult<String>> handler)
Move a member from one set to another
|
RedisClient |
RedisClient.sort(String key,
SortOptions options,
Handler<AsyncResult<JsonArray>> handler)
Sort the elements in a list, set or sorted set
|
RedisTransaction |
RedisTransaction.sort(String key,
SortOptions options,
Handler<AsyncResult<String>> handler)
Sort the elements in a list, set or sorted set
|
RedisClient |
RedisClient.spop(String key,
Handler<AsyncResult<String>> handler)
Remove and return a random member from a set
|
RedisTransaction |
RedisTransaction.spop(String key,
Handler<AsyncResult<String>> handler)
Remove and return a random member from a set
|
RedisClient |
RedisClient.spopMany(String key,
int count,
Handler<AsyncResult<JsonArray>> handler)
Remove and return random members from a set
|
RedisTransaction |
RedisTransaction.spopMany(String key,
int count,
Handler<AsyncResult<String>> handler)
Remove and return random members from a set
|
RedisClient |
RedisClient.srandmember(String key,
Handler<AsyncResult<String>> handler)
Get one or multiple random members from a set
|
RedisTransaction |
RedisTransaction.srandmember(String key,
Handler<AsyncResult<String>> handler)
Get one or multiple random members from a set
|
RedisClient |
RedisClient.srandmemberCount(String key,
int count,
Handler<AsyncResult<JsonArray>> handler)
Get one or multiple random members from a set
|
RedisTransaction |
RedisTransaction.srandmemberCount(String key,
int count,
Handler<AsyncResult<String>> handler)
Get one or multiple random members from a set
|
RedisClient |
RedisClient.srem(String key,
String member,
Handler<AsyncResult<Long>> handler)
Remove one member from a set
|
RedisTransaction |
RedisTransaction.srem(String key,
String member,
Handler<AsyncResult<String>> handler)
Remove one member from a set
|
RedisClient |
RedisClient.sremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Remove one or more members from a set
|
RedisTransaction |
RedisTransaction.sremMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Remove one or more members from a set
|
RedisClient |
RedisClient.sscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate Set elements
|
RedisTransaction |
RedisTransaction.sscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate Set elements
|
RedisClient |
RedisClient.strlen(String key,
Handler<AsyncResult<Long>> handler)
Get the length of the value stored in a key
|
RedisTransaction |
RedisTransaction.strlen(String key,
Handler<AsyncResult<String>> handler)
Get the length of the value stored in a key
|
RedisClient |
RedisClient.subscribe(String channel,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to the given channels
|
RedisTransaction |
RedisTransaction.subscribe(String channel,
Handler<AsyncResult<String>> handler)
Listen for messages published to the given channels
|
RedisClient |
RedisClient.subscribeMany(List<String> channels,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to the given channels
|
RedisTransaction |
RedisTransaction.subscribeMany(List<String> channels,
Handler<AsyncResult<String>> handler)
Listen for messages published to the given channels
|
RedisClient |
RedisClient.sunion(List<String> keys,
Handler<AsyncResult<JsonArray>> handler)
Add multiple sets
|
RedisTransaction |
RedisTransaction.sunion(List<String> keys,
Handler<AsyncResult<String>> handler)
Add multiple sets
|
RedisClient |
RedisClient.sunionstore(String destkey,
List<String> keys,
Handler<AsyncResult<Long>> handler)
Add multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sunionstore(String destkey,
List<String> keys,
Handler<AsyncResult<String>> handler)
Add multiple sets and store the resulting set in a key
|
RedisTransaction |
RedisTransaction.sync(Handler<AsyncResult<String>> handler)
Internal command used for replication
|
RedisClient |
RedisClient.sync(Handler<AsyncResult<Void>> handler)
Internal command used for replication
|
RedisClient |
RedisClient.time(Handler<AsyncResult<JsonArray>> handler)
Return the current server time
|
RedisTransaction |
RedisTransaction.time(Handler<AsyncResult<String>> handler)
Return the current server time
|
RedisClient |
RedisClient.ttl(String key,
Handler<AsyncResult<Long>> handler)
Get the time to live for a key
|
RedisTransaction |
RedisTransaction.ttl(String key,
Handler<AsyncResult<String>> handler)
Get the time to live for a key
|
RedisClient |
RedisClient.type(String key,
Handler<AsyncResult<String>> handler)
Determine the type stored at key
|
RedisTransaction |
RedisTransaction.type(String key,
Handler<AsyncResult<String>> handler)
Determine the type stored at key
|
RedisTransaction |
RedisTransaction.unsubscribe(List<String> channels,
Handler<AsyncResult<String>> handler)
Stop listening for messages posted to the given channels
|
RedisClient |
RedisClient.unsubscribe(List<String> channels,
Handler<AsyncResult<Void>> handler)
Stop listening for messages posted to the given channels
|
RedisTransaction |
RedisTransaction.unwatch(Handler<AsyncResult<String>> handler)
Forget about all watched keys
|
RedisClient |
RedisClient.wait(long numSlaves,
long timeout,
Handler<AsyncResult<String>> handler)
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
|
RedisTransaction |
RedisTransaction.wait(long numSlaves,
long timeout,
Handler<AsyncResult<String>> handler)
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
|
RedisTransaction |
RedisTransaction.watch(String key,
Handler<AsyncResult<String>> handler)
Watch the given keys to determine execution of the MULTI/EXEC block
|
RedisTransaction |
RedisTransaction.watchMany(List<String> keys,
Handler<AsyncResult<String>> handler)
Watch the given keys to determine execution of the MULTI/EXEC block
|
RedisClient |
RedisClient.zadd(String key,
double score,
String member,
Handler<AsyncResult<Long>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisTransaction |
RedisTransaction.zadd(String key,
double score,
String member,
Handler<AsyncResult<String>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisClient |
RedisClient.zaddMany(String key,
Map<String,Double> members,
Handler<AsyncResult<Long>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisTransaction |
RedisTransaction.zaddMany(String key,
Map<String,Double> members,
Handler<AsyncResult<String>> handler)
Add one or more members to a sorted set, or update its score if it already exists
|
RedisClient |
RedisClient.zcard(String key,
Handler<AsyncResult<Long>> handler)
Get the number of members in a sorted set
|
RedisTransaction |
RedisTransaction.zcard(String key,
Handler<AsyncResult<String>> handler)
Get the number of members in a sorted set
|
RedisClient |
RedisClient.zcount(String key,
double min,
double max,
Handler<AsyncResult<Long>> handler)
Count the members in a sorted set with scores within the given values
|
RedisTransaction |
RedisTransaction.zcount(String key,
double min,
double max,
Handler<AsyncResult<String>> handler)
Count the members in a sorted set with scores within the given values
|
RedisClient |
RedisClient.zincrby(String key,
double increment,
String member,
Handler<AsyncResult<String>> handler)
Increment the score of a member in a sorted set
|
RedisTransaction |
RedisTransaction.zincrby(String key,
double increment,
String member,
Handler<AsyncResult<String>> handler)
Increment the score of a member in a sorted set
|
RedisClient |
RedisClient.zinterstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key
|
RedisTransaction |
RedisTransaction.zinterstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key
|
RedisClient |
RedisClient.zinterstoreWeighed(String destkey,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
|
RedisTransaction |
RedisTransaction.zinterstoreWeighed(String destkey,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
|
RedisClient |
RedisClient.zlexcount(String key,
String min,
String max,
Handler<AsyncResult<Long>> handler)
Count the number of members in a sorted set between a given lexicographical range
|
RedisTransaction |
RedisTransaction.zlexcount(String key,
String min,
String max,
Handler<AsyncResult<String>> handler)
Count the number of members in a sorted set between a given lexicographical range
|
RedisClient |
RedisClient.zrange(String key,
long start,
long stop,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by index
|
RedisTransaction |
RedisTransaction.zrange(String key,
long start,
long stop,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by index
|
RedisClient |
RedisClient.zrangebylex(String key,
String min,
String max,
LimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by lexicographical range
|
RedisTransaction |
RedisTransaction.zrangebylex(String key,
String min,
String max,
LimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by lexicographical range
|
RedisClient |
RedisClient.zrangebyscore(String key,
String min,
String max,
RangeLimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by score
|
RedisTransaction |
RedisTransaction.zrangebyscore(String key,
String min,
String max,
RangeLimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by score
|
RedisClient |
RedisClient.zrangeWithOptions(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by index
|
RedisTransaction |
RedisTransaction.zrangeWithOptions(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by index
|
RedisClient |
RedisClient.zrank(String key,
String member,
Handler<AsyncResult<Long>> handler)
Determine the index of a member in a sorted set
|
RedisTransaction |
RedisTransaction.zrank(String key,
String member,
Handler<AsyncResult<String>> handler)
Determine the index of a member in a sorted set
|
RedisClient |
RedisClient.zrem(String key,
String member,
Handler<AsyncResult<Long>> handler)
Remove one member from a sorted set
|
RedisTransaction |
RedisTransaction.zrem(String key,
String member,
Handler<AsyncResult<String>> handler)
Remove one member from a sorted set
|
RedisClient |
RedisClient.zremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Remove one or more members from a sorted set
|
RedisTransaction |
RedisTransaction.zremMany(String key,
List<String> members,
Handler<AsyncResult<String>> handler)
Remove one or more members from a sorted set
|
RedisClient |
RedisClient.zremrangebylex(String key,
String min,
String max,
Handler<AsyncResult<Long>> handler)
Remove all members in a sorted set between the given lexicographical range
|
RedisTransaction |
RedisTransaction.zremrangebylex(String key,
String min,
String max,
Handler<AsyncResult<String>> handler)
Remove all members in a sorted set between the given lexicographical range
|
RedisClient |
RedisClient.zremrangebyrank(String key,
long start,
long stop,
Handler<AsyncResult<Long>> handler)
Remove all members in a sorted set within the given indexes
|
RedisTransaction |
RedisTransaction.zremrangebyrank(String key,
long start,
long stop,
Handler<AsyncResult<String>> handler)
Remove all members in a sorted set within the given indexes
|
RedisClient |
RedisClient.zremrangebyscore(String key,
String min,
String max,
Handler<AsyncResult<Long>> handler)
Remove all members in a sorted set within the given scores
|
RedisTransaction |
RedisTransaction.zremrangebyscore(String key,
String min,
String max,
Handler<AsyncResult<String>> handler)
Remove all members in a sorted set within the given scores
|
RedisClient |
RedisClient.zrevrange(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by index, with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrange(String key,
long start,
long stop,
RangeOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by index, with scores ordered from high to low
|
RedisClient |
RedisClient.zrevrangebylex(String key,
String max,
String min,
LimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrangebylex(String key,
String max,
String min,
LimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
|
RedisClient |
RedisClient.zrevrangebyscore(String key,
String max,
String min,
RangeLimitOptions options,
Handler<AsyncResult<JsonArray>> handler)
Return a range of members in a sorted set, by score, with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrangebyscore(String key,
String max,
String min,
RangeLimitOptions options,
Handler<AsyncResult<String>> handler)
Return a range of members in a sorted set, by score, with scores ordered from high to low
|
RedisClient |
RedisClient.zrevrank(String key,
String member,
Handler<AsyncResult<Long>> handler)
Determine the index of a member in a sorted set, with scores ordered from high to low
|
RedisTransaction |
RedisTransaction.zrevrank(String key,
String member,
Handler<AsyncResult<String>> handler)
Determine the index of a member in a sorted set, with scores ordered from high to low
|
RedisClient |
RedisClient.zscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> handler)
Incrementally iterate sorted sets elements and associated scores
|
RedisTransaction |
RedisTransaction.zscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<String>> handler)
Incrementally iterate sorted sets elements and associated scores
|
RedisClient |
RedisClient.zscore(String key,
String member,
Handler<AsyncResult<String>> handler)
Get the score associated with the given member in a sorted set
|
RedisTransaction |
RedisTransaction.zscore(String key,
String member,
Handler<AsyncResult<String>> handler)
Get the score associated with the given member in a sorted set
|
RedisClient |
RedisClient.zunionstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Add multiple sorted sets and store the resulting sorted set in a new key
|
RedisTransaction |
RedisTransaction.zunionstore(String destkey,
List<String> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Add multiple sorted sets and store the resulting sorted set in a new key
|
RedisClient |
RedisClient.zunionstoreWeighed(String key,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<Long>> handler)
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
|
RedisTransaction |
RedisTransaction.zunionstoreWeighed(String key,
Map<String,Double> sets,
AggregateOptions options,
Handler<AsyncResult<String>> handler)
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
|
Modifier and Type | Method and Description |
---|---|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(JsonObject filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(JsonObject filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
void |
ServiceDiscovery.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServiceDiscovery.update(Record record,
Handler<AsyncResult<Record>> resultHandler)
Updates the given record.
|
Modifier and Type | Method and Description |
---|---|
void |
ServiceExporter.close(Handler<Void> closeHandler)
Close the exporter
|
void |
ServicePublisher.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
void |
ServicePublisher.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
Modifier and Type | Method and Description |
---|---|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static <T> void |
MessageSource.getConsumer(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<MessageConsumer<T>>> resultHandler)
Convenient method that looks for a message source and provides the configured .
|
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient . |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient . |
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
JsonObject filter,
String proxyClass,
Handler<AsyncResult<T>> resultHandler) |
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
String itf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
String serviceInterface,
String proxyInterface,
Handler<AsyncResult<T>> resultHandler) |
Modifier and Type | Method and Description |
---|---|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(JsonObject filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(JsonObject filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
void |
ServiceDiscovery.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServiceDiscovery.update(Record record,
Handler<AsyncResult<Record>> resultHandler)
Updates the given record.
|
Modifier and Type | Method and Description |
---|---|
void |
RedisBackendService.getRecord(String uuid,
Handler<AsyncResult<Record>> resultHandler) |
void |
RedisBackendService.getRecords(Handler<AsyncResult<List<Record>>> resultHandler) |
void |
RedisBackendService.remove(Record record,
Handler<AsyncResult<Record>> resultHandler) |
void |
RedisBackendService.remove(String uuid,
Handler<AsyncResult<Record>> resultHandler) |
void |
RedisBackendService.store(Record record,
Handler<AsyncResult<Record>> resultHandler) |
void |
RedisBackendService.update(Record record,
Handler<AsyncResult<Void>> resultHandler) |
Modifier and Type | Method and Description |
---|---|
void |
ServiceExporter.close(Handler<Void> closeHandler)
Close the exporter
|
void |
ServiceDiscoveryBackend.getRecord(String uuid,
Handler<AsyncResult<Record>> resultHandler)
Get the record with the given uuid.
|
void |
ServiceDiscoveryBackend.getRecords(Handler<AsyncResult<List<Record>>> resultHandler)
Gets all the records
|
void |
ServicePublisher.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
void |
ServiceDiscoveryBackend.remove(Record record,
Handler<AsyncResult<Record>> resultHandler)
Removes a record.
|
void |
ServiceDiscoveryBackend.remove(String uuid,
Handler<AsyncResult<Record>> resultHandler)
Removes a records based on its UUID.
|
void |
ServiceDiscoveryBackend.store(Record record,
Handler<AsyncResult<Record>> resultHandler)
Stores a record.
|
void |
ServicePublisher.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServiceDiscoveryBackend.update(Record record,
Handler<AsyncResult<Void>> resultHandler)
Updates a record
|
Modifier and Type | Method and Description |
---|---|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured
HttpClient . |
static <T> void |
MessageSource.getConsumer(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<MessageConsumer<T>>> resultHandler)
Convenient method that looks for a message source and provides the configured
MessageConsumer . |
static void |
DataSource.getDataSourceMetadata(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<JsonObject>> resultHandler)
Gets the metadata of a data source service.
|
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient . |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient . |
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
Class<T> itf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
JsonObject filter,
String proxyClass,
Handler<AsyncResult<T>> resultHandler) |
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
String itf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> void |
EventBusService.getProxy(ServiceDiscovery discovery,
String serviceInterface,
String proxyInterface,
Handler<AsyncResult<T>> resultHandler) |
Modifier and Type | Class and Description |
---|---|
class |
ProxyHandler |
Modifier and Type | Method and Description |
---|---|
<K,V> void |
HazelcastClusterManager.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler) |
<K,V> void |
HazelcastClusterManager.getAsyncMultiMap(String name,
Handler<AsyncResult<AsyncMultiMap<K,V>>> resultHandler)
Every eventbus handler has an ID.
|
void |
HazelcastClusterManager.getCounter(String name,
Handler<AsyncResult<Counter>> resultHandler) |
void |
HazelcastClusterManager.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler) |
void |
HazelcastClusterManager.join(Handler<AsyncResult<Void>> resultHandler) |
void |
HazelcastClusterManager.leave(Handler<AsyncResult<Void>> resultHandler) |
Modifier and Type | Method and Description |
---|---|
<K,V> void |
IgniteClusterManager.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> handler) |
<K,V> void |
IgniteClusterManager.getAsyncMultiMap(String name,
Handler<AsyncResult<AsyncMultiMap<K,V>>> handler) |
void |
IgniteClusterManager.getCounter(String name,
Handler<AsyncResult<Counter>> handler) |
void |
IgniteClusterManager.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> handler) |
void |
IgniteClusterManager.join(Handler<AsyncResult<Void>> handler) |
void |
IgniteClusterManager.leave(Handler<AsyncResult<Void>> handler) |
Modifier and Type | Method and Description |
---|---|
<K,V> void |
JGroupsClusterManager.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> handler) |
<K,V> void |
JGroupsClusterManager.getAsyncMultiMap(String name,
Handler<AsyncResult<AsyncMultiMap<K,V>>> handler) |
void |
JGroupsClusterManager.getCounter(String name,
Handler<AsyncResult<Counter>> handler) |
void |
JGroupsClusterManager.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> handler) |
void |
JGroupsClusterManager.join(Handler<AsyncResult<Void>> handler) |
void |
JGroupsClusterManager.leave(Handler<AsyncResult<Void>> handler) |
Copyright © 2016. All rights reserved.