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 |
---|---|
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.
|
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) |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
<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 |
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. |
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.
|
void |
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.
|
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). |
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.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. |
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) |
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
|
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
|
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
|
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
|
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. |
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 |
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.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)
Remove matching documents from a collection
|
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.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.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 |
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.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.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.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 |
---|---|
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. |
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.
|
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. |
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. |
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 |
---|---|
static <V> Handler<AsyncResult<V>> |
InternalHelper.asyncResultHandler(CompletableFuture<V> f) |
Modifier and Type | Method and Description |
---|---|
RedisClient |
RedisClient.append(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append a value to a key
|
RedisClient |
RedisClient.auth(String password,
Handler<AsyncResult<String>> handler)
Authenticate to the server
|
RedisClient |
RedisClient.bgrewriteaof(Handler<AsyncResult<String>> handler)
Asynchronously rewrite the append-only file
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.bitcountRange(String key,
long start,
long end,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.bitpos(String key,
int bit,
Handler<AsyncResult<Long>> 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.
|
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
|
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
|
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
|
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
|
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
|
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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.clusterAddslots(List<Long> slots,
Handler<AsyncResult<Void>> 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.
|
RedisClient |
RedisClient.clusterCountkeysinslot(long slot,
Handler<AsyncResult<Long>> handler)
Return the number of local keys in the specified hash slot.
|
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.
|
RedisClient |
RedisClient.clusterFailover(Handler<AsyncResult<Void>> 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.
|
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.
|
RedisClient |
RedisClient.clusterInfo(Handler<AsyncResult<JsonArray>> 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.
|
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.
|
RedisClient |
RedisClient.clusterReplicate(String nodeId,
Handler<AsyncResult<Void>> handler)
Reconfigure a node as a slave of the specified master node.
|
RedisClient |
RedisClient.clusterReset(Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterResetWithOptions(ResetOptions options,
Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterSaveconfig(Handler<AsyncResult<Void>> handler)
Forces the node to save cluster state on disk.
|
RedisClient |
RedisClient.clusterSetConfigEpoch(long epoch,
Handler<AsyncResult<Void>> handler)
Set the configuration epoch in a new node.
|
RedisClient |
RedisClient.clusterSetslot(long slot,
SlotCmd subcommand,
Handler<AsyncResult<Void>> 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.
|
RedisClient |
RedisClient.clusterSlots(Handler<AsyncResult<JsonArray>> handler)
Get array of Cluster slot to node mappings
|
RedisClient |
RedisClient.command(Handler<AsyncResult<JsonArray>> handler)
Get array of Redis command details
|
RedisClient |
RedisClient.commandCount(Handler<AsyncResult<Long>> handler)
Get total number of Redis commands
|
RedisClient |
RedisClient.commandGetkeys(Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.configGet(String parameter,
Handler<AsyncResult<JsonArray>> handler)
Get the value of a configuration parameter
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.debugObject(String key,
Handler<AsyncResult<String>> handler)
Get debugging information about a key
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.decrby(String key,
long decrement,
Handler<AsyncResult<Long>> handler)
Decrement the integer value of a key by the given number
|
RedisClient |
RedisClient.del(String key,
Handler<AsyncResult<Long>> handler)
Delete a key
|
RedisClient |
RedisClient.delMany(List<String> keys,
Handler<AsyncResult<Long>> handler)
Delete many keys
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.evalsha(String sha1,
List<String> keys,
List<String> values,
Handler<AsyncResult<JsonArray>> handler)
Execute a Lua script server side.
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.expire(String key,
int seconds,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.getbit(String key,
long offset,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.hdelMany(String key,
List<String> fields,
Handler<AsyncResult<Long>> handler)
Delete one or more hash fields
|
RedisClient |
RedisClient.hexists(String key,
String field,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.hgetall(String key,
Handler<AsyncResult<JsonObject>> 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
|
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
|
RedisClient |
RedisClient.hkeys(String key,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.hmget(String key,
List<String> fields,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.hscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> 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
|
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
|
RedisClient |
RedisClient.hvals(String key,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.incrby(String key,
long increment,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.info(Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.infoSection(String section,
Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.keys(String pattern,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.llen(String key,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.lpush(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.lpushx(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.lrem(String key,
long count,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.mgetMany(List<String> keys,
Handler<AsyncResult<JsonArray>> 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.
|
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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.multi(Handler<AsyncResult<String>> handler)
Mark the start of a transaction block
|
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
|
RedisClient |
RedisClient.pexpire(String key,
long millis,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.pfadd(String key,
String element,
Handler<AsyncResult<Long>> 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.
|
RedisClient |
RedisClient.pfcount(String key,
Handler<AsyncResult<Long>> 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).
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.psubscribeMany(List<String> patterns,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.publish(String channel,
String message,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.pubsubNumpat(Handler<AsyncResult<Long>> 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
|
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
|
RedisClient |
RedisClient.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
|
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.
|
RedisClient |
RedisClient.role(Handler<AsyncResult<JsonArray>> 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
|
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
|
RedisClient |
RedisClient.rpush(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.rpushx(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.saddMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Add one or more members to a set
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.scard(String key,
Handler<AsyncResult<Long>> 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.
|
RedisClient |
RedisClient.scriptExistsMany(List<String> scripts,
Handler<AsyncResult<JsonArray>> handler)
Check existence of scripts in the script cache.
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.select(int dbindex,
Handler<AsyncResult<String>> handler)
Change the selected database for the current connection
|
RedisClient |
RedisClient.set(String key,
String value,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.setBinary(String key,
Buffer value,
Handler<AsyncResult<Void>> handler)
Set the binary string value of a key - without encoding as utf-8
|
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
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.setWithOptions(String key,
String value,
SetOptions options,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.sinter(List<String> keys,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.sismember(String key,
String member,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.slowlogLen(Handler<AsyncResult<Long>> handler)
Get the length of 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
|
RedisClient |
RedisClient.smove(String key,
String destkey,
String member,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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<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
|
RedisClient |
RedisClient.srandmemberCount(String key,
int count,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.sremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.strlen(String key,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.subscribeMany(List<String> channels,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to the given channels
|
RedisClient |
RedisClient.sunion(List<String> keys,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.sync(Handler<AsyncResult<Void>> handler)
Internal command used for replication
|
RedisClient |
RedisClient.time(Handler<AsyncResult<JsonArray>> handler)
Return the current server time
|
RedisClient |
RedisClient.ttl(String key,
Handler<AsyncResult<Long>> handler)
Get the time to live for a key
|
RedisClient |
RedisClient.type(String key,
Handler<AsyncResult<String>> handler)
Determine the type stored at key
|
RedisClient |
RedisClient.unsubscribe(List<String> channels,
Handler<AsyncResult<Void>> handler)
Stop listening for messages posted to the given channels
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.watch(String key,
Handler<AsyncResult<String>> handler)
Watch the given keys to determine execution of the MULTI/EXEC block
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.zcard(String key,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
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
|
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
|
RedisClient |
RedisClient.zrange(String key,
long start,
long stop,
Handler<AsyncResult<JsonArray>> 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
|
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
|
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
|
RedisClient |
RedisClient.zrank(String key,
String member,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.zremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.zremrangebyrank(String key,
long start,
long stop,
Handler<AsyncResult<Long>> 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
|
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
|
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
|
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
|
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
|
RedisClient |
RedisClient.zscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> 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
|
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
|
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
|
Modifier and Type | Method and Description |
---|---|
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(rx.functions.Action1<T> onNext)
Adapt an item callback as a
Handler<AsyncResult<T>> . |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(rx.functions.Action1<T> onNext,
rx.functions.Action1<Throwable> onError)
Adapt an item callback and an error callback as a
Handler<AsyncResult<T>> . |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(rx.functions.Action1<T> onNext,
rx.functions.Action1<Throwable> onError,
rx.functions.Action0 onComplete)
Adapt an item callback and an error callback as a
Handler<AsyncResult<T>> . |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(rx.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(rx.functions.Action1<T> onNext)
Adapt an item callback as a
Handler<T> . |
static <T> Handler<T> |
RxHelper.toHandler(rx.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(rx.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 |
Vertx.close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx 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.
|
void |
Vertx.deployVerticle(String name,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(String name,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx but the completionHandler will be notified when the deployment is complete. |
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
<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 |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Invoke
Context with order = true. |
<T> void |
Context.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Invoke
Context with order = true. |
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx called with ordered = true. |
<T> void |
Vertx.executeBlocking(Handler<Future<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx called with ordered = true. |
<T> rx.Observable<T> |
Context.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)
Invoke
Context with order = true. |
<T> rx.Observable<T> |
Vertx.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)
Like
Vertx called with ordered = true. |
<T> rx.Observable<T> |
Context.executeBlockingObservable(Handler<Future<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> rx.Observable<T> |
Vertx.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.
|
void |
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 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 but supplying a handler that will be called when the server is actually closed (or has failed). |
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.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. |
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) |
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
|
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 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
|
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
|
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
|
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 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 but providing a handler which will be notified once the file has been
completely written to the wire. |
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 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 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 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 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 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 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 |
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.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.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.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.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 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.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.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.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 |
---|---|
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. |
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.
|
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. |
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. |
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 |
---|---|
RedisClient |
RedisClient.append(String key,
String value,
Handler<AsyncResult<Long>> handler)
Append a value to a key
|
RedisClient |
RedisClient.auth(String password,
Handler<AsyncResult<String>> handler)
Authenticate to the server
|
RedisClient |
RedisClient.bgrewriteaof(Handler<AsyncResult<String>> handler)
Asynchronously rewrite the append-only file
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.bitcountRange(String key,
long start,
long end,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.bitpos(String key,
int bit,
Handler<AsyncResult<Long>> 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.
|
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
|
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
|
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
|
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
|
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
|
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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.clusterAddslots(List<Long> slots,
Handler<AsyncResult<Void>> 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.
|
RedisClient |
RedisClient.clusterCountkeysinslot(long slot,
Handler<AsyncResult<Long>> handler)
Return the number of local keys in the specified hash slot.
|
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.
|
RedisClient |
RedisClient.clusterFailover(Handler<AsyncResult<Void>> 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.
|
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.
|
RedisClient |
RedisClient.clusterInfo(Handler<AsyncResult<JsonArray>> 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.
|
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.
|
RedisClient |
RedisClient.clusterReplicate(String nodeId,
Handler<AsyncResult<Void>> handler)
Reconfigure a node as a slave of the specified master node.
|
RedisClient |
RedisClient.clusterReset(Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterResetWithOptions(ResetOptions options,
Handler<AsyncResult<Void>> handler)
Reset a Redis Cluster node.
|
RedisClient |
RedisClient.clusterSaveconfig(Handler<AsyncResult<Void>> handler)
Forces the node to save cluster state on disk.
|
RedisClient |
RedisClient.clusterSetConfigEpoch(long epoch,
Handler<AsyncResult<Void>> handler)
Set the configuration epoch in a new node.
|
RedisClient |
RedisClient.clusterSetslot(long slot,
SlotCmd subcommand,
Handler<AsyncResult<Void>> 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.
|
RedisClient |
RedisClient.clusterSlots(Handler<AsyncResult<JsonArray>> handler)
Get array of Cluster slot to node mappings
|
RedisClient |
RedisClient.command(Handler<AsyncResult<JsonArray>> handler)
Get array of Redis command details
|
RedisClient |
RedisClient.commandCount(Handler<AsyncResult<Long>> handler)
Get total number of Redis commands
|
RedisClient |
RedisClient.commandGetkeys(Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.configGet(String parameter,
Handler<AsyncResult<JsonArray>> handler)
Get the value of a configuration parameter
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.debugObject(String key,
Handler<AsyncResult<String>> handler)
Get debugging information about a key
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.decrby(String key,
long decrement,
Handler<AsyncResult<Long>> handler)
Decrement the integer value of a key by the given number
|
RedisClient |
RedisClient.del(String key,
Handler<AsyncResult<Long>> handler)
Delete a key
|
RedisClient |
RedisClient.delMany(List<String> keys,
Handler<AsyncResult<Long>> handler)
Delete many keys
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.evalsha(String sha1,
List<String> keys,
List<String> values,
Handler<AsyncResult<JsonArray>> handler)
Execute a Lua script server side.
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.expire(String key,
int seconds,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.getbit(String key,
long offset,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.hdelMany(String key,
List<String> fields,
Handler<AsyncResult<Long>> handler)
Delete one or more hash fields
|
RedisClient |
RedisClient.hexists(String key,
String field,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.hgetall(String key,
Handler<AsyncResult<JsonObject>> 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
|
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
|
RedisClient |
RedisClient.hkeys(String key,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.hmget(String key,
List<String> fields,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.hscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> 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
|
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
|
RedisClient |
RedisClient.hvals(String key,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.incrby(String key,
long increment,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.info(Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.infoSection(String section,
Handler<AsyncResult<JsonObject>> handler)
Get information and statistics about the server
|
RedisClient |
RedisClient.keys(String pattern,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.llen(String key,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.lpush(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.lpushx(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.lrem(String key,
long count,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.mgetMany(List<String> keys,
Handler<AsyncResult<JsonArray>> 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.
|
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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.multi(Handler<AsyncResult<String>> handler)
Mark the start of a transaction block
|
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
|
RedisClient |
RedisClient.pexpire(String key,
long millis,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.pfadd(String key,
String element,
Handler<AsyncResult<Long>> 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.
|
RedisClient |
RedisClient.pfcount(String key,
Handler<AsyncResult<Long>> 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).
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.psubscribeMany(List<String> patterns,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.publish(String channel,
String message,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.pubsubNumpat(Handler<AsyncResult<Long>> 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
|
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
|
RedisClient |
RedisClient.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
|
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.
|
RedisClient |
RedisClient.role(Handler<AsyncResult<JsonArray>> 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
|
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
|
RedisClient |
RedisClient.rpush(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.rpushx(String key,
String value,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.saddMany(String key,
List<String> members,
Handler<AsyncResult<Long>> handler)
Add one or more members to a set
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.scard(String key,
Handler<AsyncResult<Long>> 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.
|
RedisClient |
RedisClient.scriptExistsMany(List<String> scripts,
Handler<AsyncResult<JsonArray>> handler)
Check existence of scripts in the script cache.
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.select(int dbindex,
Handler<AsyncResult<String>> handler)
Change the selected database for the current connection
|
RedisClient |
RedisClient.set(String key,
String value,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.setBinary(String key,
Buffer value,
Handler<AsyncResult<Void>> handler)
Set the binary string value of a key - without encoding as utf-8
|
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
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.setWithOptions(String key,
String value,
SetOptions options,
Handler<AsyncResult<Void>> handler)
Set the string value of a key
|
RedisClient |
RedisClient.sinter(List<String> keys,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.sismember(String key,
String member,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
RedisClient |
RedisClient.slowlogLen(Handler<AsyncResult<Long>> handler)
Get the length of 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
|
RedisClient |
RedisClient.smove(String key,
String destkey,
String member,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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<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
|
RedisClient |
RedisClient.srandmemberCount(String key,
int count,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.sremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.strlen(String key,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.subscribeMany(List<String> channels,
Handler<AsyncResult<JsonArray>> handler)
Listen for messages published to the given channels
|
RedisClient |
RedisClient.sunion(List<String> keys,
Handler<AsyncResult<JsonArray>> 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
|
RedisClient |
RedisClient.sync(Handler<AsyncResult<Void>> handler)
Internal command used for replication
|
RedisClient |
RedisClient.time(Handler<AsyncResult<JsonArray>> handler)
Return the current server time
|
RedisClient |
RedisClient.ttl(String key,
Handler<AsyncResult<Long>> handler)
Get the time to live for a key
|
RedisClient |
RedisClient.type(String key,
Handler<AsyncResult<String>> handler)
Determine the type stored at key
|
RedisClient |
RedisClient.unsubscribe(List<String> channels,
Handler<AsyncResult<Void>> handler)
Stop listening for messages posted to the given channels
|
RedisClient |
RedisClient.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.
|
RedisClient |
RedisClient.watch(String key,
Handler<AsyncResult<String>> handler)
Watch the given keys to determine execution of the MULTI/EXEC block
|
RedisClient |
RedisClient.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
|
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
|
RedisClient |
RedisClient.zcard(String key,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.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
|
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
|
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
|
RedisClient |
RedisClient.zrange(String key,
long start,
long stop,
Handler<AsyncResult<JsonArray>> 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
|
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
|
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
|
RedisClient |
RedisClient.zrank(String key,
String member,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.zremMany(String key,
List<String> members,
Handler<AsyncResult<Long>> 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
|
RedisClient |
RedisClient.zremrangebyrank(String key,
long start,
long stop,
Handler<AsyncResult<Long>> 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
|
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
|
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
|
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
|
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
|
RedisClient |
RedisClient.zscan(String key,
String cursor,
ScanOptions options,
Handler<AsyncResult<JsonArray>> 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
|
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
|
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
|
Modifier and Type | Class and Description |
---|---|
class |
io.vertx.serviceproxy.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 |
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) |
Modifier and Type | Method and Description |
---|---|
void |
ClusteredCounterImpl.addAndGet(long delta,
Handler<AsyncResult<Long>> handler) |
void |
ClusteredCounterImpl.compareAndSet(long expected,
long update,
Handler<AsyncResult<Boolean>> handler) |
void |
ClusteredCounterImpl.decrementAndGet(Handler<AsyncResult<Long>> handler) |
void |
ClusteredCounterImpl.get(Handler<AsyncResult<Long>> handler) |
void |
ClusteredCounterImpl.getAndAdd(long delta,
Handler<AsyncResult<Long>> handler) |
void |
ClusteredCounterImpl.getAndIncrement(Handler<AsyncResult<Long>> handler) |
void |
ClusteredCounterImpl.incrementAndGet(Handler<AsyncResult<Long>> handler) |
Modifier and Type | Method and Description |
---|---|
void |
AsyncMultiMapWrapper.add(K k,
V v,
Handler<AsyncResult<Void>> handler) |
void |
AsyncMapWrapper.clear(Handler<AsyncResult<Void>> handler) |
void |
AsyncMultiMapWrapper.get(K k,
Handler<AsyncResult<ChoosableIterable<V>>> handler) |
void |
AsyncMapWrapper.get(K k,
Handler<AsyncResult<V>> handler) |
void |
AsyncMapWrapper.put(K k,
V v,
Handler<AsyncResult<Void>> handler) |
void |
AsyncMapWrapper.put(K k,
V v,
long timeout,
Handler<AsyncResult<Void>> handler) |
void |
AsyncMapWrapper.putIfAbsent(K k,
V v,
Handler<AsyncResult<V>> handler) |
void |
AsyncMapWrapper.putIfAbsent(K k,
V v,
long timeout,
Handler<AsyncResult<V>> handler) |
void |
AsyncMapWrapper.remove(K k,
Handler<AsyncResult<V>> handler) |
void |
AsyncMultiMapWrapper.remove(K k,
V v,
Handler<AsyncResult<Boolean>> handler) |
void |
AsyncMultiMapWrapper.removeAllForValue(V v,
Handler<AsyncResult<Void>> handler) |
void |
AsyncMapWrapper.removeIfPresent(K k,
V v,
Handler<AsyncResult<Boolean>> handler) |
void |
AsyncMapWrapper.replace(K k,
V v,
Handler<AsyncResult<V>> handler) |
void |
AsyncMapWrapper.replaceIfPresent(K k,
V oldValue,
V newValue,
Handler<AsyncResult<Boolean>> handler) |
void |
AsyncMapWrapper.size(Handler<AsyncResult<Integer>> handler) |
Modifier and Type | Method and Description |
---|---|
<T> void |
DefaultRpcExecutorService.remoteExecute(org.jgroups.blocks.MethodCall action,
Handler<AsyncResult<T>> handler) |
<T> void |
RpcExecutorService.remoteExecute(org.jgroups.blocks.MethodCall action,
Handler<AsyncResult<T>> handler) |
<T> void |
DefaultRpcExecutorService.remoteExecute(org.jgroups.blocks.MethodCall action,
long timeout,
Handler<AsyncResult<T>> handler) |
<T> void |
RpcExecutorService.remoteExecute(org.jgroups.blocks.MethodCall action,
long timeout,
Handler<AsyncResult<T>> handler) |
<T> void |
DefaultRpcExecutorService.runAsync(java.util.function.Supplier<T> supplier,
Handler<AsyncResult<T>> handler) |
<T> void |
RpcExecutorService.runAsync(java.util.function.Supplier<T> supplier,
Handler<AsyncResult<T>> handler) |
Copyright © 2015. All rights reserved.