| Modifier and Type | Method and Description |
|---|---|
AmqpConnection |
AmqpConnection.close(Handler<AsyncResult<Void>> done)
Closes the AMQP connection, i.e.
|
void |
AmqpSender.close(Handler<AsyncResult<Void>> handler)
Closes the sender.
|
void |
AmqpReceiver.close(Handler<AsyncResult<Void>> handler)
Closes the receiver.
|
void |
AmqpClient.close(Handler<AsyncResult<Void>> closeHandler)
Closes the client.
|
AmqpClient |
AmqpClient.connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)
Connects to the AMQP broker or router.
|
AmqpConnection |
AmqpConnection.createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)
Creates an anonymous sender.
|
AmqpConnection |
AmqpConnection.createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a dynamic receiver.
|
AmqpConnection |
AmqpConnection.createReceiver(String address,
AmqpReceiverOptions receiverOptions,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consumer messages from the given address.
|
AmqpClient |
AmqpClient.createReceiver(String address,
AmqpReceiverOptions receiverOptions,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consumer messages from the given address.
|
AmqpConnection |
AmqpConnection.createReceiver(String address,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consume messages from the given address.
|
AmqpClient |
AmqpClient.createReceiver(String address,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consume messages from the given address.
|
AmqpConnection |
AmqpConnection.createSender(String address,
AmqpSenderOptions options,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpClient |
AmqpClient.createSender(String address,
AmqpSenderOptions options,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpConnection |
AmqpConnection.createSender(String address,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpClient |
AmqpClient.createSender(String address,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpReceiver |
AmqpReceiver.endHandler(Handler<Void> endHandler) |
AmqpConnection |
AmqpConnection.exceptionHandler(Handler<Throwable> handler)
Registers a handler called on disconnection.
|
AmqpSender |
AmqpSender.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.handler(Handler<AmqpMessage> handler) |
AmqpSender |
AmqpSender.sendWithAck(AmqpMessage message,
Handler<AsyncResult<Void>> acknowledgementHandler)
Sends an AMQP message and waits for an acknowledgement.
|
| Modifier and Type | Method and Description |
|---|---|
CamelBridge |
CamelBridge.start(Handler<AsyncResult<Void>> completed)
Starts the bridge.
|
CamelBridge |
CamelBridge.stop(Handler<AsyncResult<Void>> completed)
Stops the bridge.
|
| Modifier and Type | Method and Description |
|---|---|
ResultSet |
ResultSet.all(Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> handler)
The method should not be used concurrently with others like
ResultSet.fetchNextPage() or #one(Handler). |
CassandraClient |
CassandraClient.close(Handler<AsyncResult<Void>> closeHandler)
Closes this client.
|
CassandraRowStream |
CassandraRowStream.endHandler(Handler<Void> handler) |
CassandraRowStream |
CassandraRowStream.exceptionHandler(Handler<Throwable> handler) |
<R> CassandraClient |
CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement,
java.util.stream.Collector<com.datastax.oss.driver.api.core.cql.Row,?,R> collector,
Handler<AsyncResult<R>> resultHandler)
Execute a statement and produce a result by applying a collector to result set rows.
|
CassandraClient |
CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<ResultSet>> resultHandler)
Execute the statement and provide a handler for consuming results.
|
<R> CassandraClient |
CassandraClient.execute(String query,
java.util.stream.Collector<com.datastax.oss.driver.api.core.cql.Row,?,R> collector,
Handler<AsyncResult<R>> resultHandler)
Execute a query and produce a result by applying a collector to result set rows.
|
CassandraClient |
CassandraClient.execute(String query,
Handler<AsyncResult<ResultSet>> resultHandler)
Execute the query and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)
Execute the query and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.executeWithFullFetch(String query,
Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)
Execute the query and provide a handler for consuming results.
|
void |
ResultSet.fetchNextPage(Handler<AsyncResult<ResultSet>> handler)
Like
ResultSet.fetchNextPage() but with a direct callback. |
CassandraRowStream |
CassandraRowStream.handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler) |
void |
CassandraClient.metadata(Handler<AsyncResult<com.datastax.oss.driver.api.core.metadata.Metadata>> handler)
Get
Metadata for the session. |
default void |
CassandraRowStream.pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst,
Handler<AsyncResult<Void>> handler) |
CassandraClient |
CassandraClient.prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement,
Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)
Prepares the provided a
SimpleStatement. |
CassandraClient |
CassandraClient.prepare(String query,
Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)
Prepares the provided query string.
|
CassandraClient |
CassandraClient.queryStream(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)
Executes the given SQL statement which returns the results of the query as a read stream.
|
CassandraClient |
CassandraClient.queryStream(String sql,
Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
HystrixMetricHandler
A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.
|
| Modifier and Type | Method and Description |
|---|---|
CircuitBreaker |
CircuitBreaker.closeHandler(Handler<Void> handler)
Sets a
Handler invoked when the circuit breaker state switches to close. |
<T> Future<T> |
CircuitBreaker.execute(Handler<Promise<T>> command)
Same as
CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker default fallback. |
default <T> void |
CircuitBreaker.execute(Handler<Promise<T>> command,
Handler<AsyncResult<T>> handler)
Same as
CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker default fallback. |
default <T> void |
CircuitBreaker.execute(Handler<Promise<T>> command,
Handler<AsyncResult<T>> handler)
Same as
CircuitBreaker.executeWithFallback(Handler, Function) but using the circuit breaker default fallback. |
<T> CircuitBreaker |
CircuitBreaker.executeAndReport(Promise<T> resultPromise,
Handler<Promise<T>> command)
Same as
CircuitBreaker.executeAndReportWithFallback(Promise, Handler, Function) but using the circuit breaker default
fallback. |
<T> CircuitBreaker |
CircuitBreaker.executeAndReportWithFallback(Promise<T> resultPromise,
Handler<Promise<T>> command,
java.util.function.Function<Throwable,T> fallback)
Executes the given operation with the circuit breaker control.
|
<T> Future<T> |
CircuitBreaker.executeWithFallback(Handler<Promise<T>> command,
java.util.function.Function<Throwable,T> fallback)
Executes the given operation with the circuit breaker control.
|
default <T> void |
CircuitBreaker.executeWithFallback(Handler<Promise<T>> command,
java.util.function.Function<Throwable,T> fallback,
Handler<AsyncResult<T>> handler)
Same as
CircuitBreaker.executeWithFallback(Handler, Function) but using a callback. |
default <T> void |
CircuitBreaker.executeWithFallback(Handler<Promise<T>> command,
java.util.function.Function<Throwable,T> fallback,
Handler<AsyncResult<T>> handler)
Same as
CircuitBreaker.executeWithFallback(Handler, Function) but using a callback. |
CircuitBreaker |
CircuitBreaker.halfOpenHandler(Handler<Void> handler)
Sets a
Handler invoked when the circuit breaker state switches to half-open. |
CircuitBreaker |
CircuitBreaker.openHandler(Handler<Void> handler)
Sets a
Handler invoked when the circuit breaker state switches to open. |
| Modifier and Type | Method and Description |
|---|---|
void |
ConfigRetriever.getConfig(Handler<AsyncResult<JsonObject>> completionHandler)
Reads the configuration from the different
ConfigStore
and computes the final configuration. |
void |
ConfigRetriever.listen(Handler<ConfigChange> listener)
Registers a listener receiving configuration changes.
|
ConfigRetriever |
ConfigRetriever.setBeforeScanHandler(Handler<Void> handler)
Registers a handler called before every scan.
|
| Modifier and Type | Method and Description |
|---|---|
default void |
ConfigStore.close(Handler<Void> completionHandler)
Deprecated.
implement
ConfigStore.close() instead |
default void |
ConfigStore.get(Handler<AsyncResult<Buffer>> completionHandler)
Deprecated.
implement
ConfigStore.get() instead |
default void |
ConfigProcessor.process(Vertx vertx,
JsonObject configuration,
Buffer input,
Handler<AsyncResult<JsonObject>> handler)
Deprecated.
implement
ConfigProcessor.process(Vertx, JsonObject, Buffer) instead |
| Modifier and Type | Method and Description |
|---|---|
void |
FileSet.buildConfiguration(List<File> files,
Handler<AsyncResult<JsonObject>> handler)
Iterates over the given set of files, and for each matching file, computes the resulting configuration.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SlimVaultClient.createToken(TokenRequest tokenRequest,
Handler<AsyncResult<Auth>> resultHandler)
Creates a new token.
|
void |
SlimVaultClient.delete(String path,
Handler<AsyncResult<Void>> resultHandler)
Deletes a secret from `path`.
|
void |
SlimVaultClient.list(String path,
Handler<AsyncResult<List<String>>> resultHandler)
Lists secrets from path (children).
|
void |
SlimVaultClient.loginWithAppRole(String roleId,
String secretId,
Handler<AsyncResult<Auth>> resultHandler)
Logs in against the `AppRole` backend.
|
void |
SlimVaultClient.loginWithCert(Handler<AsyncResult<Auth>> resultHandler)
Logs in against the `Cert` backend.
|
void |
SlimVaultClient.loginWithUserCredentials(String username,
String password,
Handler<AsyncResult<Auth>> resultHandler)
Logs in against the `userpass` backend.
|
void |
SlimVaultClient.lookupSelf(Handler<AsyncResult<Lookup>> resultHandler)
Looks up for the current token metadata.
|
void |
SlimVaultClient.read(String path,
Handler<AsyncResult<Secret>> responseHandler)
Reads a secret from `path`.
|
void |
SlimVaultClient.renewSelf(long leaseDurationInSecond,
Handler<AsyncResult<Auth>> resultHandler)
Renews the current token.
|
void |
SlimVaultClient.write(String path,
JsonObject secrets,
Handler<AsyncResult<Secret>> resultHandler)
Write a secret to `path`.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
Promise<T>
Represents the writable side of an action that may, or may not, have occurred yet.
|
| Modifier and Type | Method and Description |
|---|---|
Handler<Throwable> |
Context.exceptionHandler() |
Handler<Throwable> |
Vertx.exceptionHandler() |
| Modifier and Type | Method and Description |
|---|---|
default Future<T> |
Future.andThen(Handler<AsyncResult<T>> handler)
Invokes the given
handler upon completion. |
void |
Vertx.close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.close() but the completionHandler will be called when the close is complete |
void |
WorkerExecutor.close(Handler<AsyncResult<Void>> handler)
Close the executor.
|
static void |
Vertx.clusteredVertx(VertxOptions options,
Handler<AsyncResult<Vertx>> resultHandler)
Creates a clustered instance using the specified options.
|
void |
Vertx.deployVerticle(Class<? extends Verticle> verticleClass,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by
invoking the default constructor of verticleClass. |
void |
Vertx.deployVerticle(String name,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(String, Handler) but DeploymentOptions are provided to configure the
deployment. |
default 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(java.util.function.Supplier<Verticle> verticleSupplier,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, DeploymentOptions, Handler) but Verticle instance is created by
invoking the verticleSupplier. |
void |
Vertx.deployVerticle(Verticle verticle,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle, Handler) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(Verticle verticle,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(Verticle) but the completionHandler will be notified when the deployment is complete. |
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
Context |
Context.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called when the context runs an action throwing an uncaught throwable.
When this handler is called,
Vertx.currentContext() will return this context. |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
Vertx |
Vertx.exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context, set on Context.exceptionHandler(Handler) at creation. |
default <T> Future<T> |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
Same as
Context.executeBlocking(Handler, Handler) but with an handler called when the operation completes |
default <T> Future<T> |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
Same as
Vertx.executeBlocking(Handler, Handler) but with an handler called when the operation completes |
default <T> Future<T> |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
Like
WorkerExecutor.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
<T> Future<T> |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Same as
Context.executeBlocking(Handler, boolean, Handler) but with an handler called when the operation completes |
default <T> Future<T> |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Same as
Vertx.executeBlocking(Handler, boolean, Handler) but with an handler called when the operation completes |
<T> Future<T> |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Same as
WorkerExecutor.executeBlocking(Handler, boolean, Handler) but with an handler called when the operation completes |
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
default <T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
default <T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
default <T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Invoke
Context.executeBlocking(Handler, boolean, Handler) with order = true. |
default <T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Invoke
Context.executeBlocking(Handler, boolean, Handler) with order = true. |
default <T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
default <T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
Vertx.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
default <T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
WorkerExecutor.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
default <T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
Like
WorkerExecutor.executeBlocking(Handler, boolean, Handler) called with ordered = true. |
static <T> Future<T> |
Future.future(Handler<Promise<T>> handler)
Create a future that hasn't completed yet and that is passed to the
handler before it is returned. |
TimeoutStream |
TimeoutStream.handler(Handler<Long> handler) |
CompositeFuture |
CompositeFuture.onComplete(Handler<AsyncResult<CompositeFuture>> handler) |
Future<T> |
Future.onComplete(Handler<AsyncResult<T>> handler)
Add a handler to be notified of the result.
|
default Future<T> |
Future.onFailure(Handler<Throwable> handler)
Add a handler to be notified of the failed result.
|
default CompositeFuture |
CompositeFuture.onFailure(Handler<Throwable> handler) |
default CompositeFuture |
CompositeFuture.onSuccess(Handler<CompositeFuture> handler) |
default Future<T> |
Future.onSuccess(Handler<T> handler)
Add a handler to be notified of the succeeded result.
|
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.
|
default 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.setPeriodic(long initialDelay,
long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds with initial delay, 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<Void>> 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<Void>> 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. |
DatagramSocket |
DatagramSocket.endHandler(Handler<Void> endHandler) |
DatagramSocket |
DatagramSocket.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<Void>> handler)
Joins a multicast group and listens for packets send to it.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<Void>> 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<Void>> handler)
Write the given
Buffer to the SocketAddress. |
DatagramSocket |
DatagramSocket.send(String str,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
String to the SocketAddress using UTF8 encoding. |
DatagramSocket |
DatagramSocket.send(String str,
String enc,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
String to the SocketAddress using the given encoding. |
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
Handler<AsyncResult<Void>> handler)
Leaves a multicast group and stops listening for packets send to it.
|
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<Void>> 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 |
|---|---|
<T> EventBus |
EventBus.addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is received by Vert.x
|
<T> EventBus |
EventBus.addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is sent from Vert.x
|
void |
MessageProducer.close(Handler<AsyncResult<Void>> handler)
Same as
MessageProducer.close() but with an handler called when the operation completes |
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.
|
MessageConsumer<T> |
MessageConsumer.endHandler(Handler<Void> endHandler) |
MessageConsumer<T> |
MessageConsumer.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. |
<T> EventBus |
EventBus.removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addInboundInterceptor(Handler) |
<T> EventBus |
EventBus.removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addOutboundInterceptor(Handler) |
default <R> void |
Message.replyAndRequest(Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<R>>> replyHandler)
Like
Message.replyAndRequest(Object, Handler) but specifying options that can be used
to configure the delivery. |
default <R> void |
Message.replyAndRequest(Object message,
Handler<AsyncResult<Message<R>>> replyHandler)
Reply to this message, specifying a
replyHandler for the reply - i.e. |
default <T> EventBus |
EventBus.request(String address,
Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.request(String, Object, Handler) but specifying options that can be used to configure the delivery. |
default <T> EventBus |
EventBus.request(String address,
Object message,
Handler<AsyncResult<Message<T>>> replyHandler)
Sends a message and specify a
replyHandler that will be called if the recipient
subsequently replies to the message. |
void |
MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler)
Unregisters the handler which created this registration
|
void |
MessageProducer.write(T body,
Handler<AsyncResult<Void>> handler)
Write a message to the event-bus, either sending or publishing.
|
| 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,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to, asynchronously. |
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.createTempDirectory(String prefix,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempDirectory(String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempDirectory(String dir,
String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the directory provided by the path
path, using the given
prefix to generate its name, asynchronously. |
FileSystem |
FileSystem.createTempFile(String prefix,
String suffix,
Handler<AsyncResult<String>> handler)
Creates a new file in the default temporary-file directory, using the given
prefix and suffix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempFile(String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir, using the given
prefix and suffix to generate its name, asynchronously. |
FileSystem |
FileSystem.createTempFile(String dir,
String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir, using the given
prefix and suffix to generate its name, 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) |
void |
AsyncFileLock.isValid(Handler<AsyncResult<Boolean>> handler)
Like
AsyncFileLock.isValid() but the handler will be called when the operation completes or if an error occurs. |
FileSystem |
FileSystem.link(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a hard link on the file system from
link to existing, asynchronously. |
void |
AsyncFile.lock(Handler<AsyncResult<AsyncFileLock>> handler)
Like
AsyncFile.lock() but the handler will be called when the operation is complete or if an error occurs. |
void |
AsyncFile.lock(long position,
long size,
boolean shared,
Handler<AsyncResult<AsyncFileLock>> handler)
Like
AsyncFile.lock(long, long, boolean) but the handler will be called when the operation is complete or if an error occurs. |
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,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to, 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. |
void |
AsyncFileLock.release(Handler<AsyncResult<Void>> handler)
Like
AsyncFileLock.release() but the handler will be called when the operation completes or if an error occurs. |
default void |
AsyncFile.size(Handler<AsyncResult<Long>> handler)
Like
AsyncFile.size() but the handler will be called when the operation is complete or if an error occurs. |
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. |
void |
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 | Field and Description |
|---|---|
static Handler<HttpServerRequest> |
HttpServerRequest.DEFAULT_INVALID_REQUEST_HANDLER
The default invalid request handler, it uses the
HttpServerRequest.decoderResult() cause and the request information
to determine the status code of the response to be sent. |
| Modifier and Type | Method and Description |
|---|---|
Handler<HttpServerRequest> |
HttpServer.requestHandler() |
Handler<ServerWebSocket> |
HttpServer.webSocketHandler() |
| Modifier and Type | Method and Description |
|---|---|
WebSocketBase |
WebSocketBase.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
default HttpClientResponse |
HttpClientResponse.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpClientResponse.body() but with an handler called when the operation completes |
default HttpServerRequest |
HttpServerRequest.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpServerRequest.body() but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.bodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
default HttpClientResponse |
HttpClientResponse.bodyHandler(Handler<Buffer> bodyHandler)
Convenience method for receiving the entire request body in one piece.
|
default HttpServerRequest |
HttpServerRequest.bodyHandler(Handler<Buffer> bodyHandler)
Convenience method for receiving the entire request body in one piece.
|
void |
HttpServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
HttpServer.close() but supplying a handler that will be called when the server is actually closed (or has failed). |
default void |
HttpConnection.close(Handler<AsyncResult<Void>> handler)
Close the connection and all the currently active streams.
|
void |
HttpClient.close(Handler<AsyncResult<Void>> handler)
Close the client.
|
void |
WebSocketBase.close(Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close() but with an handler called when the operation completes |
void |
WebSocketBase.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(short) but with an handler called when the operation completes |
void |
WebSocketBase.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(short, String) but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.closeHandler(Handler<Void> handler)
Set a close handler for the response, this is called when the underlying connection is closed and the response
was still using the connection.
|
ServerWebSocket |
ServerWebSocket.closeHandler(Handler<Void> handler) |
WebSocket |
WebSocket.closeHandler(Handler<Void> handler) |
HttpConnection |
HttpConnection.closeHandler(Handler<Void> handler)
Set a close handler.
|
WebSocketBase |
WebSocketBase.closeHandler(Handler<Void> handler)
Set a close handler.
|
void |
HttpClientRequest.connect(Handler<AsyncResult<HttpClientResponse>> handler)
Create an HTTP tunnel to the server.
|
HttpServer |
HttpServer.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the server.
|
HttpClient |
HttpClient.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the client.
|
HttpClientRequest |
HttpClientRequest.continueHandler(Handler<Void> handler)
If you send an HTTP request with the header
Expect set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100 and a continue handler
has been set using this method, then the handler will be called. |
HttpClientResponse |
HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)
Set an custom frame handler.
|
HttpServerRequest |
HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)
Set a custom frame handler.
|
HttpServerResponse |
HttpServerResponse.drainHandler(Handler<Void> handler) |
ServerWebSocket |
ServerWebSocket.drainHandler(Handler<Void> handler) |
HttpClientRequest |
HttpClientRequest.drainHandler(Handler<Void> handler) |
WebSocket |
WebSocket.drainHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.drainHandler(Handler<Void> handler) |
void |
HttpServerResponse.end(Buffer chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(Buffer) but with an handler called when the operation completes |
void |
HttpClientRequest.end(Buffer chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(String) but with an handler called when the operation completes |
default void |
HttpClientResponse.end(Handler<AsyncResult<Void>> handler)
Same as
HttpClientResponse.end() but with an handler called when the operation completes |
void |
HttpClientRequest.end(Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end() but with an handler called when the operation completes |
default void |
HttpServerRequest.end(Handler<AsyncResult<Void>> handler)
Same as
HttpServerRequest.end() but with an handler called when the operation completes |
void |
WebSocketBase.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end() but with an handler called when the operation completes |
void |
HttpServerResponse.end(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(String) but with an handler called when the operation completes |
void |
HttpClientRequest.end(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(String) but with an handler called when the operation completes |
void |
HttpServerResponse.end(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(String, String) but with an handler called when the operation completes |
void |
HttpClientRequest.end(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(String,String) but with an handler called when the operation completes |
HttpClientResponse |
HttpClientResponse.endHandler(Handler<Void> endHandler) |
HttpServerResponse |
HttpServerResponse.endHandler(Handler<Void> handler)
Set an end handler for the response.
|
ServerWebSocket |
ServerWebSocket.endHandler(Handler<Void> endHandler) |
WebSocket |
WebSocket.endHandler(Handler<Void> endHandler) |
HttpServerFileUpload |
HttpServerFileUpload.endHandler(Handler<Void> endHandler) |
HttpServerRequest |
HttpServerRequest.endHandler(Handler<Void> endHandler) |
WebSocketBase |
WebSocketBase.endHandler(Handler<Void> endHandler) |
HttpClientResponse |
HttpClientResponse.exceptionHandler(Handler<Throwable> handler) |
HttpServerResponse |
HttpServerResponse.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpServer |
HttpServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called for socket errors happening before the HTTP connection
is established, e.g during the TLS handshake.
|
HttpClientRequest |
HttpClientRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocket |
WebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpConnection |
HttpConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called when a connection error happens
|
HttpServerFileUpload |
HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequest |
HttpServerRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocketBase |
WebSocketBase.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.
|
HttpConnection |
HttpConnection.goAwayHandler(Handler<GoAway> handler)
Set an handler called when a GOAWAY frame is received.
|
HttpClientResponse |
HttpClientResponse.handler(Handler<Buffer> handler) |
ServerWebSocket |
ServerWebSocket.handler(Handler<Buffer> handler) |
WebSocket |
WebSocket.handler(Handler<Buffer> handler) |
HttpServerFileUpload |
HttpServerFileUpload.handler(Handler<Buffer> handler) |
HttpServerRequest |
HttpServerRequest.handler(Handler<Buffer> handler) |
WebSocketBase |
WebSocketBase.handler(Handler<Buffer> handler) |
HttpServerResponse |
HttpServerResponse.headersEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the headers are written to the wire.
|
HttpServer |
HttpServer.invalidRequestHandler(Handler<HttpServerRequest> handler)
Set a
handler for handling invalid requests. |
default 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). |
default 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). |
default 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). |
default HttpServer |
HttpServer.listen(SocketAddress address,
Handler<AsyncResult<HttpServer>> listenHandler)
Tell the server to start listening on the given address supplying
a handler that will be called when the server is actually
listening (or has failed).
|
HttpConnection |
HttpConnection.ping(Buffer data,
Handler<AsyncResult<Buffer>> pongHandler)
Send a PING frame to the remote endpoint.
|
HttpConnection |
HttpConnection.pingHandler(Handler<Buffer> handler)
Set an handler notified when a PING frame is received from the remote endpoint.
|
WebSocketBase |
WebSocketBase.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
default HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with the host copied from the current request. |
default HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with the host copied from the current request. |
default HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(HttpMethod, String, String, MultiMap, Handler) with no headers. |
default HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Push a response to the client.
The
handler will be notified with a success when the push can be sent and with
a failure when the client has disabled push or reset the push before it has been sent.
The handler may be queued if the client has reduced the maximum number of streams the server can push
concurrently.
Push can be sent only for peer initiated streams and if the response is not ended. |
HttpClientRequest |
HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)
Set a push handler for this request.
The handler is called when the client receives a push promise from the server.
|
HttpConnection |
HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)
Set an handler that is called when remote endpoint
Http2Settings are updated. |
void |
HttpClient.request(HttpMethod method,
int port,
String host,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the
host and port. |
void |
HttpClient.request(HttpMethod method,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the default host and port.
|
void |
HttpClient.request(HttpMethod method,
String host,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the
host and default port. |
void |
HttpClient.request(RequestOptions options,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server.
|
HttpServer |
HttpServer.requestHandler(Handler<HttpServerRequest> handler)
Set the request handler for the server to
requestHandler. |
HttpClientRequest |
HttpClientRequest.response(Handler<AsyncResult<HttpClientResponse>> handler)
Set a callback for the associated
HttpClientResponse. |
default void |
HttpClientRequest.send(Buffer body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a buffer
body. |
default void |
HttpServerResponse.send(Buffer body,
Handler<AsyncResult<Void>> handler)
Send the request with a buffer
body. |
default void |
HttpClientRequest.send(Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with an empty body.
|
default void |
HttpServerResponse.send(Handler<AsyncResult<Void>> handler)
Send the request with an empty body.
|
default void |
HttpClientRequest.send(ReadStream<Buffer> body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a stream
body. |
default void |
HttpServerResponse.send(ReadStream<Buffer> body,
Handler<AsyncResult<Void>> handler)
Send the request with a stream
body. |
default void |
HttpClientRequest.send(String body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a string
body. |
default void |
HttpServerResponse.send(String body,
Handler<AsyncResult<Void>> handler)
Send the request with a string
body. |
default HttpServerResponse |
HttpServerResponse.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(String) but providing a handler which will be notified once the file has been completely
written to the wire. |
default HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(String, long) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(String, long, long) but providing a handler which will be notified once the file has been
completely written to the wire. |
HttpClientRequest |
HttpClientRequest.sendHead(Handler<AsyncResult<Void>> completionHandler)
Like
HttpClientRequest.sendHead() but with an handler after headers have been sent. |
void |
ServerWebSocket.setHandshake(Future<Integer> future,
Handler<AsyncResult<Integer>> handler)
Set an asynchronous result for the handshake, upon completion of the specified
future, the
WebSocket will either be
accepted when the future succeeds with the HTTP 101 status code
rejected when the future is succeeds with an HTTP status code different than 101
rejected when the future fails with the HTTP status code 500
The provided future might be completed by the WebSocket itself, e.g calling the ServerWebSocket.close() method
will try to accept the handshake and close the WebSocket afterward. |
default void |
HttpConnection.shutdown(Handler<AsyncResult<Void>> handler)
Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests
are processed, otherwise after 30 seconds the connection will be closed.
|
void |
HttpConnection.shutdown(long timeout,
Handler<AsyncResult<Void>> handler)
Like
HttpConnection.shutdown(Handler) but with a specific timeout in milliseconds. |
HttpConnection |
HttpConnection.shutdownHandler(Handler<Void> handler)
Set an handler called when a GOAWAY frame has been sent or received and all connections are closed.
|
HttpClientResponse |
HttpClientResponse.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes.
|
HttpServerRequest |
HttpServerRequest.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes
|
void |
HttpServerFileUpload.streamToFileSystem(String filename,
Handler<AsyncResult<Void>> handler)
Stream the content of this upload to the given file on storage.
|
WebSocketBase |
WebSocketBase.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
default void |
HttpServerRequest.toNetSocket(Handler<AsyncResult<NetSocket>> handler)
Establish a TCP tunnel with the client.
|
default void |
HttpServerRequest.toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler)
Upgrade the connection of the current request to a WebSocket.
|
HttpConnection |
HttpConnection.updateSettings(Http2Settings settings,
Handler<AsyncResult<Void>> completionHandler)
Send to the remote endpoint an update of this endpoint settings
The
completionHandler will be notified when the remote endpoint has acknowledged the settings. |
HttpServerRequest |
HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)
Set an upload handler.
|
void |
HttpClient.webSocket(int port,
String host,
String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket to the specified port, host and relative request URI
|
void |
HttpClient.webSocket(String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket at the relative request URI using the default host and port
|
void |
HttpClient.webSocket(String host,
String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket to the host and relative request URI and default port
|
void |
HttpClient.webSocket(WebSocketConnectOptions options,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket with the specified options.
|
void |
HttpClient.webSocketAbs(String url,
MultiMap headers,
WebsocketVersion version,
List<String> subProtocols,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket with the specified absolute url, 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. |
void |
HttpServerResponse.write(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.write(String) but with an handler called when the operation completes |
void |
HttpClientRequest.write(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.write(String) but with an handler called when the operation completes |
void |
HttpServerResponse.write(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.write(String, String) but with an handler called when the operation completes |
void |
HttpClientRequest.write(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.write(String,String) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeBinaryMessage(Buffer) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFinalBinaryFrame(Buffer, Handler) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFinalTextFrame(String, Handler) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFrame(WebSocketFrame) but with an handler called when the operation completes |
WebSocketBase |
WebSocketBase.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
WebSocketBase.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
ServerWebSocket |
ServerWebSocket.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeTextMessage(String) but with an handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
Handler<NetSocket> |
NetServer.connectHandler() |
| Modifier and Type | Method and Description |
|---|---|
void |
NetClient.close(Handler<AsyncResult<Void>> handler)
Close the client.
|
void |
NetSocket.close(Handler<AsyncResult<Void>> handler)
Close the NetSocket and notify the
handler when the operation completes. |
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. |
NetClient |
NetClient.connect(int port,
String host,
String serverName,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
port and host. |
NetClient |
NetClient.connect(SocketAddress remoteAddress,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
remoteAddress. |
NetClient |
NetClient.connect(SocketAddress remoteAddress,
String serverName,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
remoteAddress. |
NetServer |
NetServer.connectHandler(Handler<NetSocket> handler)
Supply a connect handler for this server.
|
NetSocket |
NetSocket.drainHandler(Handler<Void> handler) |
void |
NetSocket.end(Handler<AsyncResult<Void>> handler)
Calls
NetSocket.end(). |
NetSocket |
NetSocket.endHandler(Handler<Void> endHandler)
Set an end handler.
|
NetSocket |
NetSocket.exceptionHandler(Handler<Throwable> handler) |
NetServer |
NetServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called for socket errors happening before the connection
is passed to the
NetServer.connectHandler(io.vertx.core.Handler<io.vertx.core.net.NetSocket>), e.g during the TLS handshake. |
NetSocket |
NetSocket.handler(Handler<Buffer> handler) |
default 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. |
default 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. |
default 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 NetServer |
NetServer.listen(SocketAddress localAddress,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(SocketAddress) 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<AsyncResult<Void>> handler)
Upgrade channel to use SSL/TLS.
|
NetSocket |
NetSocket.upgradeToSsl(String serverName,
Handler<AsyncResult<Void>> handler)
Upgrade channel to use SSL/TLS.
|
void |
NetSocket.write(Buffer message,
Handler<AsyncResult<Void>> handler)
Like
WriteStream.write(Object) but with an handler called when the message has been written
or failed to be written. |
void |
NetSocket.write(String str,
Handler<AsyncResult<Void>> handler)
Same as
NetSocket.write(String) but with an handler called when the operation completes |
void |
NetSocket.write(String str,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
NetSocket.write(String, String) but with an handler called when the operation completes |
| Modifier and Type | Interface and Description |
|---|---|
interface |
JsonParser
A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json
element fully.
|
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 |
|---|---|
RecordParser |
RecordParser.endHandler(Handler<Void> endHandler) |
JsonParser |
JsonParser.endHandler(Handler<Void> endHandler) |
RecordParser |
RecordParser.exceptionHandler(Handler<Throwable> handler) |
JsonParser |
JsonParser.exceptionHandler(Handler<Throwable> handler) |
RecordParser |
RecordParser.handler(Handler<Buffer> handler) |
JsonParser |
JsonParser.handler(Handler<JsonEvent> handler) |
static RecordParser |
RecordParser.newDelimited(Buffer delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(Buffer) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newDelimited(String delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(String) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newFixed(int size,
Handler<Buffer> output)
Like
RecordParser.newFixed(int) but set the output that will receive whole records
which have been parsed. |
void |
RecordParser.setOutput(Handler<Buffer> output) |
| Modifier and Type | Method and Description |
|---|---|
default void |
Counter.addAndGet(long value,
Handler<AsyncResult<Long>> resultHandler)
Add the value to the counter atomically and return the new count
|
default void |
AsyncMap.clear(Handler<AsyncResult<Void>> resultHandler)
Clear all entries in the map
|
default 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.
|
default void |
Counter.decrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Decrement the counter atomically and return the new count
|
default void |
AsyncMap.entries(Handler<AsyncResult<Map<K,V>>> resultHandler)
Get the entries of the map, asynchronously.
|
default void |
Counter.get(Handler<AsyncResult<Long>> resultHandler)
Get the current value of the counter
|
default void |
AsyncMap.get(K k,
Handler<AsyncResult<V>> resultHandler)
Get a value from the map, asynchronously.
|
default void |
Counter.getAndAdd(long value,
Handler<AsyncResult<Long>> resultHandler)
Add the value to the counter atomically and return the value before the add
|
default void |
Counter.getAndIncrement(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the value before the increment.
|
<K,V> void |
SharedData.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the
AsyncMap with the specified name. |
<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 an asynchronous counter.
|
<K,V> void |
SharedData.getLocalAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the
AsyncMap with the specified name. |
void |
SharedData.getLocalCounter(String name,
Handler<AsyncResult<Counter>> resultHandler)
Get an asynchronous local counter.
|
void |
SharedData.getLocalLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get an asynchronous local lock with the specified name.
|
void |
SharedData.getLocalLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
Like
SharedData.getLocalLock(String, Handler) but specifying a timeout. |
void |
SharedData.getLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get an asynchronous 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. |
default void |
Counter.incrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the new count
|
default void |
AsyncMap.keys(Handler<AsyncResult<Set<K>>> resultHandler)
Get the keys of the map, asynchronously.
|
default void |
AsyncMap.put(K k,
V v,
Handler<AsyncResult<Void>> completionHandler)
Put a value in the map, asynchronously.
|
default 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 time to live for the entry. |
default 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.
|
default 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 time to live for the entry. |
default void |
AsyncMap.remove(K k,
Handler<AsyncResult<V>> resultHandler)
Remove a value from the map, asynchronously.
|
default 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.
|
default void |
AsyncMap.replace(K k,
V v,
Handler<AsyncResult<V>> resultHandler)
Replace the entry only if it is currently mapped to some value
|
default void |
AsyncMap.replace(K k,
V v,
long ttl,
Handler<AsyncResult<V>> resultHandler)
Replace the entry only if it is currently mapped to some value
|
default 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
|
default void |
AsyncMap.replaceIfPresent(K k,
V oldValue,
V newValue,
long ttl,
Handler<AsyncResult<Boolean>> resultHandler)
Replace the entry only if it is currently mapped to a specific value
|
default void |
AsyncMap.size(Handler<AsyncResult<Integer>> resultHandler)
Provide the number of entries in the map
|
default void |
AsyncMap.values(Handler<AsyncResult<List<V>>> resultHandler)
Get the values of the map, asynchronously.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ResolverProvider.close(Handler<Void> doneHandler) |
| Modifier and Type | Method and Description |
|---|---|
WriteStream<T> |
WriteStream.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
void |
WriteStream.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end() but with an handler called when the operation completes |
default void |
WriteStream.end(T data,
Handler<AsyncResult<Void>> handler)
Same as
#end(T) but with an handler called when the operation completes |
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.
|
default void |
ReadStream.pipeTo(WriteStream<T> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
Pipe.to(WriteStream<T> dst,
Handler<AsyncResult<Void>> completionHandler)
Start to pipe the elements to the destination
WriteStream. |
void |
WriteStream.write(T data,
Handler<AsyncResult<Void>> handler)
Same as
#write(T) but with an handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
DB2Connection |
DB2Connection.closeHandler(Handler<Void> handler) |
static void |
DB2Connection.connect(Vertx vertx,
DB2ConnectOptions connectOptions,
Handler<AsyncResult<DB2Connection>> handler)
Create a connection to DB2 server with the given
connectOptions. |
static void |
DB2Connection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<DB2Connection>> handler)
Like
DB2Connection.connect(Vertx, DB2ConnectOptions, Handler) with options build
from connectionUri. |
DB2Pool |
DB2Pool.connectHandler(Handler<SqlConnection> handler) |
DB2Connection |
DB2Connection.debug(Handler<AsyncResult<Void>> handler)
Send a DEBUG command to dump debug information to the server's stdout.
|
DB2Connection |
DB2Connection.exceptionHandler(Handler<Throwable> handler) |
DB2Connection |
DB2Connection.ping(Handler<AsyncResult<Void>> handler)
Send a PING command to check if the server is alive.
|
DB2Connection |
DB2Connection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
User |
User.isAuthorized(Authorization authority,
Handler<AsyncResult<Boolean>> resultHandler)
Deprecated.
|
default User |
User.isAuthorized(String authority,
Handler<AsyncResult<Boolean>> resultHandler)
Deprecated.
Use typed alternative
User.isAuthorized(Authorization, Handler) |
| Modifier and Type | Method and Description |
|---|---|
default void |
AuthenticationProvider.authenticate(Credentials credentials,
Handler<AsyncResult<User>> resultHandler)
Authenticate a user.
|
void |
AuthenticationProvider.authenticate(JsonObject credentials,
Handler<AsyncResult<User>> resultHandler)
Deprecated.
For type safety this method should be avoided and
AuthenticationProvider.authenticate(Credentials, Handler) should be
used instead. |
| Modifier and Type | Method and Description |
|---|---|
void |
AuthorizationProvider.getAuthorizations(User user,
Handler<AsyncResult<Void>> handler)
Updates the user with the set of authorizations.
|
| Modifier and Type | Method and Description |
|---|---|
JDBCUserUtil |
JDBCUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
Insert a user into a database.
|
JDBCUserUtil |
JDBCUserUtil.createRolePermission(String role,
String permission,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
Insert a role permission into a database.
|
JDBCUserUtil |
JDBCUserUtil.createUser(String username,
String password,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
Insert a user into a database.
|
JDBCUserUtil |
JDBCUserUtil.createUserRole(String username,
String role,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
Insert a user role into a database.
|
| Modifier and Type | Method and Description |
|---|---|
default MongoUserUtil |
MongoUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<String>> resultHandler)
Insert a user into a database.
|
default MongoUserUtil |
MongoUserUtil.createUser(String username,
String password,
Handler<AsyncResult<String>> resultHandler)
Insert a user into a database.
|
default MongoUserUtil |
MongoUserUtil.createUserRolesAndPermissions(String username,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Insert a user role into a database.
|
default void |
MongoAuth.insertUser(String username,
String password,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Deprecated.
Please use
MongoUserUtil instead.
Insert a new user into mongo in the convenient way |
| Modifier and Type | Method and Description |
|---|---|
default OAuth2Auth |
OAuth2Auth.jWKSet(Handler<AsyncResult<Void>> handler)
Retrieve the public server JSON Web Key (JWK) required to verify the authenticity
of issued ID and access tokens.
|
OAuth2Auth |
OAuth2Auth.missingKeyHandler(Handler<String> handler)
Handled to be called when a key (mentioned on a JWT) is missing from the current config.
|
default OAuth2Auth |
OAuth2Auth.refresh(User user,
Handler<AsyncResult<User>> handler)
Refresh the current User (access token).
|
default OAuth2Auth |
OAuth2Auth.revoke(User user,
Handler<AsyncResult<Void>> handler)
Revoke an obtained access token.
|
default OAuth2Auth |
OAuth2Auth.revoke(User user,
String tokenType,
Handler<AsyncResult<Void>> handler)
Revoke an obtained access or refresh token.
|
default OAuth2Auth |
OAuth2Auth.userInfo(User user,
Handler<AsyncResult<JsonObject>> handler)
Retrieve profile information and other attributes for a logged-in end-user.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
SalesforceAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
IBMCloudAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
GoogleAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
AzureADAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
OpenIDConnectAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
KeycloakAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
AmazonCognitoAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
| Modifier and Type | Method and Description |
|---|---|
default SqlUserUtil |
SqlUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<Void>> resultHandler)
Insert a user into a database.
|
default SqlUserUtil |
SqlUserUtil.createRolePermission(String role,
String permission,
Handler<AsyncResult<Void>> resultHandler)
Insert a role permission into a database.
|
default SqlUserUtil |
SqlUserUtil.createUser(String username,
String password,
Handler<AsyncResult<Void>> resultHandler)
Insert a user into a database.
|
default SqlUserUtil |
SqlUserUtil.createUserRole(String username,
String role,
Handler<AsyncResult<Void>> resultHandler)
Insert a user role into a database.
|
| Modifier and Type | Method and Description |
|---|---|
default WebAuthn |
WebAuthn.createCredentialsOptions(JsonObject user,
Handler<AsyncResult<JsonObject>> handler)
Gets a challenge and any other parameters for the
navigator.credentials.create() call. |
default MetaDataService |
MetaDataService.fetchTOC(Handler<AsyncResult<Boolean>> handler)
Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
|
default MetaDataService |
MetaDataService.fetchTOC(String url,
Handler<AsyncResult<Boolean>> handler)
Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
|
default WebAuthn |
WebAuthn.getCredentialsOptions(String name,
Handler<AsyncResult<JsonObject>> handler)
Creates an assertion challenge and any other parameters for the
navigator.credentials.get() call. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
BaseBridgeEvent
Represents an event that occurs on the event bus bridge.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ClusterHealthCheck
A helper to create Vert.x cluster
HealthChecks procedures. |
| Modifier and Type | Method and Description |
|---|---|
ConsulClient |
ConsulClient.agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)
Returns the configuration and member information of the local agent
|
ConsulClient |
ConsulClient.catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)
Return all the datacenters that are known by the Consul server
|
ConsulClient |
ConsulClient.catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)
Returns the nodes registered in a datacenter
|
ConsulClient |
ConsulClient.catalogNodeServices(String node,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the node's registered services
|
ConsulClient |
ConsulClient.catalogNodeServicesWithOptions(String node,
BlockingQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the node's registered services
This is blocking query unlike
ConsulClient.catalogNodeServices(String, Handler) |
ConsulClient |
ConsulClient.catalogNodesWithOptions(NodeQueryOptions options,
Handler<AsyncResult<NodeList>> resultHandler)
Returns the nodes registered in a datacenter
|
ConsulClient |
ConsulClient.catalogServiceNodes(String service,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the nodes providing a service
|
ConsulClient |
ConsulClient.catalogServiceNodesWithOptions(String service,
ServiceQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the nodes providing a service
|
ConsulClient |
ConsulClient.catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)
Returns the services registered in a datacenter
|
ConsulClient |
ConsulClient.catalogServicesWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the services registered in a datacenter
This is blocking query unlike
ConsulClient.catalogServices(Handler) |
ConsulClient |
ConsulClient.cloneAclToken(String id,
Handler<AsyncResult<String>> idHandler)
Clone Acl token
|
ConsulClient |
ConsulClient.coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)
Returns the WAN network coordinates for all Consul servers, organized by DCs
|
ConsulClient |
ConsulClient.coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)
Returns the LAN network coordinates for all nodes in a given DC
|
ConsulClient |
ConsulClient.coordinateNodesWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<CoordinateList>> resultHandler)
Returns the LAN network coordinates for all nodes in a given DC
This is blocking query unlike
ConsulClient.coordinateNodes(Handler) |
ConsulClient |
ConsulClient.createAclToken(AclToken token,
Handler<AsyncResult<String>> idHandler)
Create new Acl token
|
ConsulClient |
ConsulClient.createPreparedQuery(PreparedQueryDefinition definition,
Handler<AsyncResult<String>> resultHandler) |
ConsulClient |
ConsulClient.createSession(Handler<AsyncResult<String>> idHandler)
Initialize a new session
|
ConsulClient |
ConsulClient.createSessionWithOptions(SessionOptions options,
Handler<AsyncResult<String>> idHandler)
Initialize a new session
|
ConsulClient |
ConsulClient.deletePreparedQuery(String id,
Handler<AsyncResult<Void>> resultHandler)
Deletes an existing prepared query
|
ConsulClient |
ConsulClient.deleteValue(String key,
Handler<AsyncResult<Void>> resultHandler)
Remove the key/value pair that corresponding to the specified key
|
ConsulClient |
ConsulClient.deleteValues(String keyPrefix,
Handler<AsyncResult<Void>> resultHandler)
Removes all the key/value pair that corresponding to the specified key prefix
|
ConsulClient |
ConsulClient.deregisterCatalogService(String nodeId,
String serviceId,
Handler<AsyncResult<Void>> resultHandler)
Deregister entities from the node or deregister the node itself.
|
ConsulClient |
ConsulClient.deregisterCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Remove a check from the local agent.
|
ConsulClient |
ConsulClient.deregisterService(String id,
Handler<AsyncResult<Void>> resultHandler)
Remove a service from the local agent.
|
ConsulClient |
ConsulClient.destroyAclToken(String id,
Handler<AsyncResult<Void>> resultHandler)
Destroy Acl token
|
ConsulClient |
ConsulClient.destroySession(String id,
Handler<AsyncResult<Void>> resultHandler)
Destroys the given session
|
ConsulClient |
ConsulClient.executePreparedQuery(String query,
Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)
Executes an existing prepared query.
|
ConsulClient |
ConsulClient.executePreparedQueryWithOptions(String query,
PreparedQueryExecuteOptions options,
Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)
Executes an existing prepared query.
|
ConsulClient |
ConsulClient.failCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "critical".
|
ConsulClient |
ConsulClient.failCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "critical".
|
ConsulClient |
ConsulClient.fireEvent(String name,
Handler<AsyncResult<Event>> resultHandler)
Fires a new user event
|
ConsulClient |
ConsulClient.fireEventWithOptions(String name,
EventOptions options,
Handler<AsyncResult<Event>> resultHandler)
Fires a new user event
|
ConsulClient |
ConsulClient.getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)
Returns a list of all prepared queries.
|
ConsulClient |
ConsulClient.getKeys(String keyPrefix,
Handler<AsyncResult<List<String>>> resultHandler)
Returns the list of keys that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getKeysWithOptions(String keyPrefix,
BlockingQueryOptions options,
Handler<AsyncResult<List<String>>> resultHandler)
Returns the list of keys that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getPreparedQuery(String id,
Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)
Returns an existing prepared query
|
ConsulClient |
ConsulClient.getValue(String key,
Handler<AsyncResult<KeyValue>> resultHandler)
Returns key/value pair that corresponding to the specified key.
|
ConsulClient |
ConsulClient.getValues(String keyPrefix,
Handler<AsyncResult<KeyValueList>> resultHandler)
Returns the list of key/value pairs that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getValuesWithOptions(String keyPrefix,
BlockingQueryOptions options,
Handler<AsyncResult<KeyValueList>> resultHandler)
Returns the list of key/value pairs that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getValueWithOptions(String key,
BlockingQueryOptions options,
Handler<AsyncResult<KeyValue>> resultHandler)
Returns key/value pair that corresponding to the specified key.
|
ConsulClient |
ConsulClient.healthChecks(String service,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks associated with the service
|
ConsulClient |
ConsulClient.healthChecksWithOptions(String service,
CheckQueryOptions options,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks associated with the service
|
ConsulClient |
ConsulClient.healthServiceNodes(String service,
boolean passing,
Handler<AsyncResult<ServiceEntryList>> resultHandler)
Returns the nodes providing the service.
|
ConsulClient |
ConsulClient.healthServiceNodesWithOptions(String service,
boolean passing,
ServiceQueryOptions options,
Handler<AsyncResult<ServiceEntryList>> resultHandler)
Returns the nodes providing the service.
|
ConsulClient |
ConsulClient.healthState(HealthState healthState,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks in the specified status
|
ConsulClient |
ConsulClient.healthStateWithOptions(HealthState healthState,
CheckQueryOptions options,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks in the specified status
|
ConsulClient |
ConsulClient.infoAclToken(String id,
Handler<AsyncResult<AclToken>> tokenHandler)
Get info of Acl token
|
ConsulClient |
ConsulClient.infoSession(String id,
Handler<AsyncResult<Session>> resultHandler)
Returns the requested session information
|
ConsulClient |
ConsulClient.infoSessionWithOptions(String id,
BlockingQueryOptions options,
Handler<AsyncResult<Session>> resultHandler)
Returns the requested session information
This is blocking query unlike
ConsulClient.infoSession(String, Handler) |
ConsulClient |
ConsulClient.leaderStatus(Handler<AsyncResult<String>> resultHandler)
Get the Raft leader for the datacenter in which the agent is running.
|
ConsulClient |
ConsulClient.listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)
Get list of Acl token
|
ConsulClient |
ConsulClient.listEvents(Handler<AsyncResult<EventList>> resultHandler)
Returns the most recent events known by the agent
|
ConsulClient |
ConsulClient.listEventsWithOptions(EventListOptions options,
Handler<AsyncResult<EventList>> resultHandler)
Returns the most recent events known by the agent.
|
ConsulClient |
ConsulClient.listNodeSessions(String nodeId,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions for a given node
|
ConsulClient |
ConsulClient.listNodeSessionsWithOptions(String nodeId,
BlockingQueryOptions options,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions for a given node
This is blocking query unlike
ConsulClient.listNodeSessions(String, Handler) |
ConsulClient |
ConsulClient.listSessions(Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions
|
ConsulClient |
ConsulClient.listSessionsWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions
This is blocking query unlike
ConsulClient.listSessions(Handler) |
ConsulClient |
ConsulClient.localChecks(Handler<AsyncResult<List<Check>>> resultHandler)
Return all the checks that are registered with the local agent.
|
ConsulClient |
ConsulClient.localServices(Handler<AsyncResult<List<Service>>> resultHandler)
Returns list of services registered with the local agent.
|
ConsulClient |
ConsulClient.maintenanceService(MaintenanceOptions maintenanceOptions,
Handler<AsyncResult<Void>> resultHandler)
Places a given service into "maintenance mode"
|
ConsulClient |
ConsulClient.passCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "passing".
|
ConsulClient |
ConsulClient.passCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "passing".
|
ConsulClient |
ConsulClient.peersStatus(Handler<AsyncResult<List<String>>> resultHandler)
Retrieves the Raft peers for the datacenter in which the the agent is running.
|
ConsulClient |
ConsulClient.putValue(String key,
String value,
Handler<AsyncResult<Boolean>> resultHandler)
Adds specified key/value pair
|
ConsulClient |
ConsulClient.putValueWithOptions(String key,
String value,
KeyValueOptions options,
Handler<AsyncResult<Boolean>> resultHandler) |
ConsulClient |
ConsulClient.registerCatalogService(Node nodeOptions,
ServiceOptions serviceOptions,
Handler<AsyncResult<Void>> resultHandler)
Register node with external service
|
ConsulClient |
ConsulClient.registerCheck(CheckOptions checkOptions,
Handler<AsyncResult<Void>> resultHandler)
Add a new check to the local agent.
|
ConsulClient |
ConsulClient.registerService(ServiceOptions serviceOptions,
Handler<AsyncResult<Void>> resultHandler)
Adds a new service, with an optional health check, to the local agent.
|
ConsulClient |
ConsulClient.renewSession(String id,
Handler<AsyncResult<Session>> resultHandler)
Renews the given session.
|
Watch<T> |
Watch.setHandler(Handler<WatchResult<T>> handler)
Set the result handler.
|
ConsulClient |
ConsulClient.transaction(TxnRequest request,
Handler<AsyncResult<TxnResponse>> resultHandler)
Manages multiple operations inside a single, atomic transaction.
|
ConsulClient |
ConsulClient.updateAclToken(AclToken token,
Handler<AsyncResult<String>> idHandler)
Update Acl token
|
ConsulClient |
ConsulClient.updateCheck(String checkId,
CheckStatus status,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to given status.
|
ConsulClient |
ConsulClient.updateCheckWithNote(String checkId,
CheckStatus status,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to given status.
|
ConsulClient |
ConsulClient.updatePreparedQuery(PreparedQueryDefinition definition,
Handler<AsyncResult<Void>> resultHandler) |
ConsulClient |
ConsulClient.warnCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "warning".
|
ConsulClient |
ConsulClient.warnCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "warning".
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
BridgeEvent
Represents an event that occurs on the event bus bridge.
|
| Modifier and Type | Method and Description |
|---|---|
void |
TcpEventBusBridge.close(Handler<AsyncResult<Void>> handler)
Close the current socket.
|
static TcpEventBusBridge |
TcpEventBusBridge.create(Vertx vertx,
BridgeOptions options,
NetServerOptions netServerOptions,
Handler<BridgeEvent> eventHandler) |
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 | Interface and Description |
|---|---|
interface |
HealthCheckHandler
A Vert.x Web handler on which you register health check procedure.
|
| Modifier and Type | Method and Description |
|---|---|
void |
HealthChecks.checkStatus(Handler<AsyncResult<CheckResult>> resultHandler)
Invokes the registered procedures.
|
void |
HealthChecks.checkStatus(String name,
Handler<AsyncResult<CheckResult>> resultHandler)
Invokes the registered procedure with the given name and sub-procedures.
|
HealthChecks |
HealthChecks.invoke(Handler<JsonObject> resultHandler)
Invokes the registered procedures and computes the outcome.
|
HealthChecks |
HealthChecks.invoke(String name,
Handler<AsyncResult<JsonObject>> resultHandler)
Invokes the registered procedure with the given name and sub-procedures.
|
HealthChecks |
HealthChecks.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthChecks |
HealthChecks.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
| 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 |
|---|---|
MailClient |
MailClient.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler)
send a single mail via MailClient
|
| Modifier and Type | Method and Description |
|---|---|
MongoClient |
MongoClient.bulkWrite(String collection,
List<BulkOperation> operations,
Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)
Execute a bulk operation.
|
MongoClient |
MongoClient.bulkWriteWithOptions(String collection,
List<BulkOperation> operations,
BulkWriteOptions bulkWriteOptions,
Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)
Execute a bulk operation with the specified write options.
|
void |
MongoClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release its resources
|
MongoClient |
MongoClient.count(String collection,
JsonObject query,
Handler<AsyncResult<Long>> resultHandler)
Count matching documents in a collection.
|
MongoClient |
MongoClient.countWithOptions(String collection,
JsonObject query,
CountOptions countOptions,
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.createCollectionWithOptions(String collectionName,
CreateCollectionOptions collectionOptions,
Handler<AsyncResult<Void>> resultHandler)
Create a new collection with options
|
MongoClient |
MongoClient.createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)
Creates a
MongoGridFsClient used to interact with Mongo GridFS. |
MongoClient |
MongoClient.createGridFsBucketService(String bucketName,
Handler<AsyncResult<MongoGridFsClient>> resultHandler)
Creates a
MongoGridFsClient used to interact with Mongo GridFS. |
MongoClient |
MongoClient.createIndex(String collection,
JsonObject key,
Handler<AsyncResult<Void>> resultHandler)
Creates an index.
|
MongoClient |
MongoClient.createIndexes(String collection,
List<IndexModel> indexes,
Handler<AsyncResult<Void>> resultHandler)
creates an indexes
|
MongoClient |
MongoClient.createIndexWithOptions(String collection,
JsonObject key,
IndexOptions options,
Handler<AsyncResult<Void>> resultHandler)
Creates an index.
|
MongoGridFsClient |
MongoGridFsClient.delete(String id,
Handler<AsyncResult<Void>> resultHandler)
Deletes a file by it's ID
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
DistinctOptions distinctOptions,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinctWithQuery(String collection,
String fieldName,
String resultClassname,
JsonObject query,
DistinctOptions distinctOptions,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name filtered by specified query.
|
MongoClient |
MongoClient.distinctWithQuery(String collection,
String fieldName,
String resultClassname,
JsonObject query,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name filtered by specified query.
|
MongoGridFsClient |
MongoGridFsClient.downloadByFileName(WriteStream<Buffer> stream,
String fileName,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadByFileNameWithOptions(WriteStream<Buffer> stream,
String fileName,
GridFsDownloadOptions options,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadById(WriteStream<Buffer> stream,
String id,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadFile(String fileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file.
|
MongoGridFsClient |
MongoGridFsClient.downloadFileAs(String fileName,
String newFileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file and gives it a new name.
|
MongoGridFsClient |
MongoGridFsClient.downloadFileByID(String id,
String fileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file using the ID generated by GridFs.
|
MongoGridFsClient |
MongoGridFsClient.drop(Handler<AsyncResult<Void>> resultHandler)
Drops the entire file bucket with all of its contents
|
MongoClient |
MongoClient.dropCollection(String collection,
Handler<AsyncResult<Void>> resultHandler)
Drop a collection
|
MongoClient |
MongoClient.dropIndex(String collection,
String indexName,
Handler<AsyncResult<Void>> resultHandler)
Drops the index given its name.
|
MongoClient |
MongoClient.find(String collection,
JsonObject query,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection
|
MongoGridFsClient |
MongoGridFsClient.findAllIds(Handler<AsyncResult<List<String>>> resultHandler)
Finds all file ids in the bucket
|
MongoGridFsClient |
MongoGridFsClient.findIds(JsonObject query,
Handler<AsyncResult<List<String>>> resultHandler)
Finds all file ids that match a query.
|
MongoClient |
MongoClient.findOne(String collection,
JsonObject query,
JsonObject fields,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection
|
MongoClient |
MongoClient.findOneAndDelete(String collection,
JsonObject query,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and delete it.
|
MongoClient |
MongoClient.findOneAndDeleteWithOptions(String collection,
JsonObject query,
FindOptions findOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and delete it.
|
MongoClient |
MongoClient.findOneAndReplace(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and replace it.
|
MongoClient |
MongoClient.findOneAndReplaceWithOptions(String collection,
JsonObject query,
JsonObject replace,
FindOptions findOptions,
UpdateOptions updateOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and replace it.
|
MongoClient |
MongoClient.findOneAndUpdate(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and update it.
|
MongoClient |
MongoClient.findOneAndUpdateWithOptions(String collection,
JsonObject query,
JsonObject update,
FindOptions findOptions,
UpdateOptions updateOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and update it.
|
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.listIndexes(String collection,
Handler<AsyncResult<JsonArray>> resultHandler)
Get all the indexes in this collection.
|
MongoClient |
MongoClient.removeDocument(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocuments(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocumentsWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection with the specified write option and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocumentWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection with the specified write option and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.replaceDocuments(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.replaceDocumentsWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.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.updateCollection(String collection,
JsonObject query,
JsonArray update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Use an aggregation pipeline to update documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollection(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonArray update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoGridFsClient |
MongoGridFsClient.uploadByFileName(ReadStream<Buffer> stream,
String fileName,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileNameWithOptions(ReadStream<Buffer> stream,
String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadFile(String fileName,
Handler<AsyncResult<String>> resultHandler)
Upload a file to gridfs
|
MongoGridFsClient |
MongoGridFsClient.uploadFileWithOptions(String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler)
Upload a file to gridfs with options
|
| Modifier and Type | Method and Description |
|---|---|
ReactiveWriteStream<T> |
ReactiveWriteStream.drainHandler(Handler<Void> handler) |
void |
ReactiveWriteStream.end(Handler<AsyncResult<Void>> handler)
Calls
ReactiveWriteStream.close(). |
ReactiveReadStream<T> |
ReactiveReadStream.endHandler(Handler<Void> endHandler) |
ReactiveReadStream<T> |
ReactiveReadStream.exceptionHandler(Handler<Throwable> handler) |
ReactiveWriteStream<T> |
ReactiveWriteStream.exceptionHandler(Handler<Throwable> handler) |
ReactiveReadStream<T> |
ReactiveReadStream.handler(Handler<T> handler) |
void |
ReactiveWriteStream.write(T data,
Handler<AsyncResult<Void>> handler) |
| 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 |
ShellServer.shellHandler(Handler<Shell> shellHandler)
Called when a new shell is created.
|
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.
|
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<Void>> 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.
|
Tty |
Tty.resizehandler(Handler<Void> handler)
Set a resize handler, the handler is called when the tty size changes.
|
Term |
Term.resizehandler(Handler<Void> handler) |
Tty |
Tty.stdinHandler(Handler<String> handler)
Set a stream handler on the standard input to read the data.
|
Term |
Term.stdinHandler(Handler<String> handler) |
Pty |
Pty.stdoutHandler(Handler<String> handler)
Set the standard out handler of the pseudo terminal.
|
SockJSTermHandler |
SockJSTermHandler.termHandler(Handler<Term> handler) |
TermServer |
TermServer.termHandler(Handler<Term> handler)
Set the term handler that will receive incoming client connections.
|
| Modifier and Type | Method and Description |
|---|---|
SQLConnection |
SQLConnection.batch(List<String> sqlStatements,
Handler<AsyncResult<List<Integer>>> handler)
Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
|
SQLConnection |
SQLConnection.batchCallableWithParams(String sqlStatement,
List<JsonArray> inArgs,
List<JsonArray> outArgs,
Handler<AsyncResult<List<Integer>>> handler)
Batch a callable statement with all entries from the args list.
|
SQLConnection |
SQLConnection.batchWithParams(String sqlStatement,
List<JsonArray> args,
Handler<AsyncResult<List<Integer>>> handler)
Batch a prepared statement with all entries from the args list.
|
SQLConnection |
SQLConnection.call(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
default SQLClient |
SQLClient.call(String sql,
Handler<AsyncResult<ResultSet>> handler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLOperations |
SQLOperations.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. |
default SQLClient |
SQLClient.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> handler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLOperations |
SQLOperations.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
void |
SQLRowStream.close(Handler<AsyncResult<Void>> handler)
Closes the stream/underlying cursor(s).
|
void |
SQLConnection.close(Handler<AsyncResult<Void>> handler)
Closes the connection.
|
void |
SQLClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release all resources.
|
SQLConnection |
SQLConnection.commit(Handler<AsyncResult<Void>> handler)
Commits all changes made since the previous commit/rollback.
|
SQLRowStream |
SQLRowStream.endHandler(Handler<Void> endHandler) |
SQLRowStream |
SQLRowStream.exceptionHandler(Handler<Throwable> handler) |
SQLConnection |
SQLConnection.execute(String sql,
Handler<AsyncResult<Void>> resultHandler)
Executes the given SQL statement
|
SQLClient |
SQLClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
SQLConnection |
SQLConnection.getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)
Attempts to return the transaction isolation level for this Connection object to the one given.
|
SQLRowStream |
SQLRowStream.handler(Handler<JsonArray> handler) |
SQLConnection |
SQLConnection.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
default SQLClient |
SQLClient.query(String sql,
Handler<AsyncResult<ResultSet>> handler)
Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL
statement and returns it back after the execution.
|
SQLOperations |
SQLOperations.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
default SQLOperations |
SQLOperations.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
default SQLOperations |
SQLOperations.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLConnection |
SQLConnection.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
default SQLClient |
SQLClient.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLOperations |
SQLOperations.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLConnection |
SQLConnection.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
default SQLClient |
SQLClient.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLOperations |
SQLOperations.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
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. |
default SQLClient |
SQLClient.queryWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<ResultSet>> handler)
Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL
prepared statement and returns it back after the execution.
|
SQLOperations |
SQLOperations.queryWithParams(String sql,
JsonArray params,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT prepared statement which returns the results of the query. |
SQLRowStream |
SQLRowStream.resultSetClosedHandler(Handler<Void> handler)
Event handler when a resultset is closed.
|
SQLConnection |
SQLConnection.rollback(Handler<AsyncResult<Void>> handler)
Rolls back all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.setAutoCommit(boolean autoCommit,
Handler<AsyncResult<Void>> resultHandler)
Sets the auto commit flag for this connection.
|
SQLConnection |
SQLConnection.setTransactionIsolation(TransactionIsolation isolation,
Handler<AsyncResult<Void>> handler)
Attempts to change the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.update(String sql,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given SQL statement which may be an
INSERT, UPDATE, or DELETE
statement. |
default SQLClient |
SQLClient.update(String sql,
Handler<AsyncResult<UpdateResult>> handler)
Executes the given SQL statement which may be an
INSERT, UPDATE, or DELETE
statement. |
SQLOperations |
SQLOperations.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 |
default SQLClient |
SQLClient.updateWithParams(String sql,
JsonArray params,
Handler<AsyncResult<UpdateResult>> handler)
Executes the given prepared statement which may be an
INSERT, UPDATE, or DELETE
statement with the given parameters |
SQLOperations |
SQLOperations.updateWithParams(String sql,
JsonArray params,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given prepared statement which may be an
INSERT, UPDATE, or DELETE
statement with the given parameters |
| Modifier and Type | Interface and Description |
|---|---|
interface |
StompServerHandler
STOMP server handler implements the behavior of the STOMP server when a specific event occurs.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultAbortHandler
STOMP compliant actions executed when receiving a
ABORT frame. |
class |
DefaultAckHandler
STOMP compliant actions executed when receiving a
ACK frame. |
class |
DefaultBeginHandler
STOMP compliant actions executed when receiving a
BEGIN frame. |
class |
DefaultCommitHandler
STOMP compliant actions executed when receiving a
COMMIT frame. |
class |
DefaultConnectHandler
STOMP compliant actions executed when receiving a
CONNECT frame. |
class |
DefaultNackHandler
STOMP compliant actions executed when receiving a
NACK sf.frame(). |
class |
DefaultSendHandler
STOMP compliant actions executed when receiving a
SEND sf.frame(). |
class |
DefaultSubscribeHandler
STOMP compliant actions executed when receiving a
SUBSCRIBE frame. |
class |
DefaultUnsubscribeHandler
STOMP compliant actions executed when receiving a
UNSUBSCRIBE frame. |
| Modifier and Type | Method and Description |
|---|---|
Handler<ServerWebSocket> |
StompServer.webSocketHandler()
Gets the
Handler able to manage web socket connections. |
| Modifier and Type | Method and Description |
|---|---|
StompClientConnection |
StompClientConnection.abort(String id,
Handler<AsyncResult<Frame>> receiptHandler)
Aborts a transaction.
|
StompClientConnection |
StompClientConnection.abort(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Sends an acknowledgement for a specific message.
|
StompClientConnection |
StompClientConnection.ack(String id,
String txId,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Begins a transaction.
|
StompClientConnection |
StompClientConnection.beginTX(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Commits a transaction.
|
StompClientConnection |
StompClientConnection.commit(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Disconnects the client.
|
StompClientConnection |
StompClientConnection.disconnect(Handler<AsyncResult<Frame>> receiptHandler)
Disconnects the client.
|
StompServerHandler |
StompServerHandler.disconnectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
DISCONNECT frame is received. |
StompClient |
StompClient.errorFrameHandler(Handler<Frame> handler)
A general error frame handler.
|
StompClientConnection |
StompClientConnection.errorHandler(Handler<Frame> handler)
Sets a handler notified when an
ERROR frame is received by the client. |
StompClientConnection |
StompClientConnection.exceptionHandler(Handler<Throwable> exceptionHandler)
Configures the exception handler notified upon TCP-level errors.
|
StompClient |
StompClient.exceptionHandler(Handler<Throwable> handler)
Sets an exception handler notified for TCP-level errors.
|
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<AsyncResult<Frame>> receiptHandler)
Sends a non-acknowledgement for the given message.
|
StompClientConnection |
StompClientConnection.nack(String id,
String txId,
Handler<AsyncResult<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(StompServerConnection connection,
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.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that get notified when a STOMP frame is received by the client.
|
StompClient |
StompClient.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that gets notified when a STOMP frame is received by the client.
|
StompServerHandler |
StompServerHandler.receivedFrameHandler(Handler<ServerFrame> handler)
Configures a handler that get notified when a STOMP frame is received by the server.
|
StompClientConnection |
StompClientConnection.send(Frame frame,
Handler<AsyncResult<Frame>> receiptHandler)
Sends the given frame to the server.
|
StompClientConnection |
StompClientConnection.send(Map<String,String> headers,
Buffer body,
Handler<AsyncResult<Frame>> receiptHandler)
Sends a
SEND frame to the server. |
StompClientConnection |
StompClientConnection.send(String destination,
Buffer body,
Handler<AsyncResult<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<AsyncResult<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. |
Future<String> |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
Future<String> |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<AsyncResult<String>> 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<AsyncResult<Frame>> receiptHandler)
Un-subscribes from the given destination.
|
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Map<String,String> headers,
Handler<AsyncResult<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. |
StompClientConnection |
StompClientConnection.writingFrameHandler(Handler<Frame> handler)
Configures a handler notified when a frame is going to be written on the wire.
|
StompClient |
StompClient.writingFrameHandler(Handler<Frame> handler)
Configures a writing handler that gets notified when a STOMP frame is written on the wire.
|
StompServer |
StompServer.writingFrameHandler(Handler<ServerFrame> handler)
Configures the handler that is invoked every time a frame is going to be written to the "wire".
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
HandlerReceiverAdaptor<T>
Deprecated.
This project will be removed with Quasar being effectively abandoned
|
| Modifier and Type | Method and Description |
|---|---|
static <T> Handler<T> |
Sync.fiberHandler(Handler<T> handler)
Deprecated.
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)
Deprecated.
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)
Deprecated.
Receive a single event from a handler synchronously.
|
static <T> T |
Sync.awaitEvent(java.util.function.Consumer<Handler<T>> consumer,
long timeout)
Deprecated.
Receive a single event from a handler synchronously.
|
static <T> T |
Sync.awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer)
Deprecated.
Invoke an asynchronous operation and obtain the result synchronous.
|
static <T> T |
Sync.awaitResult(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer,
long timeout)
Deprecated.
Invoke an asynchronous operation and obtain the result synchronous.
|
| Modifier and Type | Method and Description |
|---|---|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it completes the async operation.
When the returned handler is called back with a failed result it fails the test with the cause of the failure.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
Handler<Throwable> |
TestContext.exceptionHandler() |
| Modifier and Type | Method and Description |
|---|---|
TestSuite |
TestSuite.after(Handler<TestContext> callback)
Set a callback executed after the tests.
|
TestSuite |
TestSuite.afterEach(Handler<TestContext> callback)
Set a callback executed after each test and before the suite
after callback. |
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
TestSuite |
TestSuite.before(Handler<TestContext> callback)
Set a callback executed before the tests.
|
TestSuite |
TestSuite.beforeEach(Handler<TestContext> callback)
Set a callback executed before each test and after the suite
before callback. |
static TestCase |
TestCase.create(String name,
Handler<TestContext> testCase)
Create a test case.
|
void |
Completion.handler(Handler<AsyncResult<T>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
TestSuite |
TestSuite.test(String name,
Handler<TestContext> testCase)
Add a new test case to the suite.
|
TestSuite |
TestSuite.test(String name,
int repeat,
Handler<TestContext> testCase)
Add a new test case to the suite.
|
TestContext |
TestContext.verify(Handler<Void> block)
Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.
|
| 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 | Interface and Description |
|---|---|
interface |
Router
A router receives request from an
HttpServer and routes it to the first matching
Route that it contains. |
| Modifier and Type | Method and Description |
|---|---|
int |
RoutingContext.addBodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
int |
RoutingContext.addEndHandler(Handler<AsyncResult<Void>> handler)
Add an end handler for the request/response context.
|
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.
|
default RoutingContext |
RoutingContext.end(Buffer buffer,
Handler<AsyncResult<Void>> handler)
|
default RoutingContext |
RoutingContext.end(Handler<AsyncResult<Void>> handler)
|
default RoutingContext |
RoutingContext.end(String chunk,
Handler<AsyncResult<Void>> handler)
|
Router |
Router.errorHandler(int statusCode,
Handler<RoutingContext> errorHandler)
Specify an handler to handle an error for a particular status code.
|
Route |
Route.failureHandler(Handler<RoutingContext> failureHandler)
Append a failure handler to the route failure handlers list.
|
Route |
Route.handler(Handler<RoutingContext> requestHandler)
Append a request handler to the route handlers list.
|
default RoutingContext |
RoutingContext.json(Object json,
Handler<AsyncResult<Void>> handler)
|
Router |
Router.modifiedHandler(Handler<Router> handler)
When a Router routes are changed this handler is notified.
|
default RoutingContext |
RoutingContext.redirect(String url,
Handler<AsyncResult<Void>> handler)
|
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
RouterFactory.getValidationFailureHandler()
Deprecated.
Router Factory won't manage the validation errors anymore. You must use
Router.errorHandler(int, Handler) with 400 error |
| Modifier and Type | Method and Description |
|---|---|
RouterFactory |
RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
Add global handler to be applied prior to
Router being generated. |
RouterFactory |
RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
Mount to paths that have to follow a security schema a security handler
|
RouterFactory |
RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
You must use
Router.errorHandler(int, Handler) with 501 error |
RouterFactory |
RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
Router Factory won't manage the validation errors anymore. You must use
Router.errorHandler(int, Handler) with 400 error |
| Modifier and Type | Interface and Description |
|---|---|
interface |
OpenAPI3RequestValidationHandler
Deprecated.
You should use the new module vertx-web-openapi
|
| Modifier and Type | Method and Description |
|---|---|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addFailureHandlerByOperationId(String operationId,
Handler<RoutingContext> failureHandler)
Deprecated.
Add a failure handler by operation_id field in Operation object
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addHandlerByOperationId(String operationId,
Handler<RoutingContext> handler)
Deprecated.
Add an handler by operation_id field in Operation object
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String securitySchemaName,
String scopeName,
Handler<RoutingContext> handler)
Deprecated.
Add a particular scope validator.
|
static void |
OpenAPI3RouterFactory.create(Vertx vertx,
String url,
Handler<AsyncResult<OpenAPI3RouterFactory>> handler)
Deprecated.
Create a new OpenAPI3RouterFactory
|
static void |
OpenAPI3RouterFactory.create(Vertx vertx,
String url,
List<JsonObject> auth,
Handler<AsyncResult<OpenAPI3RouterFactory>> handler)
Deprecated.
Create a new OpenAPI3RouterFactory
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
RouteToEBServiceHandler
Handler that proxy the request to an event bus endpoint, waits for the reply and then writes the HTTP response.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
HTTPRequestValidationHandler
Deprecated.
You should use the new module vertx-web-openapi
|
| Modifier and Type | Method and Description |
|---|---|
void |
HttpRequest.send(Handler<AsyncResult<HttpResponse<T>>> handler)
Send a request, the
handler will receive the response as an HttpResponse. |
void |
HttpRequest.sendBuffer(Buffer body,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body buffer. |
void |
HttpRequest.sendForm(MultiMap body,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body multimap encoded as form and the content type
set to application/x-www-form-urlencoded. |
void |
HttpRequest.sendForm(MultiMap body,
String charset,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body multimap encoded as form and the content type
set to application/x-www-form-urlencoded. |
void |
HttpRequest.sendJson(Object body,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body object encoded as json and the content type
set to application/json. |
void |
HttpRequest.sendJsonObject(JsonObject body,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body object encoded as json and the content type
set to application/json. |
void |
HttpRequest.sendMultipartForm(MultipartForm body,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body multimap encoded as form and the content type
set to multipart/form-data. |
void |
HttpRequest.sendStream(ReadStream<Buffer> body,
Handler<AsyncResult<HttpResponse<T>>> handler)
Like
HttpRequest.send(Handler) but with an HTTP request body stream. |
| Modifier and Type | Method and Description |
|---|---|
default void |
CacheStore.delete(io.vertx.ext.web.client.impl.cache.CacheKey key,
Handler<AsyncResult<Void>> handler)
Delete all variations of a key from the cache.
|
default void |
CacheStore.flush(Handler<AsyncResult<Void>> handler)
Delete all entries from the cache.
|
default void |
CacheStore.get(io.vertx.ext.web.client.impl.cache.CacheKey key,
Handler<AsyncResult<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>> handler)
Retrieve a cached response.
|
default void |
CacheStore.set(io.vertx.ext.web.client.impl.cache.CacheKey key,
io.vertx.ext.web.client.impl.cache.CachedHttpResponse response,
Handler<AsyncResult<io.vertx.ext.web.client.impl.cache.CachedHttpResponse>> handler)
Add a response in the cache with the given key.
|
| Modifier and Type | Method and Description |
|---|---|
void |
BodyCodec.create(Handler<AsyncResult<BodyStream<T>>> handler)
Create the
BodyStream. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
BodyStream<T>
The body stream decodes a
WriteStream into the a T instance. |
| Modifier and Type | Method and Description |
|---|---|
default void |
TemplateEngine.render(JsonObject context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render the template.
|
void |
TemplateEngine.render(Map<String,Object> context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render the template.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
APIKeyHandler
An authentication handler that provides API Key support.
|
interface |
AuthorizationHandler
Base interface for authorization handlers that provide authorization support.
|
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 |
ChainAuthHandler
An auth handler that chains to a sequence of handlers.
|
interface |
CorsHandler
A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
|
interface |
CSPHandler
Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of
attacks, including Cross Site Scripting (XSS) and data injection attacks.
|
interface |
CSRFHandler
This handler adds a CSRF token to requests which mutate state.
|
interface |
DigestAuthHandler
An auth handler that provides HTTP Basic Authentication support.
|
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 |
HSTSHandler
HTTP Strict Transport Security (HSTS) RFC6797.
|
interface |
JWTAuthHandler
An auth handler that provides JWT Authentication support.
|
interface |
LoggerHandler
A handler which logs request information to the Vert.x logger.
|
interface |
MethodOverrideHandler |
interface |
MultiTenantHandler
A handler which selectively executes another handler if a precondition is met.
|
interface |
OAuth2AuthHandler
An auth handler that provides OAuth2 Authentication support.
|
interface |
OtpAuthHandler
An auth handler that provides One Time Password (Multi-Factor) Authentication support.
|
interface |
RedirectAuthHandler
An auth handler that's used to handle auth by redirecting user to a custom login page.
|
interface |
ResponseContentTypeHandler
A handler which sets the response content type automatically according to the best
Accept header match. |
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 |
SimpleAuthenticationHandler
A user customizable authentication handler.
|
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 |
WebAuthnHandler
An auth handler that provides FIDO2 WebAuthN Relay Party support.
|
interface |
XFrameHandler
The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render
a page in a
<frame>, <iframe>, <embed> or <object>. |
| Modifier and Type | Method and Description |
|---|---|
MultiTenantHandler |
MultiTenantHandler.addDefaultHandler(Handler<RoutingContext> handler)
Add a default handler for the case when no tenant was matched.
|
MultiTenantHandler |
MultiTenantHandler.addTenantHandler(String tenant,
Handler<RoutingContext> handler)
Add a handler for a given tenant to this handler.
|
default SessionHandler |
SessionHandler.flush(RoutingContext ctx,
boolean ignoreStatus,
Handler<AsyncResult<Void>> handler)
Flush a context session earlier to the store, this will allow the end user to have full control on the event of
a failure at the store level.
|
default SessionHandler |
SessionHandler.flush(RoutingContext ctx,
Handler<AsyncResult<Void>> handler)
Flush a context session earlier to the store, this will allow the end user to have full control on the event of
a failure at the store level.
|
default SessionHandler |
SessionHandler.setUser(RoutingContext context,
User user,
Handler<AsyncResult<Void>> handler)
Set the user for the session
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ApolloWSConnectionInitEvent |
interface |
ApolloWSHandler
A handler for GraphQL requests sent over Apollo's
subscriptions-transport-ws transport. |
interface |
GraphiQLHandler
A
Route handler for GraphiQL resources. |
interface |
GraphQLHandler
A
Route handler for GraphQL requests. |
| Modifier and Type | Method and Description |
|---|---|
ApolloWSHandler |
ApolloWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>> config)
Set a callback to invoke before executing a GraphQL query.
|
GraphQLHandler |
GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> config)
Set a callback to invoke before executing a GraphQL query.
|
ApolloWSHandler |
ApolloWSHandler.connectionHandler(Handler<ServerWebSocket> connectionHandler)
Customize the connection
Handler. |
ApolloWSHandler |
ApolloWSHandler.connectionInitHandler(Handler<ApolloWSConnectionInitEvent> connectionInitHandler)
Customize the connection init
Handler. |
ApolloWSHandler |
ApolloWSHandler.endHandler(Handler<ServerWebSocket> endHandler)
Customize the end
Handler. |
ApolloWSHandler |
ApolloWSHandler.messageHandler(Handler<ApolloWSMessage> messageHandler)
Customize the message
Handler. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
ConnectionInitEvent |
interface |
GraphQLWSHandler
A handler for the GraphQL over WebSocket Protocol.
|
| Modifier and Type | Method and Description |
|---|---|
GraphQLWSHandler |
GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> config)
Set a callback to invoke before executing a GraphQL query.
|
GraphQLWSHandler |
GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent> connectionInitHandler)
Customize the connection init
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 |
|---|---|
Router |
SockJSHandler.bridge(AuthorizationProvider authorizationProvider,
SockJSBridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(SockJSBridgeOptions) but specifying a handler
that will receive bridge events. |
default Router |
SockJSHandler.bridge(SockJSBridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(SockJSBridgeOptions) but specifying a handler
that will receive bridge events. |
SockJSSocket |
SockJSSocket.closeHandler(Handler<Void> closeHandler) |
SockJSSocket |
SockJSSocket.drainHandler(Handler<Void> handler) |
SockJSSocket |
SockJSSocket.endHandler(Handler<Void> endHandler) |
SockJSSocket |
SockJSSocket.exceptionHandler(Handler<Throwable> handler) |
SockJSSocket |
SockJSSocket.handler(Handler<Buffer> handler) |
Router |
SockJSHandler.socketHandler(Handler<SockJSSocket> handler)
Set a SockJS socket handler.
|
default void |
SockJSSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler) |
default void |
SockJSSocket.write(String data,
Handler<AsyncResult<Void>> handler) |
| Modifier and Type | Method and Description |
|---|---|
static void |
RouterBuilder.create(Vertx vertx,
String url,
Handler<AsyncResult<RouterBuilder>> handler)
Like
this#create(Vertx, String) |
static void |
RouterBuilder.create(Vertx vertx,
String url,
OpenAPILoaderOptions options,
Handler<AsyncResult<RouterBuilder>> handler)
Like
this#create(Vertx, String, OpenAPILoaderOptions) |
Operation |
Operation.failureHandler(Handler<RoutingContext> handler)
Mount a failure handler for this operation
|
Operation |
Operation.handler(Handler<RoutingContext> handler)
Mount an handler for this operation
|
RouterBuilder |
RouterBuilder.rootHandler(Handler<RoutingContext> rootHandler)
Add global handler to be applied prior to
Router being generated. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
ProxyHandler |
| Modifier and Type | Method and Description |
|---|---|
default SessionStore |
SessionStore.clear(Handler<AsyncResult<Void>> resultHandler)
Remove all sessions from the store.
|
default SessionStore |
SessionStore.delete(String id,
Handler<AsyncResult<Void>> resultHandler)
Delete the session with the specified ID.
|
default SessionStore |
SessionStore.get(String cookieValue,
Handler<AsyncResult<Session>> resultHandler)
Get the session with the specified ID.
|
default SessionStore |
SessionStore.put(Session session,
Handler<AsyncResult<Void>> resultHandler)
Add a session with the specified ID.
|
default SessionStore |
SessionStore.size(Handler<AsyncResult<Integer>> resultHandler)
Get the number of sessions in the store.
|
| Modifier and Type | Method and Description |
|---|---|
VertxServer |
VertxServer.shutdown(Handler<AsyncResult<Void>> completionHandler) |
VertxServer |
VertxServer.start(Handler<AsyncResult<Void>> completionHandler) |
VertxChannelBuilder |
VertxChannelBuilder.useSsl(Handler<ClientOptionsBase> handler) |
VertxServerBuilder |
VertxServerBuilder.useSsl(Handler<HttpServerOptions> handler) |
| Modifier and Type | Method and Description |
|---|---|
GrpcClientRequest<Req,Resp> |
GrpcClientRequest.drainHandler(Handler<Void> handler) |
GrpcClientResponse<Req,Resp> |
GrpcClientResponse.endHandler(Handler<Void> handler) |
GrpcClientResponse<Req,Resp> |
GrpcClientResponse.errorHandler(Handler<GrpcError> handler) |
GrpcClientResponse<Req,Resp> |
GrpcClientResponse.exceptionHandler(Handler<Throwable> handler) |
GrpcClientRequest<Req,Resp> |
GrpcClientRequest.exceptionHandler(Handler<Throwable> handler) |
GrpcClientResponse<Req,Resp> |
GrpcClientResponse.handler(Handler<Resp> handler) |
GrpcClientResponse<Req,Resp> |
GrpcClientResponse.messageHandler(Handler<GrpcMessage> handler) |
| Modifier and Type | Method and Description |
|---|---|
GrpcWriteStream<T> |
GrpcWriteStream.drainHandler(Handler<Void> handler) |
void |
GrpcWriteStream.end(Handler<AsyncResult<Void>> handler) |
default void |
GrpcWriteStream.end(T data,
Handler<AsyncResult<Void>> handler) |
GrpcReadStream<T> |
GrpcReadStream.endHandler(Handler<Void> handler) |
GrpcReadStream<T> |
GrpcReadStream.errorHandler(Handler<GrpcError> handler)
Set a handler to be notified with gRPC errors.
|
GrpcReadStream<T> |
GrpcReadStream.exceptionHandler(Handler<Throwable> handler) |
GrpcWriteStream<T> |
GrpcWriteStream.exceptionHandler(Handler<Throwable> handler) |
GrpcReadStream<T> |
GrpcReadStream.handler(Handler<T> handler) |
GrpcReadStream<T> |
GrpcReadStream.messageHandler(Handler<GrpcMessage> handler)
Set a handler to be notified with incoming encoded messages.
|
default void |
GrpcReadStream.pipeTo(WriteStream<T> dst,
Handler<AsyncResult<Void>> handler) |
void |
GrpcWriteStream.write(T t,
Handler<AsyncResult<Void>> handler) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
GrpcServer
A gRPC server based on Vert.x HTTP server.
|
| Modifier and Type | Method and Description |
|---|---|
GrpcServer |
GrpcServer.callHandler(Handler<GrpcServerRequest<Buffer,Buffer>> handler)
Set a call handler that handles any call made to the server.
|
<Req,Resp> GrpcServer |
GrpcServer.callHandler(io.grpc.MethodDescriptor<Req,Resp> methodDesc,
Handler<GrpcServerRequest<Req,Resp>> handler)
Set a service method call handler that handles any call call made to the server for the
MethodDescriptor service method. |
GrpcServerResponse<Req,Resp> |
GrpcServerResponse.drainHandler(Handler<Void> handler) |
GrpcServerRequest<Req,Resp> |
GrpcServerRequest.endHandler(Handler<Void> endHandler) |
GrpcServerRequest<Req,Resp> |
GrpcServerRequest.errorHandler(Handler<GrpcError> handler) |
GrpcServerRequest<Req,Resp> |
GrpcServerRequest.exceptionHandler(Handler<Throwable> handler) |
GrpcServerResponse<Req,Resp> |
GrpcServerResponse.exceptionHandler(Handler<Throwable> handler) |
GrpcServerRequest<Req,Resp> |
GrpcServerRequest.handler(Handler<Req> handler) |
GrpcServerRequest<Req,Resp> |
GrpcServerRequest.messageHandler(Handler<GrpcMessage> handler) |
| Modifier and Type | Method and Description |
|---|---|
WriteStream<T> |
GrpcWriteStream.drainHandler(Handler<Void> hndlr) |
void |
GrpcWriteStream.end(Handler<AsyncResult<Void>> hndlr) |
WriteStream<T> |
GrpcWriteStream.exceptionHandler(Handler<Throwable> hndlr) |
static <I,O> ReadStream<O> |
ClientCalls.manyToMany(io.vertx.core.impl.ContextInternal ctx,
Handler<WriteStream<I>> requestHandler,
java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate) |
static <I,O> Future<O> |
ClientCalls.manyToOne(io.vertx.core.impl.ContextInternal ctx,
Handler<WriteStream<I>> requestHandler,
java.util.function.Function<io.grpc.stub.StreamObserver<O>,io.grpc.stub.StreamObserver<I>> delegate) |
void |
GrpcWriteStream.write(T data,
Handler<AsyncResult<Void>> hndlr) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
HttpProxy
Handles the HTTP reverse proxy logic between the user agent and the origin.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SchemaRouter.resolveRef(JsonPointer pointer,
JsonPointer scope,
SchemaParser schemaParser,
Handler<AsyncResult<Schema>> handler)
Deprecated.
Like
SchemaRouter.resolveRef(JsonPointer, JsonPointer, SchemaParser) but with a direct callback. |
| Modifier and Type | Method and Description |
|---|---|
void |
SchemaRouterImpl.resolveRef(JsonPointer pointer,
JsonPointer scope,
SchemaParser schemaParser,
Handler<AsyncResult<Schema>> handler) |
| Modifier and Type | Method and Description |
|---|---|
<T> Handler<AsyncResult<T>> |
VertxTestContext.completing()
Deprecated.
Use
VertxTestContext.succeedingThenComplete() instead. |
<T> Handler<AsyncResult<T>> |
VertxTestContext.failing()
Deprecated.
Use
VertxTestContext.failingThenComplete() or VertxTestContext.failing(Handler), for example
failing(e -> checkpoint.flag()), failing(e -> { more testing code }), or
failing(e -> {}). |
<T> Handler<AsyncResult<T>> |
VertxTestContext.failing(Handler<Throwable> nextHandler)
Create an asynchronous result handler that expects a failure, and passes the exception to another handler.
|
<T> Handler<AsyncResult<T>> |
VertxTestContext.failingThenComplete()
Create an asynchronous result handler that expects a failure to then complete the test context.
|
<T> Handler<AsyncResult<T>> |
VertxTestContext.succeeding()
Deprecated.
Use
VertxTestContext.succeedingThenComplete() or VertxTestContext.succeeding(Handler), for example
succeeding(value -> checkpoint.flag()), succeeding(value -> { more testing code }), or
succeeding(value -> {}). |
<T> Handler<AsyncResult<T>> |
VertxTestContext.succeeding(Handler<T> nextHandler)
Create an asynchronous result handler that expects a success, and passes the value to another handler.
|
<T> Handler<AsyncResult<T>> |
VertxTestContext.succeedingThenComplete()
Create an asynchronous result handler that expects a success to then complete the test context.
|
| Modifier and Type | Method and Description |
|---|---|
<T> Handler<AsyncResult<T>> |
VertxTestContext.failing(Handler<Throwable> nextHandler)
Create an asynchronous result handler that expects a failure, and passes the exception to another handler.
|
<T> Handler<AsyncResult<T>> |
VertxTestContext.succeeding(Handler<T> nextHandler)
Create an asynchronous result handler that expects a success, and passes the value to another handler.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KafkaAdminClient.alterConfigs(Map<ConfigResource,Config> configs,
Handler<AsyncResult<Void>> completionHandler)
Update the configuration for the specified resources with the default options
|
void |
KafkaAdminClient.alterConsumerGroupOffsets(String groupId,
Map<TopicPartition,OffsetAndMetadata> offsets,
Handler<AsyncResult<Void>> completionHandler)
Alter committed offsets for a set of partitions in a consumer group.
|
void |
KafkaAdminClient.close(Handler<AsyncResult<Void>> handler)
Close the admin client
|
void |
KafkaAdminClient.close(long timeout,
Handler<AsyncResult<Void>> handler)
Close the admin client
|
void |
KafkaAdminClient.createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Create the ACL rules.
|
void |
KafkaAdminClient.createPartitions(Map<String,NewPartitions> partitions,
Handler<AsyncResult<Void>> completionHandler)
Creates a batch of new partitions in the Kafka topic
|
void |
KafkaAdminClient.createTopics(List<NewTopic> topics,
Handler<AsyncResult<Void>> completionHandler)
Creates a batch of new Kafka topics
|
void |
KafkaAdminClient.deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Delete the ACL rules.
|
void |
KafkaAdminClient.deleteConsumerGroupOffsets(String groupId,
Set<TopicPartition> partitions,
Handler<AsyncResult<Void>> completionHandler)
Delete committed offsets for a set of partitions in a consumer group.
|
void |
KafkaAdminClient.deleteConsumerGroups(List<String> groupIds,
Handler<AsyncResult<Void>> completionHandler)
Delete consumer groups from the cluster.
|
void |
KafkaAdminClient.deleteRecords(Map<TopicPartition,org.apache.kafka.clients.admin.RecordsToDelete> recordsToDelete,
Handler<AsyncResult<Map<TopicPartition,org.apache.kafka.clients.admin.DeletedRecords>>> completionHandler)
Delete records from a topic partition.
|
void |
KafkaAdminClient.deleteTopics(List<String> topicNames,
Handler<AsyncResult<Void>> completionHandler)
Deletes a batch of Kafka topics
|
void |
KafkaAdminClient.describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Describe the ACL rules.
|
void |
KafkaAdminClient.describeCluster(DescribeClusterOptions options,
Handler<AsyncResult<ClusterDescription>> completionHandler)
Like
KafkaAdminClient.describeCluster(Handler) but allows customized options. |
void |
KafkaAdminClient.describeCluster(Handler<AsyncResult<ClusterDescription>> completionHandler)
Describe the nodes in the cluster with the default options
|
void |
KafkaAdminClient.describeConfigs(List<ConfigResource> configResources,
Handler<AsyncResult<Map<ConfigResource,Config>>> completionHandler)
Get the configuration for the specified resources with the default options
|
void |
KafkaAdminClient.describeConsumerGroups(List<String> groupIds,
DescribeConsumerGroupsOptions options,
Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)
Like
KafkaAdminClient.describeConsumerGroups(List, Handler) but allows customized options |
void |
KafkaAdminClient.describeConsumerGroups(List<String> groupIds,
Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)
Describe some group ids in the cluster, with the default options
|
void |
KafkaAdminClient.describeLogDirs(List<Integer> brokers,
Handler<AsyncResult<Map<Integer,Map<String,org.apache.kafka.clients.admin.LogDirDescription>>>> completionHandler)
Query the information of all log directories on the given set of brokers
|
void |
KafkaAdminClient.describeTopics(List<String> topicNames,
DescribeTopicsOptions options,
Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)
Like
KafkaAdminClient.describeTopics(List, Handler) but allows for customised otions |
void |
KafkaAdminClient.describeTopics(List<String> topicNames,
Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)
Describe some topics in the cluster, with the default options.
|
default void |
KafkaAdminClient.listConsumerGroupOffsets(String groupId,
Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)
List the consumer group offsets available in the cluster.
|
void |
KafkaAdminClient.listConsumerGroupOffsets(String groupId,
ListConsumerGroupOffsetsOptions options,
Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)
List the consumer group offsets available in the cluster.
|
void |
KafkaAdminClient.listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)
Get the the consumer groups available in the cluster with the default options
|
void |
KafkaAdminClient.listOffsets(Map<TopicPartition,OffsetSpec> topicPartitionOffsets,
Handler<AsyncResult<Map<TopicPartition,ListOffsetsResultInfo>>> completionHandler)
List the offsets available for a set of partitions.
|
void |
KafkaAdminClient.listTopics(Handler<AsyncResult<Set<String>>> completionHandler)
List the topics available in the cluster with the default options.
|
| Modifier and Type | Method and Description |
|---|---|
KafkaReadStream<K,V> |
KafkaReadStream.assign(Set<org.apache.kafka.common.TopicPartition> partitions,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a set of partitions to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assign(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a list of partition to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assign(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a partition to this consumer.
|
KafkaReadStream<K,V> |
KafkaReadStream.assignment(Handler<AsyncResult<Set<org.apache.kafka.common.TopicPartition>>> handler)
Get the set of partitions currently assigned to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)
Get the set of partitions currently assigned to this consumer.
|
KafkaReadStream<K,V> |
KafkaReadStream.batchHandler(Handler<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>> handler)
Set the handler that will be called when a new batch of records is
returned from Kafka.
|
KafkaConsumer<K,V> |
KafkaConsumer.batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)
Set the handler to be used when batches of messages are fetched
from the Kafka server.
|
void |
KafkaReadStream.beginningOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions,
Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,Long>>> handler)
Get the first offset for the given partitions.
|
void |
KafkaConsumer.beginningOffsets(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Map<TopicPartition,Long>>> handler)
Get the first offset for the given partitions.
|
void |
KafkaReadStream.beginningOffsets(org.apache.kafka.common.TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the first offset for the given partition.
|
void |
KafkaConsumer.beginningOffsets(TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the first offset for the given partitions.
|
void |
KafkaReadStream.close(Handler<AsyncResult<Void>> completionHandler)
Close the stream
|
void |
KafkaConsumer.close(Handler<AsyncResult<Void>> completionHandler)
Close the consumer
|
void |
KafkaReadStream.commit(Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>> completionHandler)
Commit current offsets for all the subscribed list of topics and partition.
|
void |
KafkaConsumer.commit(Handler<AsyncResult<Void>> completionHandler)
Commit current offsets for all the subscribed list of topics and partition.
|
void |
KafkaReadStream.commit(Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata> offsets,
Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndMetadata>>> completionHandler)
Commit the specified offsets for the specified list of topics and partitions to Kafka.
|
void |
KafkaConsumer.commit(Map<TopicPartition,OffsetAndMetadata> offsets,
Handler<AsyncResult<Map<TopicPartition,OffsetAndMetadata>>> completionHandler)
Commit the specified offsets for the specified list of topics and partitions to Kafka.
|
void |
KafkaReadStream.committed(org.apache.kafka.common.TopicPartition topicPartition,
Handler<AsyncResult<org.apache.kafka.clients.consumer.OffsetAndMetadata>> handler)
Get the last committed offset for the given partition (whether the commit happened by this process or another).
|
void |
KafkaConsumer.committed(TopicPartition topicPartition,
Handler<AsyncResult<OffsetAndMetadata>> handler)
Get the last committed offset for the given partition (whether the commit happened by this process or another).
|
KafkaReadStream<K,V> |
KafkaReadStream.endHandler(Handler<Void> endHandler) |
KafkaConsumer<K,V> |
KafkaConsumer.endHandler(Handler<Void> endHandler) |
void |
KafkaReadStream.endOffsets(Set<org.apache.kafka.common.TopicPartition> topicPartitions,
Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,Long>>> handler)
Get the last offset for the given partitions.
|
void |
KafkaConsumer.endOffsets(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Map<TopicPartition,Long>>> handler)
Get the last offset for the given partitions.
|
void |
KafkaReadStream.endOffsets(org.apache.kafka.common.TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the last offset for the given partition.
|
void |
KafkaConsumer.endOffsets(TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the last offset for the given partition.
|
KafkaReadStream<K,V> |
KafkaReadStream.exceptionHandler(Handler<Throwable> handler) |
KafkaConsumer<K,V> |
KafkaConsumer.exceptionHandler(Handler<Throwable> handler) |
KafkaReadStream<K,V> |
KafkaReadStream.handler(Handler<org.apache.kafka.clients.consumer.ConsumerRecord<K,V>> handler) |
KafkaConsumer<K,V> |
KafkaConsumer.handler(Handler<KafkaConsumerRecord<K,V>> handler) |
KafkaReadStream<K,V> |
KafkaReadStream.listTopics(Handler<AsyncResult<Map<String,List<org.apache.kafka.common.PartitionInfo>>>> handler)
Get metadata about partitions for all topics that the user is authorized to view.
|
KafkaConsumer<K,V> |
KafkaConsumer.listTopics(Handler<AsyncResult<Map<String,List<PartitionInfo>>>> handler)
Get metadata about partitions for all topics that the user is authorized to view.
|
void |
KafkaReadStream.offsetsForTimes(Map<org.apache.kafka.common.TopicPartition,Long> topicPartitionTimestamps,
Handler<AsyncResult<Map<org.apache.kafka.common.TopicPartition,org.apache.kafka.clients.consumer.OffsetAndTimestamp>>> handler)
Look up the offsets for the given partitions by timestamp.
|
void |
KafkaConsumer.offsetsForTimes(Map<TopicPartition,Long> topicPartitionTimestamps,
Handler<AsyncResult<Map<TopicPartition,OffsetAndTimestamp>>> handler)
Look up the offsets for the given partitions by timestamp.
|
void |
KafkaReadStream.offsetsForTimes(org.apache.kafka.common.TopicPartition topicPartition,
long timestamp,
Handler<AsyncResult<org.apache.kafka.clients.consumer.OffsetAndTimestamp>> handler)
* Look up the offset for the given partition by timestamp.
|
void |
KafkaConsumer.offsetsForTimes(TopicPartition topicPartition,
Long timestamp,
Handler<AsyncResult<OffsetAndTimestamp>> handler)
Look up the offset for the given partition by timestamp.
|
KafkaReadStream<K,V> |
KafkaReadStream.partitionsAssignedHandler(Handler<Set<org.apache.kafka.common.TopicPartition>> handler)
Set the handler called when topic partitions are assigned to the consumer
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)
Set the handler called when topic partitions are assigned to the consumer
|
KafkaReadStream<K,V> |
KafkaReadStream.partitionsFor(String topic,
Handler<AsyncResult<List<org.apache.kafka.common.PartitionInfo>>> handler)
Get metadata about the partitions for a given topic.
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsFor(String topic,
Handler<AsyncResult<List<PartitionInfo>>> handler)
Get metadata about the partitions for a given topic.
|
KafkaReadStream<K,V> |
KafkaReadStream.partitionsRevokedHandler(Handler<Set<org.apache.kafka.common.TopicPartition>> handler)
Set the handler called when topic partitions are revoked to the consumer
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)
Set the handler called when topic partitions are revoked to the consumer
|
KafkaReadStream<K,V> |
KafkaReadStream.pause(Set<org.apache.kafka.common.TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.pause(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.pause(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partition.
|
void |
KafkaReadStream.paused(Handler<AsyncResult<Set<org.apache.kafka.common.TopicPartition>>> handler)
Get the set of partitions that were previously paused by a call to
KafkaReadStream.pause(Set). |
void |
KafkaConsumer.paused(Handler<AsyncResult<Set<TopicPartition>>> handler)
Get the set of partitions that were previously paused by a call to pause(Set).
|
void |
KafkaReadStream.poll(java.time.Duration timeout,
Handler<AsyncResult<org.apache.kafka.clients.consumer.ConsumerRecords<K,V>>> handler)
Executes a poll for getting messages from Kafka.
|
void |
KafkaConsumer.poll(java.time.Duration timeout,
Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)
Executes a poll for getting messages from Kafka.
|
void |
KafkaReadStream.position(org.apache.kafka.common.TopicPartition partition,
Handler<AsyncResult<Long>> handler)
Get the offset of the next record that will be fetched (if a record with that offset exists).
|
void |
KafkaConsumer.position(TopicPartition partition,
Handler<AsyncResult<Long>> handler)
Get the offset of the next record that will be fetched (if a record with that offset exists).
|
KafkaReadStream<K,V> |
KafkaReadStream.resume(Set<org.apache.kafka.common.TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partitions which have been paused with pause.
|
KafkaConsumer<K,V> |
KafkaConsumer.resume(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partitions which have been paused with pause.
|
KafkaConsumer<K,V> |
KafkaConsumer.resume(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partition which have been paused with pause.
|
KafkaReadStream<K,V> |
KafkaReadStream.seek(org.apache.kafka.common.TopicPartition topicPartition,
long offset,
Handler<AsyncResult<Void>> completionHandler)
Overrides the fetch offsets that the consumer will use on the next poll.
|
KafkaConsumer<K,V> |
KafkaConsumer.seek(TopicPartition topicPartition,
long offset,
Handler<AsyncResult<Void>> completionHandler)
Overrides the fetch offsets that the consumer will use on the next poll.
|
KafkaReadStream<K,V> |
KafkaReadStream.seekToBeginning(Set<org.apache.kafka.common.TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToBeginning(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToBeginning(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partition.
|
KafkaReadStream<K,V> |
KafkaReadStream.seekToEnd(Set<org.apache.kafka.common.TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToEnd(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToEnd(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partition.
|
KafkaReadStream<K,V> |
KafkaReadStream.subscribe(Pattern pattern,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(Pattern pattern,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to all topics matching specified pattern to get dynamically assigned partitions.
|
KafkaReadStream<K,V> |
KafkaReadStream.subscribe(Set<String> topics,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given list of topics to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(Set<String> topics,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given list of topics to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(String topic,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given topic to get dynamically assigned partitions.
|
KafkaReadStream<K,V> |
KafkaReadStream.subscription(Handler<AsyncResult<Set<String>>> handler)
Get the current subscription.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscription(Handler<AsyncResult<Set<String>>> handler)
Get the current subscription.
|
KafkaReadStream<K,V> |
KafkaReadStream.unsubscribe(Handler<AsyncResult<Void>> completionHandler)
Unsubscribe from topics currently subscribed with subscribe.
|
KafkaConsumer<K,V> |
KafkaConsumer.unsubscribe(Handler<AsyncResult<Void>> completionHandler)
Unsubscribe from topics currently subscribed with subscribe.
|
| Modifier and Type | Method and Description |
|---|---|
KafkaProducer<K,V> |
KafkaProducer.abortTransaction(Handler<AsyncResult<Void>> handler)
Aborts the ongoing transaction.
|
KafkaWriteStream<K,V> |
KafkaWriteStream.abortTransaction(Handler<AsyncResult<Void>> handler)
Aborts the ongoing transaction.
|
KafkaProducer<K,V> |
KafkaProducer.beginTransaction(Handler<AsyncResult<Void>> handler)
Starts a new kafka transaction.
|
KafkaWriteStream<K,V> |
KafkaWriteStream.beginTransaction(Handler<AsyncResult<Void>> handler)
Starts a new kafka transaction.
|
void |
KafkaProducer.close(Handler<AsyncResult<Void>> completionHandler)
Close the producer
|
void |
KafkaWriteStream.close(Handler<AsyncResult<Void>> completionHandler)
Close the stream
|
void |
KafkaProducer.close(long timeout,
Handler<AsyncResult<Void>> completionHandler)
Close the producer
|
void |
KafkaWriteStream.close(long timeout,
Handler<AsyncResult<Void>> completionHandler)
Close the stream
|
KafkaProducer<K,V> |
KafkaProducer.commitTransaction(Handler<AsyncResult<Void>> handler)
Commits the ongoing transaction.
|
KafkaWriteStream<K,V> |
KafkaWriteStream.commitTransaction(Handler<AsyncResult<Void>> handler)
Commits the ongoing transaction.
|
KafkaProducer<K,V> |
KafkaProducer.drainHandler(Handler<Void> handler) |
KafkaWriteStream<K,V> |
KafkaWriteStream.drainHandler(Handler<Void> handler) |
KafkaProducer<K,V> |
KafkaProducer.exceptionHandler(Handler<Throwable> handler) |
KafkaWriteStream<K,V> |
KafkaWriteStream.exceptionHandler(Handler<Throwable> handler) |
KafkaProducer<K,V> |
KafkaProducer.flush(Handler<AsyncResult<Void>> completionHandler)
Invoking this method makes all buffered records immediately available to write
|
KafkaWriteStream<K,V> |
KafkaWriteStream.flush(Handler<AsyncResult<Void>> completionHandler)
Invoking this method makes all buffered records immediately available to write
|
KafkaProducer<K,V> |
KafkaProducer.initTransactions(Handler<AsyncResult<Void>> handler)
Initializes the underlying kafka transactional producer.
|
KafkaWriteStream<K,V> |
KafkaWriteStream.initTransactions(Handler<AsyncResult<Void>> handler)
Initializes the underlying kafka transactional producer.
|
KafkaProducer<K,V> |
KafkaProducer.partitionsFor(String topic,
Handler<AsyncResult<List<PartitionInfo>>> handler)
Get the partition metadata for the give topic.
|
KafkaWriteStream<K,V> |
KafkaWriteStream.partitionsFor(String topic,
Handler<AsyncResult<List<org.apache.kafka.common.PartitionInfo>>> handler)
Get the partition metadata for the give topic.
|
KafkaProducer<K,V> |
KafkaProducer.send(KafkaProducerRecord<K,V> record,
Handler<AsyncResult<RecordMetadata>> handler)
Asynchronously write a record to a topic
|
KafkaWriteStream<K,V> |
KafkaWriteStream.send(org.apache.kafka.clients.producer.ProducerRecord<K,V> record,
Handler<AsyncResult<org.apache.kafka.clients.producer.RecordMetadata>> handler)
Asynchronously write a record to a topic
|
| Modifier and Type | Method and Description |
|---|---|
static Handler<RoutingContext> |
PrometheusScrapingHandler.create()
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
static Handler<RoutingContext> |
PrometheusScrapingHandler.create(io.micrometer.prometheus.PrometheusMeterRegistry registry)
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
static Handler<RoutingContext> |
PrometheusScrapingHandler.create(String registryName)
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
| Modifier and Type | Method and Description |
|---|---|
void |
MqttServer.close(Handler<AsyncResult<Void>> completionHandler)
Close the server supplying an handler that will be called when the server is actually closed (or has failed).
|
MqttClient |
MqttClient.closeHandler(Handler<Void> closeHandler)
Set a handler that will be called when the connection with server is closed
|
MqttEndpoint |
MqttEndpoint.closeHandler(Handler<Void> handler)
Set a close handler.
|
MqttClient |
MqttClient.connect(int port,
String host,
Handler<AsyncResult<MqttConnAckMessage>> connectHandler)
Connects to an MQTT server calling connectHandler after connection
|
MqttClient |
MqttClient.connect(int port,
String host,
String serverName,
Handler<AsyncResult<MqttConnAckMessage>> connectHandler)
Connects to an MQTT server calling connectHandler after connection
|
MqttClient |
MqttClient.disconnect(Handler<AsyncResult<Void>> disconnectHandler)
Disconnects from the MQTT server calling disconnectHandler after disconnection
|
MqttEndpoint |
MqttEndpoint.disconnectHandler(Handler<Void> handler)
Set a disconnect handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)
Set a disconnect handler on the MQTT endpoint.
|
MqttServer |
MqttServer.endpointHandler(Handler<MqttEndpoint> handler)
Set the endpoint handler for the server.
|
MqttClient |
MqttClient.exceptionHandler(Handler<Throwable> handler)
Set an exception handler for the client, that will be called when an error happens
in internal netty structures.
|
MqttEndpoint |
MqttEndpoint.exceptionHandler(Handler<Throwable> handler)
Set an exception handler.
|
MqttServer |
MqttServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler for the server, that will be called when an error happens independantly of an
accepted
MqttEndpoint, like a rejected connection |
MqttServer |
MqttServer.listen(Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections using the specified options
through the constructor
|
MqttServer |
MqttServer.listen(int port,
Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections on the port specified but on
"0.0.0.0" as host.
|
MqttServer |
MqttServer.listen(int port,
String host,
Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections on the port and host specified
It ignores any options specified through the constructor
|
MqttEndpoint |
MqttEndpoint.pingHandler(Handler<Void> handler)
Set the pingreq handler on the MQTT endpoint.
|
MqttClient |
MqttClient.pingResponseHandler(Handler<Void> pingResponseHandler)
Sets handler which will be called after PINGRESP packet receiving
|
MqttClient |
MqttClient.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
int messageId,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
int messageId,
io.netty.handler.codec.mqtt.MqttProperties properties,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
|
MqttEndpoint |
MqttEndpoint.publishAcknowledgeHandler(Handler<Integer> handler)
Set the puback handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)
Set the puback handler on the MQTT endpoint.
|
MqttClient |
MqttClient.publishCompletionExpirationHandler(Handler<Integer> publishCompletionExpirationHandler)
Sets a handler which will be called when the client does not receive a PUBACK or
PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
|
MqttClient |
MqttClient.publishCompletionHandler(Handler<Integer> publishCompletionHandler)
Sets a handler which will be called each time the publishing of a message has been completed.
|
MqttEndpoint |
MqttEndpoint.publishCompletionHandler(Handler<Integer> handler)
Set the pubcomp handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)
Set the pubcomp handler on the MQTT endpoint.
|
MqttClient |
MqttClient.publishCompletionUnknownPacketIdHandler(Handler<Integer> publishCompletionPhantomHandler)
Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown
packet ID.
|
MqttClient |
MqttClient.publishHandler(Handler<MqttPublishMessage> publishHandler)
Sets handler which will be called each time server publish something to client
|
MqttEndpoint |
MqttEndpoint.publishHandler(Handler<MqttPublishMessage> handler)
Set the publish handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReceivedHandler(Handler<Integer> handler)
Set the pubrec handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)
Set the pubrec handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReleaseHandler(Handler<Integer> handler)
Set the pubrel handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)
Set the pubrel handler on the MQTT endpoint.
|
MqttClient |
MqttClient.subscribe(Map<String,Integer> topics,
Handler<AsyncResult<Integer>> subscribeSentHandler)
Subscribes to the topic and adds a handler which will be called after the request is sent
|
MqttClient |
MqttClient.subscribe(String topic,
int qos,
Handler<AsyncResult<Integer>> subscribeSentHandler)
Subscribes to the topic with a specified QoS level
|
MqttClient |
MqttClient.subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)
Sets handler which will be called after SUBACK packet receiving
|
MqttEndpoint |
MqttEndpoint.subscribeHandler(Handler<MqttSubscribeMessage> handler)
Set a subscribe handler on the MQTT endpoint.
|
MqttClient |
MqttClient.unsubscribe(String topic,
Handler<AsyncResult<Integer>> unsubscribeSentHandler)
Unsubscribe from receiving messages on given topic
|
MqttClient |
MqttClient.unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)
Sets handler which will be called after UNSUBACK packet receiving
|
MqttEndpoint |
MqttEndpoint.unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)
Set a unsubscribe handler on the MQTT endpoint.
|
| Modifier and Type | Method and Description |
|---|---|
MSSQLConnection |
MSSQLConnection.closeHandler(Handler<Void> handler)
Set an handler called when the connection is closed.
|
static void |
MSSQLConnection.connect(Vertx vertx,
MSSQLConnectOptions connectOptions,
Handler<AsyncResult<MSSQLConnection>> handler)
Create a connection to SQL Server with the given
connectOptions. |
static void |
MSSQLConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<MSSQLConnection>> handler)
Like
MSSQLConnection.connect(Vertx, MSSQLConnectOptions, Handler) with options built from connectionUri. |
MSSQLPool |
MSSQLPool.connectHandler(Handler<SqlConnection> handler) |
MSSQLConnection |
MSSQLConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called with connection errors.
|
MSSQLConnection |
MSSQLConnection.infoHandler(Handler<MSSQLInfo> handler)
Set a handler called when the connection receives an informational message from the server.
|
MSSQLConnection |
MSSQLConnection.prepare(String s,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
| Modifier and Type | Method and Description |
|---|---|
MySQLConnection |
MySQLConnection.changeUser(MySQLAuthOptions options,
Handler<AsyncResult<Void>> handler)
Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
|
MySQLConnection |
MySQLConnection.closeHandler(Handler<Void> handler)
Set an handler called when the connection is closed.
|
static void |
MySQLConnection.connect(Vertx vertx,
MySQLConnectOptions connectOptions,
Handler<AsyncResult<MySQLConnection>> handler)
Create a connection to MySQL server with the given
connectOptions. |
static void |
MySQLConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<MySQLConnection>> handler)
Like
MySQLConnection.connect(Vertx, MySQLConnectOptions, Handler) with options built from connectionUri. |
MySQLPool |
MySQLPool.connectHandler(Handler<SqlConnection> handler) |
MySQLConnection |
MySQLConnection.debug(Handler<AsyncResult<Void>> handler)
Send a DEBUG command to dump debug information to the server's stdout.
|
MySQLConnection |
MySQLConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called with connection errors.
|
MySQLConnection |
MySQLConnection.getInternalStatistics(Handler<AsyncResult<String>> handler)
Send a STATISTICS command to get a human readable string of the server internal status.
|
MySQLConnection |
MySQLConnection.ping(Handler<AsyncResult<Void>> handler)
Send a PING command to check if the server is alive.
|
MySQLConnection |
MySQLConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
MySQLConnection |
MySQLConnection.resetConnection(Handler<AsyncResult<Void>> handler)
Send a RESET_CONNECTION command to reset the session state.
|
MySQLConnection |
MySQLConnection.setOption(MySQLSetOption option,
Handler<AsyncResult<Void>> handler)
Send a SET_OPTION command to set options for the current connection.
|
MySQLConnection |
MySQLConnection.specifySchema(String schemaName,
Handler<AsyncResult<Void>> handler)
Send a INIT_DB command to change the default schema of the connection.
|
| Modifier and Type | Method and Description |
|---|---|
PgConnection |
PgConnection.cancelRequest(Handler<AsyncResult<Void>> handler)
Send a request cancellation message to tell the server to cancel processing request in this connection.
|
PgConnection |
PgConnection.closeHandler(Handler<Void> handler)
Set an handler called when the connection is closed.
|
static void |
PgConnection.connect(Vertx vertx,
Handler<AsyncResult<PgConnection>> handler)
Like
PgConnection.connect(Vertx, PgConnectOptions, Handler) with options build from the environment variables. |
static void |
PgConnection.connect(Vertx vertx,
PgConnectOptions options,
Handler<AsyncResult<PgConnection>> handler)
Connects to the database and returns the connection if that succeeds.
|
static void |
PgConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<PgConnection>> handler)
Like
PgConnection.connect(Vertx, PgConnectOptions, Handler) with options build from connectionUri. |
PgPool |
PgPool.connectHandler(Handler<SqlConnection> handler) |
PgConnection |
PgConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called with connection errors.
|
PgConnection |
PgConnection.noticeHandler(Handler<PgNotice> handler)
Set a handler called when the connection receives a notice from the server.
|
PgConnection |
PgConnection.notificationHandler(Handler<PgNotification> handler)
Set a handler called when the connection receives notification on a channel.
|
PgConnection |
PgConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
| Modifier and Type | Method and Description |
|---|---|
void |
PgSubscriber.close(Handler<AsyncResult<Void>> handler)
Close the subscriber, the retry policy will not be invoked.
|
PgSubscriber |
PgSubscriber.closeHandler(Handler<Void> handler)
Set an handler called when the subscriber is closed.
|
PgSubscriber |
PgSubscriber.connect(Handler<AsyncResult<Void>> handler)
Connect the subscriber to Postgres.
|
PgChannel |
PgChannel.endHandler(Handler<Void> endHandler)
Set an handler to be called when no more notifications will be received.
|
PgChannel |
PgChannel.exceptionHandler(Handler<Throwable> handler) |
PgChannel |
PgChannel.handler(Handler<String> handler)
Set or unset an handler to be called when a the channel is notified by Postgres.
|
PgChannel |
PgChannel.subscribeHandler(Handler<Void> handler)
Set an handler called when the the channel get subscribed.
|
| Modifier and Type | Method and Description |
|---|---|
void |
RabbitMQClient.addConfirmListener(int maxQueueSize,
Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)
Add a Confirm Listener to the channel.
|
void |
RabbitMQClient.addConnectionEstablishedCallback(Handler<Promise<Void>> connectionEstablishedCallback)
Set a callback to be called whenever a new connection is established.
|
void |
RabbitMQClient.basicAck(long deliveryTag,
boolean multiple,
Handler<AsyncResult<Void>> resultHandler)
Acknowledge one or several received messages.
|
default void |
RabbitMQClient.basicConsumer(String queue,
Handler<AsyncResult<RabbitMQConsumer>> resultHandler) |
void |
RabbitMQClient.basicConsumer(String queue,
QueueOptions options,
Handler<AsyncResult<RabbitMQConsumer>> resultHandler)
Create a consumer with the given
options. |
void |
RabbitMQClient.basicGet(String queue,
boolean autoAck,
Handler<AsyncResult<RabbitMQMessage>> resultHandler)
Retrieve a message from a queue using AMQP.Basic.Get
|
void |
RabbitMQClient.basicNack(long deliveryTag,
boolean multiple,
boolean requeue,
Handler<AsyncResult<Void>> resultHandler)
Reject one or several received messages.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
Future<Void> |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
default void |
RabbitMQClient.basicQos(int prefetchCount,
boolean global,
Handler<AsyncResult<Void>> resultHandler)
Request a specific prefetchCount "quality of service" settings
for this channel.
|
default void |
RabbitMQClient.basicQos(int prefetchCount,
Handler<AsyncResult<Void>> resultHandler)
Request a specific prefetchCount "quality of service" settings
for this channel.
|
void |
RabbitMQClient.basicQos(int prefetchSize,
int prefetchCount,
boolean global,
Handler<AsyncResult<Void>> resultHandler)
Request specific "quality of service" settings.
|
void |
RabbitMQConsumer.cancel(Handler<AsyncResult<Void>> cancelResult)
Stop message consumption from a queue.
|
void |
RabbitMQClient.confirmSelect(Handler<AsyncResult<Void>> resultHandler)
Enables publisher acknowledgements on this channel.
|
RabbitMQConsumer |
RabbitMQConsumer.endHandler(Handler<Void> endHandler)
Set an end handler.
|
RabbitMQConsumer |
RabbitMQConsumer.exceptionHandler(Handler<Throwable> exceptionHandler)
Set an exception handler on the read stream.
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
JsonObject config,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
|
void |
RabbitMQClient.exchangeDelete(String exchange,
Handler<AsyncResult<Void>> resultHandler)
Delete an exchange, without regard for whether it is in use or not.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
RabbitMQConsumer |
RabbitMQConsumer.handler(Handler<RabbitMQMessage> messageArrived)
Set a message handler.
|
void |
RabbitMQClient.messageCount(String queue,
Handler<AsyncResult<Long>> resultHandler)
Returns the number of messages in a queue ready to be delivered.
|
void |
RabbitMQPublisher.publish(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Declare a queue
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
JsonObject config,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Declare a queue with config options
|
void |
RabbitMQClient.queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)
Actively declare a server-named exclusive, autodelete, non-durable queue.
|
void |
RabbitMQClient.queueDelete(String queue,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Delete a queue, without regard for whether it is in use or has messages on it
|
void |
RabbitMQClient.queueDeleteIf(String queue,
boolean ifUnused,
boolean ifEmpty,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Delete a queue
|
void |
RabbitMQClient.queueUnbind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind a queue from an exchange
|
void |
RabbitMQClient.queueUnbind(String queue,
String exchange,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Unbind a queue from an exchange
|
void |
RabbitMQClient.restartConnect(int attempts,
Handler<AsyncResult<Void>> resultHandler)
restart the rabbitMQ connect.
|
void |
RabbitMQClient.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ client.
|
void |
RabbitMQPublisher.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ publisher.
|
void |
RabbitMQClient.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ client.
|
void |
RabbitMQPublisher.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ publisher.
|
void |
RabbitMQClient.waitForConfirms(Handler<AsyncResult<Void>> resultHandler)
Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
|
void |
RabbitMQClient.waitForConfirms(long timeout,
Handler<AsyncResult<Void>> resultHandler)
Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.
|
| Modifier and Type | Method and Description |
|---|---|
static <T> MaybeObserver<T> |
MaybeHelper.toObserver(Handler<AsyncResult<T>> handler)
Adapts an Vert.x
Handler<AsyncResult<T>> to an RxJava2 MaybeObserver. |
static <T> SingleObserver<T> |
SingleHelper.toObserver(Handler<AsyncResult<T>> handler)
Adapts an Vert.x
Handler<AsyncResult<T>> to an RxJava2 SingleObserver. |
static <T> CompletableObserver |
CompletableHelper.toObserver(Handler<AsyncResult<T>> handler)
Adapts an Vert.x
Handler<AsyncResult<T>> to an RxJava2 SingleObserver. |
| Modifier and Type | Method and Description |
|---|---|
static Completable |
CompletableHelper.toCompletable(java.util.function.Consumer<Handler<AsyncResult<Void>>> handler)
Returns a
Completable that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method. |
static <T> Maybe<T> |
MaybeHelper.toMaybe(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)
Returns a
Maybe that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method. |
static <T> Single<T> |
SingleHelper.toSingle(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)
Returns a
Single that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method. |
| Modifier and Type | Method and Description |
|---|---|
AmqpConnection |
AmqpConnection.close(Handler<AsyncResult<Void>> done)
Closes the AMQP connection, i.e.
|
void |
AmqpSender.close(Handler<AsyncResult<Void>> handler)
Closes the sender.
|
void |
AmqpReceiver.close(Handler<AsyncResult<Void>> handler)
Closes the receiver.
|
void |
AmqpClient.close(Handler<AsyncResult<Void>> closeHandler)
Closes the client.
|
AmqpClient |
AmqpClient.connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)
Connects to the AMQP broker or router.
|
AmqpConnection |
AmqpConnection.createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)
Creates an anonymous sender.
|
AmqpConnection |
AmqpConnection.createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a dynamic receiver.
|
AmqpConnection |
AmqpConnection.createReceiver(String address,
AmqpReceiverOptions receiverOptions,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consumer messages from the given address.
|
AmqpClient |
AmqpClient.createReceiver(String address,
AmqpReceiverOptions receiverOptions,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consumer messages from the given address.
|
AmqpConnection |
AmqpConnection.createReceiver(String address,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consume messages from the given address.
|
AmqpClient |
AmqpClient.createReceiver(String address,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consume messages from the given address.
|
AmqpConnection |
AmqpConnection.createSender(String address,
AmqpSenderOptions options,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpClient |
AmqpClient.createSender(String address,
AmqpSenderOptions options,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpConnection |
AmqpConnection.createSender(String address,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpClient |
AmqpClient.createSender(String address,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
WriteStream<AmqpMessage> |
AmqpSender.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
void |
AmqpSender.end(AmqpMessage data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
AmqpSender.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
AmqpReceiver |
AmqpReceiver.endHandler(Handler<Void> endHandler) |
AmqpConnection |
AmqpConnection.exceptionHandler(Handler<Throwable> handler)
Registers a handler called on disconnection.
|
AmqpSender |
AmqpSender.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.handler(Handler<AmqpMessage> handler) |
void |
AmqpReceiver.pipeTo(WriteStream<AmqpMessage> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
AmqpSender |
AmqpSender.sendWithAck(AmqpMessage message,
Handler<AsyncResult<Void>> acknowledgementHandler)
Sends an AMQP message and waits for an acknowledgement.
|
void |
AmqpSender.write(AmqpMessage data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
ResultSet |
ResultSet.all(Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> handler)
The method should not be used concurrently with others like
ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.cassandra.ResultSet>>) or . |
CassandraClient |
CassandraClient.close(Handler<AsyncResult<Void>> closeHandler)
Closes this client.
|
CassandraRowStream |
CassandraRowStream.endHandler(Handler<Void> handler) |
CassandraRowStream |
CassandraRowStream.exceptionHandler(Handler<Throwable> handler) |
CassandraClient |
CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<ResultSet>> resultHandler)
Execute the statement and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.execute(String query,
Handler<AsyncResult<ResultSet>> resultHandler)
Execute the query and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)
Execute the query and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.executeWithFullFetch(String query,
Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)
Execute the query and provide a handler for consuming results.
|
void |
ResultSet.fetchNextPage(Handler<AsyncResult<ResultSet>> handler)
Like
ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.cassandra.ResultSet>>) but with a direct callback. |
CassandraRowStream |
CassandraRowStream.handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler) |
void |
CassandraClient.metadata(Handler<AsyncResult<com.datastax.oss.driver.api.core.metadata.Metadata>> handler)
Get for the session.
|
void |
CassandraRowStream.pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst,
Handler<AsyncResult<Void>> handler) |
CassandraClient |
CassandraClient.prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement,
Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)
Prepares the provided a .
|
CassandraClient |
CassandraClient.prepare(String query,
Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)
Prepares the provided query string.
|
CassandraClient |
CassandraClient.queryStream(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)
Executes the given SQL statement which returns the results of the query as a read stream.
|
CassandraClient |
CassandraClient.queryStream(String sql,
Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
| Modifier and Type | Method and Description |
|---|---|
void |
ConfigRetriever.getConfig(Handler<AsyncResult<JsonObject>> completionHandler)
Reads the configuration from the different
and computes the final configuration.
|
void |
ConfigRetriever.listen(Handler<ConfigChange> listener)
Registers a listener receiving configuration changes.
|
ConfigRetriever |
ConfigRetriever.setBeforeScanHandler(Handler<Void> handler)
Registers a handler called before every scan.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Vertx.close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete |
void |
WorkerExecutor.close(Handler<AsyncResult<Void>> handler)
Close the executor.
|
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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(String name,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete. |
void |
Vertx.deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by
invoking the verticleSupplier. |
void |
Vertx.deployVerticle(Verticle verticle,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(Verticle verticle,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete. |
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
Context |
Context.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called when the context runs an action throwing an uncaught throwable.
When this handler is called,
Vertx.currentContext() will return this context. |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
Vertx |
Vertx.exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context, set on Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>) at creation. |
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
TimeoutStream |
TimeoutStream.handler(Handler<Long> handler) |
void |
TimeoutStream.pipeTo(WriteStream<Long> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
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.
|
<T> Maybe<T> |
Context.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> Maybe<T> |
Vertx.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> Maybe<T> |
WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> Maybe<T> |
Context.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Maybe<T> |
Vertx.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Maybe<T> |
WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
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.setPeriodic(long initialDelay,
long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds with initial delay, at which point handler will be called with
the id of the timer. |
long |
Vertx.setTimer(long delay,
Handler<Long> handler)
Set a one-shot timer to fire after
delay milliseconds, at which point handler will be called with
the id of the timer. |
void |
Vertx.undeploy(String deploymentID,
Handler<AsyncResult<Void>> completionHandler)
Like
#undeploy(String) but the completionHandler will be notified when the undeployment is complete. |
| Modifier and Type | Method and Description |
|---|---|
DatagramSocket |
DatagramSocket.blockMulticastGroup(String multicastAddress,
String sourceToBlock,
Handler<AsyncResult<Void>> 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<Void>> 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. |
DatagramSocket |
DatagramSocket.endHandler(Handler<Void> endHandler) |
DatagramSocket |
DatagramSocket.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<Void>> handler)
Joins a multicast group and listens for packets send to it.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<Void>> handler)
Joins a multicast group and listens for packets send to it on the given network interface.
|
void |
DatagramSocket.pipeTo(WriteStream<DatagramPacket> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
DatagramSocket |
DatagramSocket.send(Buffer packet,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
Buffer to the SocketAddress. |
DatagramSocket |
DatagramSocket.send(String str,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
String to the SocketAddress using UTF8 encoding. |
DatagramSocket |
DatagramSocket.send(String str,
String enc,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
String to the SocketAddress using the given encoding. |
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
Handler<AsyncResult<Void>> handler)
Leaves a multicast group and stops listening for packets send to it.
|
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<Void>> 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 |
|---|---|
<T> EventBus |
EventBus.addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is received by Vert.x
|
<T> EventBus |
EventBus.addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is sent from Vert.x
|
void |
MessageProducer.close(Handler<AsyncResult<Void>> handler)
Same as
MessageProducer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
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.
|
MessageConsumer<T> |
MessageConsumer.endHandler(Handler<Void> endHandler) |
MessageConsumer<T> |
MessageConsumer.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. |
void |
MessageConsumer.pipeTo(WriteStream<Message<T>> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
<T> EventBus |
EventBus.removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>) |
<T> EventBus |
EventBus.removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>) |
<R> void |
Message.replyAndRequest(Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<R>>> replyHandler)
Like
Message.replyAndRequest(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.eventbus.Message<R>>>) but specifying options that can be used
to configure the delivery. |
<R> void |
Message.replyAndRequest(Object message,
Handler<AsyncResult<Message<R>>> replyHandler)
Reply to this message, specifying a
replyHandler for the reply - i.e. |
<T> EventBus |
EventBus.request(String address,
Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.request(java.lang.String, java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.eventbus.Message<T>>>) but specifying options that can be used to configure the delivery. |
<T> EventBus |
EventBus.request(String address,
Object message,
Handler<AsyncResult<Message<T>>> replyHandler)
Sends a message and specify a
replyHandler that will be called if the recipient
subsequently replies to the message. |
void |
MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler)
Unregisters the handler which created this registration
|
void |
MessageProducer.write(T body,
Handler<AsyncResult<Void>> handler)
Write a message to the event-bus, either sending or publishing.
|
| 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,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to, asynchronously. |
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.createTempDirectory(String prefix,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempDirectory(String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempDirectory(String dir,
String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the directory provided by the path
path, using the given
prefix to generate its name, asynchronously. |
FileSystem |
FileSystem.createTempFile(String prefix,
String suffix,
Handler<AsyncResult<String>> handler)
Creates a new file in the default temporary-file directory, using the given
prefix and suffix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempFile(String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir, using the given
prefix and suffix to generate its name, asynchronously. |
FileSystem |
FileSystem.createTempFile(String dir,
String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir, using the given
prefix and suffix to generate its name, 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) |
void |
AsyncFile.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
AsyncFile.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
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(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) 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) |
void |
AsyncFileLock.isValid(Handler<AsyncResult<Boolean>> handler)
Like
AsyncFileLock.isValid(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>) but the handler will be called when the operation completes or if an error occurs. |
FileSystem |
FileSystem.link(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a hard link on the file system from
link to existing, asynchronously. |
void |
AsyncFile.lock(Handler<AsyncResult<AsyncFileLock>> handler)
Like
AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.AsyncFileLock>>) but the handler will be called when the operation is complete or if an error occurs. |
void |
AsyncFile.lock(long position,
long size,
boolean shared,
Handler<AsyncResult<AsyncFileLock>> handler)
Like
AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.file.AsyncFileLock>>) but the handler will be called when the operation is complete or if an error occurs. |
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,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to, 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. |
void |
AsyncFile.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
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. |
void |
AsyncFileLock.release(Handler<AsyncResult<Void>> handler)
Like
AsyncFileLock.release(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the handler will be called when the operation completes or if an error occurs. |
void |
AsyncFile.size(Handler<AsyncResult<Long>> handler)
Like
AsyncFile.size(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>) but the handler will be called when the operation is complete or if an error occurs. |
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. |
void |
AsyncFile.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
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 |
|---|---|
WebSocketBase |
ServerWebSocket.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
WebSocketBase |
WebSocket.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
WebSocketBase |
WebSocketBase.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
HttpClientResponse |
HttpClientResponse.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpClientResponse.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>) but with an handler called when the operation completes |
HttpServerRequest |
HttpServerRequest.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.buffer.Buffer>>) but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.bodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
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 |
ServerWebSocket.close(Handler<AsyncResult<Void>> handler)
Same as
ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
HttpServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the server is actually closed (or has failed). |
void |
WebSocket.close(Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpConnection.close(Handler<AsyncResult<Void>> handler)
Close the connection and all the currently active streams.
|
void |
HttpClient.close(Handler<AsyncResult<Void>> handler)
Close the client.
|
void |
WebSocketBase.close(Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocketBase.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocketBase.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.closeHandler(Handler<Void> handler)
Set a close handler for the response, this is called when the underlying connection is closed and the response
was still using the connection.
|
ServerWebSocket |
ServerWebSocket.closeHandler(Handler<Void> handler) |
WebSocket |
WebSocket.closeHandler(Handler<Void> handler) |
HttpConnection |
HttpConnection.closeHandler(Handler<Void> handler)
Set a close handler.
|
WebSocketBase |
WebSocketBase.closeHandler(Handler<Void> handler)
Set a close handler.
|
void |
HttpClientRequest.connect(Handler<AsyncResult<HttpClientResponse>> handler)
Create an HTTP tunnel to the server.
|
HttpServer |
HttpServer.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the server.
|
HttpClient |
HttpClient.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the client.
|
HttpClientRequest |
HttpClientRequest.continueHandler(Handler<Void> handler)
If you send an HTTP request with the header
Expect set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100 and a continue handler
has been set using this method, then the handler will be called. |
HttpClientResponse |
HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)
Set an custom frame handler.
|
HttpServerRequest |
HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)
Set a custom frame handler.
|
HttpServerResponse |
HttpServerResponse.drainHandler(Handler<Void> handler) |
ServerWebSocket |
ServerWebSocket.drainHandler(Handler<Void> handler) |
HttpClientRequest |
HttpClientRequest.drainHandler(Handler<Void> handler) |
WebSocket |
WebSocket.drainHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.drainHandler(Handler<Void> handler) |
void |
HttpServerResponse.end(Buffer chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpClientRequest.end(Buffer chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
WebSocketBase.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpClientResponse.end(Handler<AsyncResult<Void>> handler)
Same as
HttpClientResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServerResponse.end(Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.end(Handler<AsyncResult<Void>> handler)
|
void |
HttpClientRequest.end(Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.end(Handler<AsyncResult<Void>> handler)
|
void |
HttpServerRequest.end(Handler<AsyncResult<Void>> handler)
Same as
HttpServerRequest.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocketBase.end(Handler<AsyncResult<Void>> handler)
|
void |
HttpServerResponse.end(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.end(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServerResponse.end(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.end(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
HttpClientResponse |
HttpClientResponse.endHandler(Handler<Void> endHandler) |
HttpServerResponse |
HttpServerResponse.endHandler(Handler<Void> handler)
Set an end handler for the response.
|
ServerWebSocket |
ServerWebSocket.endHandler(Handler<Void> endHandler) |
WebSocket |
WebSocket.endHandler(Handler<Void> endHandler) |
HttpServerFileUpload |
HttpServerFileUpload.endHandler(Handler<Void> endHandler) |
HttpServerRequest |
HttpServerRequest.endHandler(Handler<Void> endHandler) |
WebSocketBase |
WebSocketBase.endHandler(Handler<Void> endHandler) |
HttpClientResponse |
HttpClientResponse.exceptionHandler(Handler<Throwable> handler) |
HttpServerResponse |
HttpServerResponse.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpServer |
HttpServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called for socket errors happening before the HTTP connection
is established, e.g during the TLS handshake.
|
HttpClientRequest |
HttpClientRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocket |
WebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpConnection |
HttpConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called when a connection error happens
|
HttpServerFileUpload |
HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequest |
HttpServerRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocketBase |
WebSocketBase.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.
|
HttpConnection |
HttpConnection.goAwayHandler(Handler<GoAway> handler)
Set an handler called when a frame is received.
|
HttpClientResponse |
HttpClientResponse.handler(Handler<Buffer> handler) |
ServerWebSocket |
ServerWebSocket.handler(Handler<Buffer> handler) |
WebSocket |
WebSocket.handler(Handler<Buffer> handler) |
HttpServerFileUpload |
HttpServerFileUpload.handler(Handler<Buffer> handler) |
HttpServerRequest |
HttpServerRequest.handler(Handler<Buffer> handler) |
WebSocketBase |
WebSocketBase.handler(Handler<Buffer> handler) |
HttpServerResponse |
HttpServerResponse.headersEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the headers are written to the wire.
|
HttpServer |
HttpServer.invalidRequestHandler(Handler<HttpServerRequest> handler)
Set a
handler for handling invalid requests. |
HttpServer |
HttpServer.listen(Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.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(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) 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, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually
listening (or has failed). |
HttpServer |
HttpServer.listen(SocketAddress address,
Handler<AsyncResult<HttpServer>> listenHandler)
Tell the server to start listening on the given address supplying
a handler that will be called when the server is actually
listening (or has failed).
|
HttpConnection |
HttpConnection.ping(Buffer data,
Handler<AsyncResult<Buffer>> pongHandler)
Send a frame to the remote endpoint.
|
HttpConnection |
HttpConnection.pingHandler(Handler<Buffer> handler)
Set an handler notified when a frame is received from the remote endpoint.
|
void |
HttpClientResponse.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
ServerWebSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
WebSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
HttpServerFileUpload.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
HttpServerRequest.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
WebSocketBase.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
WebSocketBase |
ServerWebSocket.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
WebSocketBase |
WebSocket.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
WebSocketBase |
WebSocketBase.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.http.HttpServerResponse>>) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Push a response to the client.
The
handler will be notified with a success when the push can be sent and with
a failure when the client has disabled push or reset the push before it has been sent.
The handler may be queued if the client has reduced the maximum number of streams the server can push
concurrently.
Push can be sent only for peer initiated streams and if the response is not ended. |
HttpClientRequest |
HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)
Set a push handler for this request.
The handler is called when the client receives a push promise from the server.
|
HttpConnection |
HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)
Set an handler that is called when remote endpoint
Http2Settings are updated. |
void |
HttpClient.request(HttpMethod method,
int port,
String host,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the
host and port. |
void |
HttpClient.request(HttpMethod method,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the default host and port.
|
void |
HttpClient.request(HttpMethod method,
String host,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the
host and default port. |
void |
HttpClient.request(RequestOptions options,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server.
|
HttpServer |
HttpServer.requestHandler(Handler<HttpServerRequest> handler)
Set the request handler for the server to
requestHandler. |
HttpClientRequest |
HttpClientRequest.response(Handler<AsyncResult<HttpClientResponse>> handler)
Set a callback for the associated
HttpClientResponse. |
void |
HttpClientRequest.send(Buffer body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a buffer
body. |
void |
HttpServerResponse.send(Buffer body,
Handler<AsyncResult<Void>> handler)
Send the request with a buffer
body. |
void |
HttpClientRequest.send(Flowable<Buffer> body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a stream
body. |
void |
HttpServerResponse.send(Flowable<Buffer> body,
Handler<AsyncResult<Void>> handler)
Send the request with a stream
body. |
void |
HttpClientRequest.send(Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with an empty body.
|
void |
HttpServerResponse.send(Handler<AsyncResult<Void>> handler)
Send the request with an empty body.
|
void |
HttpClientRequest.send(ReadStream<Buffer> body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a stream
body. |
void |
HttpServerResponse.send(ReadStream<Buffer> body,
Handler<AsyncResult<Void>> handler)
Send the request with a stream
body. |
void |
HttpClientRequest.send(String body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a string
body. |
void |
HttpServerResponse.send(String body,
Handler<AsyncResult<Void>> handler)
Send the request with a string
body. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but providing a handler which will be notified once the file has been
completely written to the wire. |
HttpClientRequest |
HttpClientRequest.sendHead(Handler<AsyncResult<Void>> completionHandler)
Like
HttpClientRequest.sendHead(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler after headers have been sent. |
void |
ServerWebSocket.setHandshake(Future<Integer> future,
Handler<AsyncResult<Integer>> handler)
Set an asynchronous result for the handshake, upon completion of the specified
future, the
WebSocket will either be
accepted when the future succeeds with the HTTP status code
rejected when the future is succeeds with an HTTP status code different than
rejected when the future fails with the HTTP status code 500
The provided future might be completed by the WebSocket itself, e.g calling the ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) method
will try to accept the handshake and close the WebSocket afterward. |
void |
ServerWebSocket.setHandshake(Single<Integer> future,
Handler<AsyncResult<Integer>> handler)
Set an asynchronous result for the handshake, upon completion of the specified
future, the
WebSocket will either be
accepted when the future succeeds with the HTTP status code
rejected when the future is succeeds with an HTTP status code different than
rejected when the future fails with the HTTP status code 500
The provided future might be completed by the WebSocket itself, e.g calling the ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) method
will try to accept the handshake and close the WebSocket afterward. |
void |
HttpConnection.shutdown(Handler<AsyncResult<Void>> handler)
Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests
are processed, otherwise after 30 seconds the connection will be closed.
|
void |
HttpConnection.shutdown(long timeout,
Handler<AsyncResult<Void>> handler)
Like
HttpConnection.shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with a specific timeout in milliseconds. |
HttpConnection |
HttpConnection.shutdownHandler(Handler<Void> handler)
Set an handler called when a frame has been sent or received and all connections are closed.
|
HttpClientResponse |
HttpClientResponse.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes.
|
HttpServerRequest |
HttpServerRequest.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes
|
void |
HttpServerFileUpload.streamToFileSystem(String filename,
Handler<AsyncResult<Void>> handler)
Stream the content of this upload to the given file on storage.
|
WebSocketBase |
ServerWebSocket.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
WebSocketBase |
WebSocket.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
WebSocketBase |
WebSocketBase.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
void |
HttpServerRequest.toNetSocket(Handler<AsyncResult<NetSocket>> handler)
Establish a TCP tunnel with the client.
|
void |
HttpServerRequest.toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler)
Upgrade the connection of the current request to a WebSocket.
|
HttpConnection |
HttpConnection.updateSettings(Http2Settings settings,
Handler<AsyncResult<Void>> completionHandler)
Send to the remote endpoint an update of this endpoint settings
The
completionHandler will be notified when the remote endpoint has acknowledged the settings. |
HttpServerRequest |
HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)
Set an upload handler.
|
void |
HttpClient.webSocket(int port,
String host,
String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket to the specified port, host and relative request URI
|
void |
HttpClient.webSocket(String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket at the relative request URI using the default host and port
|
void |
HttpClient.webSocket(String host,
String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket to the host and relative request URI and default port
|
void |
HttpClient.webSocket(WebSocketConnectOptions options,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket with the specified options.
|
void |
HttpClient.webSocketAbs(String url,
MultiMap headers,
WebsocketVersion version,
List<String> subProtocols,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket with the specified absolute url, 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. |
void |
HttpServerResponse.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
ServerWebSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpClientRequest.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
WebSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
WebSocketBase.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpServerResponse.write(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.write(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServerResponse.write(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.write(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.write(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeBinaryMessage(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFinalBinaryFrame(io.vertx.reactivex.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFinalTextFrame(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFrame(io.vertx.reactivex.core.http.WebSocketFrame, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
WebSocketBase |
ServerWebSocket.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
WebSocket.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
WebSocketBase.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
ServerWebSocket.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
WebSocketBase |
WebSocket.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
WebSocketBase |
WebSocketBase.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
ServerWebSocket |
ServerWebSocket.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeTextMessage(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
void |
NetClient.close(Handler<AsyncResult<Void>> handler)
Close the client.
|
void |
NetSocket.close(Handler<AsyncResult<Void>> handler)
Close the NetSocket and notify the
handler when the operation completes. |
void |
NetServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
NetServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) 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. |
NetClient |
NetClient.connect(int port,
String host,
String serverName,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
port and host. |
NetClient |
NetClient.connect(SocketAddress remoteAddress,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
remoteAddress. |
NetClient |
NetClient.connect(SocketAddress remoteAddress,
String serverName,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
remoteAddress. |
NetServer |
NetServer.connectHandler(Handler<NetSocket> handler)
Supply a connect handler for this server.
|
NetSocket |
NetSocket.drainHandler(Handler<Void> handler) |
void |
NetSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
NetSocket.end(Handler<AsyncResult<Void>> handler)
|
NetSocket |
NetSocket.endHandler(Handler<Void> endHandler)
This handler might be called after the close handler when the socket is paused and there are still
buffers to deliver.
|
NetSocket |
NetSocket.exceptionHandler(Handler<Throwable> handler) |
NetSocket |
NetSocket.handler(Handler<Buffer> handler) |
NetServer |
NetServer.listen(Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>) 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(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>) 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(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>) but providing a handler that will be notified when the server is listening, or fails. |
NetServer |
NetServer.listen(SocketAddress localAddress,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.net.NetServer>>) but providing a handler that will be notified when the server is listening, or fails. |
void |
NetSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
NetSocket |
NetSocket.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.upgradeToSsl(Handler<AsyncResult<Void>> handler)
Upgrade channel to use SSL/TLS.
|
NetSocket |
NetSocket.upgradeToSsl(String serverName,
Handler<AsyncResult<Void>> handler)
Upgrade channel to use SSL/TLS.
|
void |
NetSocket.write(Buffer message,
Handler<AsyncResult<Void>> handler)
Like
WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the message has been written
or failed to be written. |
void |
NetSocket.write(String str,
Handler<AsyncResult<Void>> handler)
Same as
NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
NetSocket.write(String str,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
RecordParser |
RecordParser.endHandler(Handler<Void> endHandler) |
JsonParser |
JsonParser.endHandler(Handler<Void> endHandler) |
RecordParser |
RecordParser.exceptionHandler(Handler<Throwable> handler) |
JsonParser |
JsonParser.exceptionHandler(Handler<Throwable> handler) |
RecordParser |
RecordParser.handler(Handler<Buffer> handler) |
JsonParser |
JsonParser.handler(Handler<JsonEvent> handler) |
static RecordParser |
RecordParser.newDelimited(Buffer delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newDelimited(String delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.reactivex.core.buffer.Buffer>) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newFixed(int size,
Handler<Buffer> output)
Like
RecordParser.newFixed(int) but set the output that will receive whole records
which have been parsed. |
void |
RecordParser.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
JsonParser.pipeTo(WriteStream<JsonEvent> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
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.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the
AsyncMap with the specified name. |
<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 an asynchronous counter.
|
<K,V> void |
SharedData.getLocalAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the
AsyncMap with the specified name. |
void |
SharedData.getLocalCounter(String name,
Handler<AsyncResult<Counter>> resultHandler)
Get an asynchronous local counter.
|
void |
SharedData.getLocalLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get an asynchronous local lock with the specified name.
|
void |
SharedData.getLocalLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
|
void |
SharedData.getLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get an asynchronous lock with the specified name.
|
void |
SharedData.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
|
void |
Counter.incrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the new count
|
void |
AsyncMap.keys(Handler<AsyncResult<Set<K>>> resultHandler)
Get the keys of the map, asynchronously.
|
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 time to live for the entry. |
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 time to live for the entry. |
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.replace(K k,
V v,
long ttl,
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.replaceIfPresent(K k,
V oldValue,
V newValue,
long ttl,
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
|
void |
AsyncMap.values(Handler<AsyncResult<List<V>>> resultHandler)
Get the values of the map, asynchronously.
|
| Modifier and Type | Method and Description |
|---|---|
WriteStream<T> |
WriteStream.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
void |
WriteStream.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WriteStream.end(T data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
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.
|
void |
ReadStream.pipeTo(WriteStream<T> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
Pipe.to(WriteStream<T> dst,
Handler<AsyncResult<Void>> completionHandler)
Start to pipe the elements to the destination
WriteStream. |
void |
WriteStream.write(T data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
DB2Connection |
DB2Connection.closeHandler(Handler<Void> handler) |
static void |
DB2Connection.connect(Vertx vertx,
DB2ConnectOptions connectOptions,
Handler<AsyncResult<DB2Connection>> handler)
Create a connection to DB2 server with the given
connectOptions. |
static void |
DB2Connection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<DB2Connection>> handler)
|
DB2Pool |
DB2Pool.connectHandler(Handler<SqlConnection> handler) |
DB2Connection |
DB2Connection.debug(Handler<AsyncResult<Void>> handler)
Send a DEBUG command to dump debug information to the server's stdout.
|
DB2Connection |
DB2Connection.exceptionHandler(Handler<Throwable> handler) |
DB2Connection |
DB2Connection.ping(Handler<AsyncResult<Void>> handler)
Send a PING command to check if the server is alive.
|
DB2Connection |
DB2Connection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
User |
User.isAuthorized(Authorization authority,
Handler<AsyncResult<Boolean>> resultHandler)
Deprecated.
|
User |
User.isAuthorized(String authority,
Handler<AsyncResult<Boolean>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
AuthenticationProvider.authenticate(Credentials credentials,
Handler<AsyncResult<User>> resultHandler)
Authenticate a user.
|
void |
AuthenticationProvider.authenticate(JsonObject credentials,
Handler<AsyncResult<User>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
AuthorizationProvider.getAuthorizations(User user,
Handler<AsyncResult<Void>> handler)
Updates the user with the set of authorizations.
|
| Modifier and Type | Method and Description |
|---|---|
JDBCUserUtil |
JDBCUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
JDBCUserUtil |
JDBCUserUtil.createRolePermission(String role,
String permission,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
JDBCUserUtil |
JDBCUserUtil.createUser(String username,
String password,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
JDBCUserUtil |
JDBCUserUtil.createUserRole(String username,
String role,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
MongoUserUtil |
MongoUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<String>> resultHandler)
Insert a user into a database.
|
MongoUserUtil |
MongoUserUtil.createUser(String username,
String password,
Handler<AsyncResult<String>> resultHandler)
Insert a user into a database.
|
MongoUserUtil |
MongoUserUtil.createUserRolesAndPermissions(String username,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Insert a user role into a database.
|
void |
MongoAuth.insertUser(String username,
String password,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
OAuth2Auth |
OAuth2Auth.jWKSet(Handler<AsyncResult<Void>> handler)
Retrieve the public server JSON Web Key (JWK) required to verify the authenticity
of issued ID and access tokens.
|
OAuth2Auth |
OAuth2Auth.missingKeyHandler(Handler<String> handler)
Handled to be called when a key (mentioned on a JWT) is missing from the current config.
|
OAuth2Auth |
OAuth2Auth.refresh(User user,
Handler<AsyncResult<User>> handler)
Refresh the current User (access token).
|
OAuth2Auth |
OAuth2Auth.revoke(User user,
Handler<AsyncResult<Void>> handler)
Revoke an obtained access token.
|
OAuth2Auth |
OAuth2Auth.revoke(User user,
String tokenType,
Handler<AsyncResult<Void>> handler)
Revoke an obtained access or refresh token.
|
OAuth2Auth |
OAuth2Auth.userInfo(User user,
Handler<AsyncResult<JsonObject>> handler)
Retrieve profile information and other attributes for a logged-in end-user.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
SalesforceAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
IBMCloudAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
GoogleAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
AzureADAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
OpenIDConnectAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
KeycloakAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
AmazonCognitoAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
| Modifier and Type | Method and Description |
|---|---|
SqlUserUtil |
SqlUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<Void>> resultHandler)
Insert a user into a database.
|
SqlUserUtil |
SqlUserUtil.createRolePermission(String role,
String permission,
Handler<AsyncResult<Void>> resultHandler)
Insert a role permission into a database.
|
SqlUserUtil |
SqlUserUtil.createUser(String username,
String password,
Handler<AsyncResult<Void>> resultHandler)
Insert a user into a database.
|
SqlUserUtil |
SqlUserUtil.createUserRole(String username,
String role,
Handler<AsyncResult<Void>> resultHandler)
Insert a user role into a database.
|
| Modifier and Type | Method and Description |
|---|---|
WebAuthn |
WebAuthn.createCredentialsOptions(JsonObject user,
Handler<AsyncResult<JsonObject>> handler)
Gets a challenge and any other parameters for the
navigator.credentials.create() call. |
MetaDataService |
MetaDataService.fetchTOC(Handler<AsyncResult<Boolean>> handler)
Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
|
MetaDataService |
MetaDataService.fetchTOC(String url,
Handler<AsyncResult<Boolean>> handler)
Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
|
WebAuthn |
WebAuthn.getCredentialsOptions(String name,
Handler<AsyncResult<JsonObject>> handler)
Creates an assertion challenge and any other parameters for the
navigator.credentials.get() call. |
| Modifier and Type | Method and Description |
|---|---|
ConsulClient |
ConsulClient.agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)
Returns the configuration and member information of the local agent
|
ConsulClient |
ConsulClient.catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)
Return all the datacenters that are known by the Consul server
|
ConsulClient |
ConsulClient.catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)
Returns the nodes registered in a datacenter
|
ConsulClient |
ConsulClient.catalogNodeServices(String node,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the node's registered services
|
ConsulClient |
ConsulClient.catalogNodeServicesWithOptions(String node,
BlockingQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the node's registered services
This is blocking query unlike
ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>) |
ConsulClient |
ConsulClient.catalogNodesWithOptions(NodeQueryOptions options,
Handler<AsyncResult<NodeList>> resultHandler)
Returns the nodes registered in a datacenter
|
ConsulClient |
ConsulClient.catalogServiceNodes(String service,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the nodes providing a service
|
ConsulClient |
ConsulClient.catalogServiceNodesWithOptions(String service,
ServiceQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the nodes providing a service
|
ConsulClient |
ConsulClient.catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)
Returns the services registered in a datacenter
|
ConsulClient |
ConsulClient.catalogServicesWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the services registered in a datacenter
This is blocking query unlike
ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>) |
ConsulClient |
ConsulClient.cloneAclToken(String id,
Handler<AsyncResult<String>> idHandler)
Clone Acl token
|
ConsulClient |
ConsulClient.coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)
Returns the WAN network coordinates for all Consul servers, organized by DCs
|
ConsulClient |
ConsulClient.coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)
Returns the LAN network coordinates for all nodes in a given DC
|
ConsulClient |
ConsulClient.coordinateNodesWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<CoordinateList>> resultHandler)
Returns the LAN network coordinates for all nodes in a given DC
This is blocking query unlike
ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>) |
ConsulClient |
ConsulClient.createAclToken(AclToken token,
Handler<AsyncResult<String>> idHandler)
Create new Acl token
|
ConsulClient |
ConsulClient.createPreparedQuery(PreparedQueryDefinition definition,
Handler<AsyncResult<String>> resultHandler) |
ConsulClient |
ConsulClient.createSession(Handler<AsyncResult<String>> idHandler)
Initialize a new session
|
ConsulClient |
ConsulClient.createSessionWithOptions(SessionOptions options,
Handler<AsyncResult<String>> idHandler)
Initialize a new session
|
ConsulClient |
ConsulClient.deletePreparedQuery(String id,
Handler<AsyncResult<Void>> resultHandler)
Deletes an existing prepared query
|
ConsulClient |
ConsulClient.deleteValue(String key,
Handler<AsyncResult<Void>> resultHandler)
Remove the key/value pair that corresponding to the specified key
|
ConsulClient |
ConsulClient.deleteValues(String keyPrefix,
Handler<AsyncResult<Void>> resultHandler)
Removes all the key/value pair that corresponding to the specified key prefix
|
ConsulClient |
ConsulClient.deregisterCatalogService(String nodeId,
String serviceId,
Handler<AsyncResult<Void>> resultHandler)
Deregister entities from the node or deregister the node itself.
|
ConsulClient |
ConsulClient.deregisterCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Remove a check from the local agent.
|
ConsulClient |
ConsulClient.deregisterService(String id,
Handler<AsyncResult<Void>> resultHandler)
Remove a service from the local agent.
|
ConsulClient |
ConsulClient.destroyAclToken(String id,
Handler<AsyncResult<Void>> resultHandler)
Destroy Acl token
|
ConsulClient |
ConsulClient.destroySession(String id,
Handler<AsyncResult<Void>> resultHandler)
Destroys the given session
|
ConsulClient |
ConsulClient.executePreparedQuery(String query,
Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)
Executes an existing prepared query.
|
ConsulClient |
ConsulClient.executePreparedQueryWithOptions(String query,
PreparedQueryExecuteOptions options,
Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)
Executes an existing prepared query.
|
ConsulClient |
ConsulClient.failCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "critical".
|
ConsulClient |
ConsulClient.failCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "critical".
|
ConsulClient |
ConsulClient.fireEvent(String name,
Handler<AsyncResult<Event>> resultHandler)
Fires a new user event
|
ConsulClient |
ConsulClient.fireEventWithOptions(String name,
EventOptions options,
Handler<AsyncResult<Event>> resultHandler)
Fires a new user event
|
ConsulClient |
ConsulClient.getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)
Returns a list of all prepared queries.
|
ConsulClient |
ConsulClient.getKeys(String keyPrefix,
Handler<AsyncResult<List<String>>> resultHandler)
Returns the list of keys that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getKeysWithOptions(String keyPrefix,
BlockingQueryOptions options,
Handler<AsyncResult<List<String>>> resultHandler)
Returns the list of keys that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getPreparedQuery(String id,
Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)
Returns an existing prepared query
|
ConsulClient |
ConsulClient.getValue(String key,
Handler<AsyncResult<KeyValue>> resultHandler)
Returns key/value pair that corresponding to the specified key.
|
ConsulClient |
ConsulClient.getValues(String keyPrefix,
Handler<AsyncResult<KeyValueList>> resultHandler)
Returns the list of key/value pairs that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getValuesWithOptions(String keyPrefix,
BlockingQueryOptions options,
Handler<AsyncResult<KeyValueList>> resultHandler)
Returns the list of key/value pairs that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getValueWithOptions(String key,
BlockingQueryOptions options,
Handler<AsyncResult<KeyValue>> resultHandler)
Returns key/value pair that corresponding to the specified key.
|
ConsulClient |
ConsulClient.healthChecks(String service,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks associated with the service
|
ConsulClient |
ConsulClient.healthChecksWithOptions(String service,
CheckQueryOptions options,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks associated with the service
|
ConsulClient |
ConsulClient.healthServiceNodes(String service,
boolean passing,
Handler<AsyncResult<ServiceEntryList>> resultHandler)
Returns the nodes providing the service.
|
ConsulClient |
ConsulClient.healthServiceNodesWithOptions(String service,
boolean passing,
ServiceQueryOptions options,
Handler<AsyncResult<ServiceEntryList>> resultHandler)
Returns the nodes providing the service.
|
ConsulClient |
ConsulClient.healthState(HealthState healthState,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks in the specified status
|
ConsulClient |
ConsulClient.healthStateWithOptions(HealthState healthState,
CheckQueryOptions options,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks in the specified status
|
ConsulClient |
ConsulClient.infoAclToken(String id,
Handler<AsyncResult<AclToken>> tokenHandler)
Get info of Acl token
|
ConsulClient |
ConsulClient.infoSession(String id,
Handler<AsyncResult<Session>> resultHandler)
Returns the requested session information
|
ConsulClient |
ConsulClient.infoSessionWithOptions(String id,
BlockingQueryOptions options,
Handler<AsyncResult<Session>> resultHandler)
Returns the requested session information
This is blocking query unlike
ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>) |
ConsulClient |
ConsulClient.leaderStatus(Handler<AsyncResult<String>> resultHandler)
Get the Raft leader for the datacenter in which the agent is running.
|
ConsulClient |
ConsulClient.listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)
Get list of Acl token
|
ConsulClient |
ConsulClient.listEvents(Handler<AsyncResult<EventList>> resultHandler)
Returns the most recent events known by the agent
|
ConsulClient |
ConsulClient.listEventsWithOptions(EventListOptions options,
Handler<AsyncResult<EventList>> resultHandler)
Returns the most recent events known by the agent.
|
ConsulClient |
ConsulClient.listNodeSessions(String nodeId,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions for a given node
|
ConsulClient |
ConsulClient.listNodeSessionsWithOptions(String nodeId,
BlockingQueryOptions options,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions for a given node
This is blocking query unlike
ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>) |
ConsulClient |
ConsulClient.listSessions(Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions
|
ConsulClient |
ConsulClient.listSessionsWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions
This is blocking query unlike
ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>) |
ConsulClient |
ConsulClient.localChecks(Handler<AsyncResult<List<Check>>> resultHandler)
Return all the checks that are registered with the local agent.
|
ConsulClient |
ConsulClient.localServices(Handler<AsyncResult<List<Service>>> resultHandler)
Returns list of services registered with the local agent.
|
ConsulClient |
ConsulClient.maintenanceService(MaintenanceOptions maintenanceOptions,
Handler<AsyncResult<Void>> resultHandler)
Places a given service into "maintenance mode"
|
ConsulClient |
ConsulClient.passCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "passing".
|
ConsulClient |
ConsulClient.passCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "passing".
|
ConsulClient |
ConsulClient.peersStatus(Handler<AsyncResult<List<String>>> resultHandler)
Retrieves the Raft peers for the datacenter in which the the agent is running.
|
ConsulClient |
ConsulClient.putValue(String key,
String value,
Handler<AsyncResult<Boolean>> resultHandler)
Adds specified key/value pair
|
ConsulClient |
ConsulClient.putValueWithOptions(String key,
String value,
KeyValueOptions options,
Handler<AsyncResult<Boolean>> resultHandler) |
ConsulClient |
ConsulClient.registerCatalogService(Node nodeOptions,
ServiceOptions serviceOptions,
Handler<AsyncResult<Void>> resultHandler)
Register node with external service
|
ConsulClient |
ConsulClient.registerCheck(CheckOptions checkOptions,
Handler<AsyncResult<Void>> resultHandler)
Add a new check to the local agent.
|
ConsulClient |
ConsulClient.registerService(ServiceOptions serviceOptions,
Handler<AsyncResult<Void>> resultHandler)
Adds a new service, with an optional health check, to the local agent.
|
ConsulClient |
ConsulClient.renewSession(String id,
Handler<AsyncResult<Session>> resultHandler)
Renews the given session.
|
Watch<T> |
Watch.setHandler(Handler<WatchResult<T>> handler)
Set the result handler.
|
ConsulClient |
ConsulClient.transaction(TxnRequest request,
Handler<AsyncResult<TxnResponse>> resultHandler)
Manages multiple operations inside a single, atomic transaction.
|
ConsulClient |
ConsulClient.updateAclToken(AclToken token,
Handler<AsyncResult<String>> idHandler)
Update Acl token
|
ConsulClient |
ConsulClient.updateCheck(String checkId,
CheckStatus status,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to given status.
|
ConsulClient |
ConsulClient.updateCheckWithNote(String checkId,
CheckStatus status,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to given status.
|
ConsulClient |
ConsulClient.updatePreparedQuery(PreparedQueryDefinition definition,
Handler<AsyncResult<Void>> resultHandler) |
ConsulClient |
ConsulClient.warnCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "warning".
|
ConsulClient |
ConsulClient.warnCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "warning".
|
| Modifier and Type | Method and Description |
|---|---|
void |
TcpEventBusBridge.close(Handler<AsyncResult<Void>> handler)
Close the current socket.
|
static TcpEventBusBridge |
TcpEventBusBridge.create(Vertx vertx,
BridgeOptions options,
NetServerOptions netServerOptions,
Handler<BridgeEvent> eventHandler) |
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 |
HealthChecks.checkStatus(Handler<AsyncResult<CheckResult>> resultHandler)
Invokes the registered procedures.
|
void |
HealthChecks.checkStatus(String name,
Handler<AsyncResult<CheckResult>> resultHandler)
Invokes the registered procedure with the given name and sub-procedures.
|
HealthChecks |
HealthChecks.invoke(Handler<JsonObject> resultHandler)
Invokes the registered procedures and computes the outcome.
|
HealthChecks |
HealthChecks.invoke(String name,
Handler<AsyncResult<JsonObject>> resultHandler)
Invokes the registered procedure with the given name and sub-procedures.
|
HealthChecks |
HealthChecks.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthChecks |
HealthChecks.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
| Modifier and Type | Method and Description |
|---|---|
SQLOperations |
JDBCClient.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
JDBCClient.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
| Modifier and Type | Method and Description |
|---|---|
MailClient |
MailClient.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler)
send a single mail via MailClient
|
| Modifier and Type | Method and Description |
|---|---|
MongoClient |
MongoClient.bulkWrite(String collection,
List<BulkOperation> operations,
Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)
Execute a bulk operation.
|
MongoClient |
MongoClient.bulkWriteWithOptions(String collection,
List<BulkOperation> operations,
BulkWriteOptions bulkWriteOptions,
Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)
Execute a bulk operation with the specified write options.
|
void |
MongoClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release its resources
|
MongoClient |
MongoClient.count(String collection,
JsonObject query,
Handler<AsyncResult<Long>> resultHandler)
Count matching documents in a collection.
|
MongoClient |
MongoClient.countWithOptions(String collection,
JsonObject query,
CountOptions countOptions,
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.createCollectionWithOptions(String collectionName,
CreateCollectionOptions collectionOptions,
Handler<AsyncResult<Void>> resultHandler)
Create a new collection with options
|
MongoClient |
MongoClient.createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)
Creates a
MongoGridFsClient used to interact with Mongo GridFS. |
MongoClient |
MongoClient.createGridFsBucketService(String bucketName,
Handler<AsyncResult<MongoGridFsClient>> resultHandler)
Creates a
MongoGridFsClient used to interact with Mongo GridFS. |
MongoClient |
MongoClient.createIndex(String collection,
JsonObject key,
Handler<AsyncResult<Void>> resultHandler)
Creates an index.
|
MongoClient |
MongoClient.createIndexes(String collection,
List<IndexModel> indexes,
Handler<AsyncResult<Void>> resultHandler)
creates an indexes
|
MongoClient |
MongoClient.createIndexWithOptions(String collection,
JsonObject key,
IndexOptions options,
Handler<AsyncResult<Void>> resultHandler)
Creates an index.
|
MongoGridFsClient |
MongoGridFsClient.delete(String id,
Handler<AsyncResult<Void>> resultHandler)
Deletes a file by it's ID
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
DistinctOptions distinctOptions,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinctWithQuery(String collection,
String fieldName,
String resultClassname,
JsonObject query,
DistinctOptions distinctOptions,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name filtered by specified query.
|
MongoClient |
MongoClient.distinctWithQuery(String collection,
String fieldName,
String resultClassname,
JsonObject query,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name filtered by specified query.
|
MongoGridFsClient |
MongoGridFsClient.downloadByFileName(WriteStream<Buffer> stream,
String fileName,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadByFileNameWithOptions(WriteStream<Buffer> stream,
String fileName,
GridFsDownloadOptions options,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadById(WriteStream<Buffer> stream,
String id,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadFile(String fileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file.
|
MongoGridFsClient |
MongoGridFsClient.downloadFileAs(String fileName,
String newFileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file and gives it a new name.
|
MongoGridFsClient |
MongoGridFsClient.downloadFileByID(String id,
String fileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file using the ID generated by GridFs.
|
MongoGridFsClient |
MongoGridFsClient.drop(Handler<AsyncResult<Void>> resultHandler)
Drops the entire file bucket with all of its contents
|
MongoClient |
MongoClient.dropCollection(String collection,
Handler<AsyncResult<Void>> resultHandler)
Drop a collection
|
MongoClient |
MongoClient.dropIndex(String collection,
String indexName,
Handler<AsyncResult<Void>> resultHandler)
Drops the index given its name.
|
MongoClient |
MongoClient.find(String collection,
JsonObject query,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection
|
MongoGridFsClient |
MongoGridFsClient.findAllIds(Handler<AsyncResult<List<String>>> resultHandler)
Finds all file ids in the bucket
|
MongoGridFsClient |
MongoGridFsClient.findIds(JsonObject query,
Handler<AsyncResult<List<String>>> resultHandler)
Finds all file ids that match a query.
|
MongoClient |
MongoClient.findOne(String collection,
JsonObject query,
JsonObject fields,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection
|
MongoClient |
MongoClient.findOneAndDelete(String collection,
JsonObject query,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and delete it.
|
MongoClient |
MongoClient.findOneAndDeleteWithOptions(String collection,
JsonObject query,
FindOptions findOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and delete it.
|
MongoClient |
MongoClient.findOneAndReplace(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and replace it.
|
MongoClient |
MongoClient.findOneAndReplaceWithOptions(String collection,
JsonObject query,
JsonObject replace,
FindOptions findOptions,
UpdateOptions updateOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and replace it.
|
MongoClient |
MongoClient.findOneAndUpdate(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and update it.
|
MongoClient |
MongoClient.findOneAndUpdateWithOptions(String collection,
JsonObject query,
JsonObject update,
FindOptions findOptions,
UpdateOptions updateOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and update it.
|
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.listIndexes(String collection,
Handler<AsyncResult<JsonArray>> resultHandler)
Get all the indexes in this collection.
|
MongoClient |
MongoClient.removeDocument(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocuments(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocumentsWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection with the specified write option and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocumentWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection with the specified write option and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.replaceDocuments(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.replaceDocumentsWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.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.updateCollection(String collection,
JsonObject query,
JsonArray update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Use an aggregation pipeline to update documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollection(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonArray update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoGridFsClient |
MongoGridFsClient.uploadByFileName(Flowable<Buffer> stream,
String fileName,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileName(ReadStream<Buffer> stream,
String fileName,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileNameWithOptions(Flowable<Buffer> stream,
String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileNameWithOptions(ReadStream<Buffer> stream,
String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadFile(String fileName,
Handler<AsyncResult<String>> resultHandler)
Upload a file to gridfs
|
MongoGridFsClient |
MongoGridFsClient.uploadFileWithOptions(String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler)
Upload a file to gridfs with 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 |
ShellServer.shellHandler(Handler<Shell> shellHandler)
Called when a new shell is created.
|
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.
|
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 | Method and Description |
|---|---|
void |
TermServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
TermServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) 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<Void>> listenHandler)
Bind the term server, the
TermServer.termHandler(io.vertx.core.Handler<io.vertx.reactivex.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.
|
Tty |
Tty.resizehandler(Handler<Void> handler)
Set a resize handler, the handler is called when the tty size changes.
|
Term |
Term.resizehandler(Handler<Void> handler) |
Tty |
Tty.stdinHandler(Handler<String> handler)
Set a stream handler on the standard input to read the data.
|
Term |
Term.stdinHandler(Handler<String> handler) |
Pty |
Pty.stdoutHandler(Handler<String> handler)
Set the standard out handler of the pseudo terminal.
|
SockJSTermHandler |
SockJSTermHandler.termHandler(Handler<Term> handler) |
TermServer |
TermServer.termHandler(Handler<Term> handler)
Set the term handler that will receive incoming client connections.
|
| Modifier and Type | Method and Description |
|---|---|
SQLConnection |
SQLConnection.batch(List<String> sqlStatements,
Handler<AsyncResult<List<Integer>>> handler)
Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
|
SQLConnection |
SQLConnection.batchCallableWithParams(String sqlStatement,
List<JsonArray> inArgs,
List<JsonArray> outArgs,
Handler<AsyncResult<List<Integer>>> handler)
Batch a callable statement with all entries from the args list.
|
SQLConnection |
SQLConnection.batchWithParams(String sqlStatement,
List<JsonArray> args,
Handler<AsyncResult<List<Integer>>> handler)
Batch a prepared statement with all entries from the args list.
|
SQLConnection |
SQLConnection.call(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLClient |
SQLClient.call(String sql,
Handler<AsyncResult<ResultSet>> handler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLOperations |
SQLOperations.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. |
SQLClient |
SQLClient.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> handler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLOperations |
SQLOperations.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
void |
SQLRowStream.close(Handler<AsyncResult<Void>> handler)
Closes the stream/underlying cursor(s).
|
void |
SQLConnection.close(Handler<AsyncResult<Void>> handler)
Closes the connection.
|
void |
SQLClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release all resources.
|
SQLConnection |
SQLConnection.commit(Handler<AsyncResult<Void>> handler)
Commits all changes made since the previous commit/rollback.
|
SQLRowStream |
SQLRowStream.endHandler(Handler<Void> endHandler) |
SQLRowStream |
SQLRowStream.exceptionHandler(Handler<Throwable> handler) |
SQLConnection |
SQLConnection.execute(String sql,
Handler<AsyncResult<Void>> resultHandler)
Executes the given SQL statement
|
SQLClient |
SQLClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
SQLConnection |
SQLConnection.getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)
Attempts to return the transaction isolation level for this Connection object to the one given.
|
SQLRowStream |
SQLRowStream.handler(Handler<JsonArray> handler) |
void |
SQLRowStream.pipeTo(WriteStream<JsonArray> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
SQLConnection |
SQLConnection.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
SQLClient |
SQLClient.query(String sql,
Handler<AsyncResult<ResultSet>> handler)
Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL
statement and returns it back after the execution.
|
SQLOperations |
SQLOperations.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
SQLOperations |
SQLConnection.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
SQLClient.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
SQLOperations.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
SQLConnection.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLOperations |
SQLClient.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLOperations |
SQLOperations.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLConnection |
SQLConnection.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLClient |
SQLClient.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLOperations |
SQLOperations.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLConnection |
SQLConnection.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLClient |
SQLClient.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLOperations |
SQLOperations.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
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. |
SQLClient |
SQLClient.queryWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<ResultSet>> handler)
Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL
prepared statement and returns it back after the execution.
|
SQLOperations |
SQLOperations.queryWithParams(String sql,
JsonArray params,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT prepared statement which returns the results of the query. |
SQLRowStream |
SQLRowStream.resultSetClosedHandler(Handler<Void> handler)
Event handler when a resultset is closed.
|
SQLConnection |
SQLConnection.rollback(Handler<AsyncResult<Void>> handler)
Rolls back all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.setAutoCommit(boolean autoCommit,
Handler<AsyncResult<Void>> resultHandler)
Sets the auto commit flag for this connection.
|
SQLConnection |
SQLConnection.setTransactionIsolation(TransactionIsolation isolation,
Handler<AsyncResult<Void>> handler)
Attempts to change the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.update(String sql,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given SQL statement which may be an
INSERT, UPDATE, or DELETE
statement. |
SQLClient |
SQLClient.update(String sql,
Handler<AsyncResult<UpdateResult>> handler)
Executes the given SQL statement which may be an
INSERT, UPDATE, or DELETE
statement. |
SQLOperations |
SQLOperations.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 |
SQLClient |
SQLClient.updateWithParams(String sql,
JsonArray params,
Handler<AsyncResult<UpdateResult>> handler)
Executes the given prepared statement which may be an
INSERT, UPDATE, or DELETE
statement with the given parameters |
SQLOperations |
SQLOperations.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 | Method and Description |
|---|---|
Handler<ServerWebSocket> |
StompServer.webSocketHandler()
Gets the able to manage web socket connections.
|
| Modifier and Type | Method and Description |
|---|---|
StompClientConnection |
StompClientConnection.abort(String id,
Handler<AsyncResult<Frame>> receiptHandler)
Aborts a transaction.
|
StompClientConnection |
StompClientConnection.abort(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Sends an acknowledgement for a specific message.
|
StompClientConnection |
StompClientConnection.ack(String id,
String txId,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Begins a transaction.
|
StompClientConnection |
StompClientConnection.beginTX(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Commits a transaction.
|
StompClientConnection |
StompClientConnection.commit(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Disconnects the client.
|
StompClientConnection |
StompClientConnection.disconnect(Handler<AsyncResult<Frame>> receiptHandler)
Disconnects the client.
|
StompServerHandler |
StompServerHandler.disconnectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
DISCONNECT frame is received. |
StompClient |
StompClient.errorFrameHandler(Handler<Frame> handler)
A general error frame handler.
|
StompClientConnection |
StompClientConnection.errorHandler(Handler<Frame> handler)
Sets a handler notified when an
ERROR frame is received by the client. |
StompClientConnection |
StompClientConnection.exceptionHandler(Handler<Throwable> exceptionHandler)
Configures the exception handler notified upon TCP-level errors.
|
StompClient |
StompClient.exceptionHandler(Handler<Throwable> handler)
Sets an exception handler notified for TCP-level errors.
|
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<AsyncResult<Frame>> receiptHandler)
Sends a non-acknowledgement for the given message.
|
StompClientConnection |
StompClientConnection.nack(String id,
String txId,
Handler<AsyncResult<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(StompServerConnection connection,
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.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that get notified when a STOMP frame is received by the client.
|
StompClient |
StompClient.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that gets notified when a STOMP frame is received by the client.
|
StompServerHandler |
StompServerHandler.receivedFrameHandler(Handler<ServerFrame> handler)
Configures a handler that get notified when a STOMP frame is received by the server.
|
Single<String> |
StompClientConnection.rxSubscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
Single<String> |
StompClientConnection.rxSubscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.send(Frame frame,
Handler<AsyncResult<Frame>> receiptHandler)
Sends the given frame to the server.
|
StompClientConnection |
StompClientConnection.send(Map<String,String> headers,
Buffer body,
Handler<AsyncResult<Frame>> receiptHandler)
Sends a
SEND frame to the server. |
StompClientConnection |
StompClientConnection.send(String destination,
Buffer body,
Handler<AsyncResult<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<AsyncResult<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. |
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<AsyncResult<String>> 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<AsyncResult<Frame>> receiptHandler)
Un-subscribes from the given destination.
|
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Map<String,String> headers,
Handler<AsyncResult<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. |
StompClientConnection |
StompClientConnection.writingFrameHandler(Handler<Frame> handler)
Configures a handler notified when a frame is going to be written on the wire.
|
StompClient |
StompClient.writingFrameHandler(Handler<Frame> handler)
Configures a writing handler that gets notified when a STOMP frame is written on the wire.
|
StompServer |
StompServer.writingFrameHandler(Handler<ServerFrame> handler)
Configures the handler that is invoked every time a frame is going to be written to the "wire".
|
| Modifier and Type | Method and Description |
|---|---|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it completes the async operation.
When the returned handler is called back with a failed result it fails the test with the cause of the failure.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
Handler<Throwable> |
TestContext.exceptionHandler() |
| Modifier and Type | Method and Description |
|---|---|
TestSuite |
TestSuite.after(Handler<TestContext> callback)
Set a callback executed after the tests.
|
TestSuite |
TestSuite.afterEach(Handler<TestContext> callback)
Set a callback executed after each test and before the suite
after callback. |
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
TestSuite |
TestSuite.before(Handler<TestContext> callback)
Set a callback executed before the tests.
|
TestSuite |
TestSuite.beforeEach(Handler<TestContext> callback)
Set a callback executed before each test and after the suite
before callback. |
static TestCase |
TestCase.create(String name,
Handler<TestContext> testCase)
Create a test case.
|
void |
Completion.handler(Handler<AsyncResult<T>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
void |
Async.handler(Handler<AsyncResult<Void>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
void |
TestCompletion.handler(Handler<AsyncResult<Void>> 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.
|
TestContext |
TestContext.verify(Handler<Void> block)
Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.
|
| 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) |
void |
TestSuiteReport.pipeTo(WriteStream<TestCaseReport> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
| Modifier and Type | Method and Description |
|---|---|
int |
RoutingContext.addBodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
int |
RoutingContext.addEndHandler(Handler<AsyncResult<Void>> handler)
Add an end handler for the request/response context.
|
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.reactivex.ext.web.RoutingContext>) called with ordered = true |
Route |
Route.blockingHandler(Handler<RoutingContext> requestHandler,
boolean ordered)
Specify a blocking request handler for the route.
|
RoutingContext |
RoutingContext.end(Buffer buffer,
Handler<AsyncResult<Void>> handler)
|
RoutingContext |
RoutingContext.end(Handler<AsyncResult<Void>> handler)
|
RoutingContext |
RoutingContext.end(String chunk,
Handler<AsyncResult<Void>> handler)
|
Router |
Router.errorHandler(int statusCode,
Handler<RoutingContext> errorHandler)
Specify an handler to handle an error for a particular status code.
|
Route |
Route.failureHandler(Handler<RoutingContext> failureHandler)
Append a failure handler to the route failure handlers list.
|
Route |
Route.handler(Handler<RoutingContext> requestHandler)
Append a request handler to the route handlers list.
|
RoutingContext |
RoutingContext.json(Object json,
Handler<AsyncResult<Void>> handler)
|
Router |
Router.modifiedHandler(Handler<Router> handler)
When a Router routes are changed this handler is notified.
|
RoutingContext |
RoutingContext.redirect(String url,
Handler<AsyncResult<Void>> handler)
|
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
RouterFactory.getValidationFailureHandler()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
RouterFactory |
RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
|
RouterFactory |
RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
|
RouterFactory |
RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
OpenAPI3RouterFactory.getValidationFailureHandler()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addFailureHandlerByOperationId(String operationId,
Handler<RoutingContext> failureHandler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addHandlerByOperationId(String operationId,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String securitySchemaName,
String scopeName,
Handler<RoutingContext> handler)
Deprecated.
|
static void |
OpenAPI3RouterFactory.create(Vertx vertx,
String url,
Handler<AsyncResult<OpenAPI3RouterFactory>> handler)
Deprecated.
|
static void |
OpenAPI3RouterFactory.create(Vertx vertx,
String url,
List<JsonObject> auth,
Handler<AsyncResult<OpenAPI3RouterFactory>> handler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
TemplateEngine.render(JsonObject context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render the template.
|
void |
TemplateEngine.render(Map<String,Object> context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render the template.
|
| Modifier and Type | Method and Description |
|---|---|
MultiTenantHandler |
MultiTenantHandler.addDefaultHandler(Handler<RoutingContext> handler)
Add a default handler for the case when no tenant was matched.
|
MultiTenantHandler |
MultiTenantHandler.addTenantHandler(String tenant,
Handler<RoutingContext> handler)
Add a handler for a given tenant to this handler.
|
SessionHandler |
SessionHandler.flush(RoutingContext ctx,
boolean ignoreStatus,
Handler<AsyncResult<Void>> handler)
Flush a context session earlier to the store, this will allow the end user to have full control on the event of
a failure at the store level.
|
SessionHandler |
SessionHandler.flush(RoutingContext ctx,
Handler<AsyncResult<Void>> handler)
Flush a context session earlier to the store, this will allow the end user to have full control on the event of
a failure at the store level.
|
SessionHandler |
SessionHandler.setUser(RoutingContext context,
User user,
Handler<AsyncResult<Void>> handler)
Set the user for the session
|
| Modifier and Type | Method and Description |
|---|---|
ApolloWSHandler |
ApolloWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>> config)
Set a callback to invoke before executing a GraphQL query.
|
GraphQLHandler |
GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> config)
Set a callback to invoke before executing a GraphQL query.
|
ApolloWSHandler |
ApolloWSHandler.connectionHandler(Handler<ServerWebSocket> connectionHandler)
Customize the connection .
|
ApolloWSHandler |
ApolloWSHandler.connectionInitHandler(Handler<ApolloWSConnectionInitEvent> connectionInitHandler)
Customize the connection init .
|
ApolloWSHandler |
ApolloWSHandler.endHandler(Handler<ServerWebSocket> endHandler)
Customize the end .
|
ApolloWSHandler |
ApolloWSHandler.messageHandler(Handler<ApolloWSMessage> messageHandler)
Customize the message .
|
| Modifier and Type | Method and Description |
|---|---|
GraphQLWSHandler |
GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> config)
Set a callback to invoke before executing a GraphQL query.
|
GraphQLWSHandler |
GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent> connectionInitHandler)
Customize the connection init .
|
| Modifier and Type | Method and Description |
|---|---|
Router |
SockJSHandler.bridge(AuthorizationProvider authorizationProvider,
SockJSBridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions) but specifying a handler
that will receive bridge events. |
Router |
SockJSHandler.bridge(SockJSBridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions) but specifying a handler
that will receive bridge events. |
SockJSSocket |
SockJSSocket.closeHandler(Handler<Void> closeHandler) |
SockJSSocket |
SockJSSocket.drainHandler(Handler<Void> handler) |
void |
SockJSSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
SockJSSocket.end(Handler<AsyncResult<Void>> handler)
Same as
SockJSSocket.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
SockJSSocket |
SockJSSocket.endHandler(Handler<Void> endHandler) |
SockJSSocket |
SockJSSocket.exceptionHandler(Handler<Throwable> handler) |
SockJSSocket |
SockJSSocket.handler(Handler<Buffer> handler) |
void |
SockJSSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
Router |
SockJSHandler.socketHandler(Handler<SockJSSocket> handler)
Set a SockJS socket handler.
|
void |
SockJSSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler) |
void |
SockJSSocket.write(String data,
Handler<AsyncResult<Void>> handler) |
| Modifier and Type | Method and Description |
|---|---|
static void |
RouterBuilder.create(Vertx vertx,
String url,
Handler<AsyncResult<RouterBuilder>> handler)
Like
|
static void |
RouterBuilder.create(Vertx vertx,
String url,
OpenAPILoaderOptions options,
Handler<AsyncResult<RouterBuilder>> handler)
Like
|
Operation |
Operation.failureHandler(Handler<RoutingContext> handler)
Mount a failure handler for this operation
|
Operation |
Operation.handler(Handler<RoutingContext> handler)
Mount an handler for this operation
|
RouterBuilder |
RouterBuilder.rootHandler(Handler<RoutingContext> rootHandler)
Add global handler to be applied prior to being generated.
|
| Modifier and Type | Method and Description |
|---|---|
SessionStore |
SessionStore.clear(Handler<AsyncResult<Void>> resultHandler)
Remove all sessions from the store.
|
SessionStore |
SessionStore.delete(String id,
Handler<AsyncResult<Void>> resultHandler)
Delete the session with the specified ID.
|
SessionStore |
SessionStore.get(String cookieValue,
Handler<AsyncResult<Session>> resultHandler)
Get the session with the specified ID.
|
SessionStore |
SessionStore.put(Session session,
Handler<AsyncResult<Void>> resultHandler)
Add a session with the specified ID.
|
SessionStore |
SessionStore.size(Handler<AsyncResult<Integer>> resultHandler)
Get the number of sessions in the store.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SchemaRouter.resolveRef(JsonPointer pointer,
JsonPointer scope,
SchemaParser schemaParser,
Handler<AsyncResult<Schema>> handler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KafkaAdminClient.close(Handler<AsyncResult<Void>> handler)
Close the admin client
|
void |
KafkaAdminClient.close(long timeout,
Handler<AsyncResult<Void>> handler)
Close the admin client
|
void |
KafkaAdminClient.createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Create the ACL rules.
|
void |
KafkaAdminClient.createPartitions(Map<String,NewPartitions> partitions,
Handler<AsyncResult<Void>> completionHandler)
Creates a batch of new partitions in the Kafka topic
|
void |
KafkaAdminClient.createTopics(List<NewTopic> topics,
Handler<AsyncResult<Void>> completionHandler)
Creates a batch of new Kafka topics
|
void |
KafkaAdminClient.deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Delete the ACL rules.
|
void |
KafkaAdminClient.deleteConsumerGroupOffsets(String groupId,
Set<TopicPartition> partitions,
Handler<AsyncResult<Void>> completionHandler)
Delete committed offsets for a set of partitions in a consumer group.
|
void |
KafkaAdminClient.deleteConsumerGroups(List<String> groupIds,
Handler<AsyncResult<Void>> completionHandler)
Delete consumer groups from the cluster.
|
void |
KafkaAdminClient.deleteTopics(List<String> topicNames,
Handler<AsyncResult<Void>> completionHandler)
Deletes a batch of Kafka topics
|
void |
KafkaAdminClient.describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Describe the ACL rules.
|
void |
KafkaAdminClient.describeCluster(DescribeClusterOptions options,
Handler<AsyncResult<ClusterDescription>> completionHandler)
Like
KafkaAdminClient.describeCluster(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.kafka.admin.ClusterDescription>>) but allows customized options. |
void |
KafkaAdminClient.describeCluster(Handler<AsyncResult<ClusterDescription>> completionHandler)
Describe the nodes in the cluster with the default options
|
void |
KafkaAdminClient.describeConsumerGroups(List<String> groupIds,
DescribeConsumerGroupsOptions options,
Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)
|
void |
KafkaAdminClient.describeConsumerGroups(List<String> groupIds,
Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)
Describe some group ids in the cluster, with the default options
|
void |
KafkaAdminClient.describeTopics(List<String> topicNames,
DescribeTopicsOptions options,
Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)
|
void |
KafkaAdminClient.describeTopics(List<String> topicNames,
Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)
Describe some topics in the cluster, with the default options.
|
void |
KafkaAdminClient.listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)
Get the the consumer groups available in the cluster with the default options
|
void |
KafkaAdminClient.listTopics(Handler<AsyncResult<Set<String>>> completionHandler)
List the topics available in the cluster with the default options.
|
| Modifier and Type | Method and Description |
|---|---|
KafkaConsumer<K,V> |
KafkaConsumer.assign(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a list of partition to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assign(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a partition to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)
Get the set of partitions currently assigned to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)
Set the handler to be used when batches of messages are fetched
from the Kafka server.
|
void |
KafkaConsumer.beginningOffsets(TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the first offset for the given partitions.
|
void |
KafkaConsumer.close(Handler<AsyncResult<Void>> completionHandler)
Close the consumer
|
void |
KafkaConsumer.commit(Handler<AsyncResult<Void>> completionHandler)
Commit current offsets for all the subscribed list of topics and partition.
|
void |
KafkaConsumer.committed(TopicPartition topicPartition,
Handler<AsyncResult<OffsetAndMetadata>> handler)
Get the last committed offset for the given partition (whether the commit happened by this process or another).
|
KafkaConsumer<K,V> |
KafkaConsumer.endHandler(Handler<Void> endHandler) |
void |
KafkaConsumer.endOffsets(TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the last offset for the given partition.
|
KafkaConsumer<K,V> |
KafkaConsumer.exceptionHandler(Handler<Throwable> handler) |
KafkaConsumer<K,V> |
KafkaConsumer.handler(Handler<KafkaConsumerRecord<K,V>> handler) |
void |
KafkaConsumer.offsetsForTimes(TopicPartition topicPartition,
Long timestamp,
Handler<AsyncResult<OffsetAndTimestamp>> handler)
Look up the offset for the given partition by timestamp.
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)
Set the handler called when topic partitions are assigned to the consumer
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsFor(String topic,
Handler<AsyncResult<List<PartitionInfo>>> handler)
Get metadata about the partitions for a given topic.
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)
Set the handler called when topic partitions are revoked to the consumer
|
KafkaConsumer<K,V> |
KafkaConsumer.pause(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.pause(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partition.
|
void |
KafkaConsumer.paused(Handler<AsyncResult<Set<TopicPartition>>> handler)
Get the set of partitions that were previously paused by a call to pause(Set).
|
void |
KafkaConsumer.pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
KafkaConsumer.poll(java.time.Duration timeout,
Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)
Executes a poll for getting messages from Kafka.
|
void |
KafkaConsumer.position(TopicPartition partition,
Handler<AsyncResult<Long>> handler)
Get the offset of the next record that will be fetched (if a record with that offset exists).
|
KafkaConsumer<K,V> |
KafkaConsumer.resume(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partitions which have been paused with pause.
|
KafkaConsumer<K,V> |
KafkaConsumer.resume(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partition which have been paused with pause.
|
KafkaConsumer<K,V> |
KafkaConsumer.seek(TopicPartition topicPartition,
long offset,
Handler<AsyncResult<Void>> completionHandler)
Overrides the fetch offsets that the consumer will use on the next poll.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToBeginning(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToBeginning(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partition.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToEnd(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToEnd(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partition.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(Set<String> topics,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given list of topics to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(String topic,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given topic to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscription(Handler<AsyncResult<Set<String>>> handler)
Get the current subscription.
|
KafkaConsumer<K,V> |
KafkaConsumer.unsubscribe(Handler<AsyncResult<Void>> completionHandler)
Unsubscribe from topics currently subscribed with subscribe.
|
| Modifier and Type | Method and Description |
|---|---|
KafkaProducer<K,V> |
KafkaProducer.abortTransaction(Handler<AsyncResult<Void>> handler)
Aborts the ongoing transaction.
|
KafkaProducer<K,V> |
KafkaProducer.beginTransaction(Handler<AsyncResult<Void>> handler)
Starts a new kafka transaction.
|
void |
KafkaProducer.close(Handler<AsyncResult<Void>> completionHandler)
Close the producer
|
void |
KafkaProducer.close(long timeout,
Handler<AsyncResult<Void>> completionHandler)
Close the producer
|
KafkaProducer<K,V> |
KafkaProducer.commitTransaction(Handler<AsyncResult<Void>> handler)
Commits the ongoing transaction.
|
KafkaProducer<K,V> |
KafkaProducer.drainHandler(Handler<Void> handler) |
void |
KafkaProducer.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
KafkaProducer.end(KafkaProducerRecord<K,V> data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
KafkaProducer<K,V> |
KafkaProducer.exceptionHandler(Handler<Throwable> handler) |
KafkaProducer<K,V> |
KafkaProducer.flush(Handler<AsyncResult<Void>> completionHandler)
Invoking this method makes all buffered records immediately available to write
|
KafkaProducer<K,V> |
KafkaProducer.initTransactions(Handler<AsyncResult<Void>> handler)
Initializes the underlying kafka transactional producer.
|
KafkaProducer<K,V> |
KafkaProducer.partitionsFor(String topic,
Handler<AsyncResult<List<PartitionInfo>>> handler)
Get the partition metadata for the give topic.
|
KafkaProducer<K,V> |
KafkaProducer.send(KafkaProducerRecord<K,V> record,
Handler<AsyncResult<RecordMetadata>> handler)
Asynchronously write a record to a topic
|
void |
KafkaProducer.write(KafkaProducerRecord<K,V> data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
static Handler<RoutingContext> |
PrometheusScrapingHandler.create()
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
static Handler<RoutingContext> |
PrometheusScrapingHandler.create(io.micrometer.prometheus.PrometheusMeterRegistry registry)
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
static Handler<RoutingContext> |
PrometheusScrapingHandler.create(String registryName)
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
| Modifier and Type | Method and Description |
|---|---|
void |
MqttServer.close(Handler<AsyncResult<Void>> completionHandler)
Close the server supplying an handler that will be called when the server is actually closed (or has failed).
|
MqttClient |
MqttClient.closeHandler(Handler<Void> closeHandler)
Set a handler that will be called when the connection with server is closed
|
MqttEndpoint |
MqttEndpoint.closeHandler(Handler<Void> handler)
Set a close handler.
|
MqttClient |
MqttClient.connect(int port,
String host,
Handler<AsyncResult<MqttConnAckMessage>> connectHandler)
Connects to an MQTT server calling connectHandler after connection
|
MqttClient |
MqttClient.connect(int port,
String host,
String serverName,
Handler<AsyncResult<MqttConnAckMessage>> connectHandler)
Connects to an MQTT server calling connectHandler after connection
|
MqttClient |
MqttClient.disconnect(Handler<AsyncResult<Void>> disconnectHandler)
Disconnects from the MQTT server calling disconnectHandler after disconnection
|
MqttEndpoint |
MqttEndpoint.disconnectHandler(Handler<Void> handler)
Set a disconnect handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)
Set a disconnect handler on the MQTT endpoint.
|
MqttServer |
MqttServer.endpointHandler(Handler<MqttEndpoint> handler)
Set the endpoint handler for the server.
|
MqttClient |
MqttClient.exceptionHandler(Handler<Throwable> handler)
Set an exception handler for the client, that will be called when an error happens
in internal netty structures.
|
MqttEndpoint |
MqttEndpoint.exceptionHandler(Handler<Throwable> handler)
Set an exception handler.
|
MqttServer |
MqttServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler for the server, that will be called when an error happens independantly of an
accepted
MqttEndpoint, like a rejected connection |
MqttServer |
MqttServer.listen(Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections using the specified options
through the constructor
|
MqttServer |
MqttServer.listen(int port,
Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections on the port specified but on
"0.0.0.0" as host.
|
MqttServer |
MqttServer.listen(int port,
String host,
Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections on the port and host specified
It ignores any options specified through the constructor
|
MqttEndpoint |
MqttEndpoint.pingHandler(Handler<Void> handler)
Set the pingreq handler on the MQTT endpoint.
|
MqttClient |
MqttClient.pingResponseHandler(Handler<Void> pingResponseHandler)
Sets handler which will be called after PINGRESP packet receiving
|
MqttClient |
MqttClient.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
int messageId,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
int messageId,
io.netty.handler.codec.mqtt.MqttProperties properties,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
|
MqttEndpoint |
MqttEndpoint.publishAcknowledgeHandler(Handler<Integer> handler)
Set the puback handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)
Set the puback handler on the MQTT endpoint.
|
MqttClient |
MqttClient.publishCompletionExpirationHandler(Handler<Integer> publishCompletionExpirationHandler)
Sets a handler which will be called when the client does not receive a PUBACK or
PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
|
MqttClient |
MqttClient.publishCompletionHandler(Handler<Integer> publishCompletionHandler)
Sets a handler which will be called each time the publishing of a message has been completed.
|
MqttEndpoint |
MqttEndpoint.publishCompletionHandler(Handler<Integer> handler)
Set the pubcomp handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)
Set the pubcomp handler on the MQTT endpoint.
|
MqttClient |
MqttClient.publishCompletionUnknownPacketIdHandler(Handler<Integer> publishCompletionPhantomHandler)
Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown
packet ID.
|
MqttClient |
MqttClient.publishHandler(Handler<MqttPublishMessage> publishHandler)
Sets handler which will be called each time server publish something to client
|
MqttEndpoint |
MqttEndpoint.publishHandler(Handler<MqttPublishMessage> handler)
Set the publish handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReceivedHandler(Handler<Integer> handler)
Set the pubrec handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)
Set the pubrec handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReleaseHandler(Handler<Integer> handler)
Set the pubrel handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)
Set the pubrel handler on the MQTT endpoint.
|
MqttClient |
MqttClient.subscribe(Map<String,Integer> topics,
Handler<AsyncResult<Integer>> subscribeSentHandler)
Subscribes to the topic and adds a handler which will be called after the request is sent
|
MqttClient |
MqttClient.subscribe(String topic,
int qos,
Handler<AsyncResult<Integer>> subscribeSentHandler)
Subscribes to the topic with a specified QoS level
|
MqttClient |
MqttClient.subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)
Sets handler which will be called after SUBACK packet receiving
|
MqttEndpoint |
MqttEndpoint.subscribeHandler(Handler<MqttSubscribeMessage> handler)
Set a subscribe handler on the MQTT endpoint.
|
MqttClient |
MqttClient.unsubscribe(String topic,
Handler<AsyncResult<Integer>> unsubscribeSentHandler)
Unsubscribe from receiving messages on given topic
|
MqttClient |
MqttClient.unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)
Sets handler which will be called after UNSUBACK packet receiving
|
MqttEndpoint |
MqttEndpoint.unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)
Set a unsubscribe handler on the MQTT endpoint.
|
| Modifier and Type | Method and Description |
|---|---|
MSSQLConnection |
MSSQLConnection.closeHandler(Handler<Void> handler) |
static void |
MSSQLConnection.connect(Vertx vertx,
MSSQLConnectOptions connectOptions,
Handler<AsyncResult<MSSQLConnection>> handler)
Create a connection to SQL Server with the given
connectOptions. |
static void |
MSSQLConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<MSSQLConnection>> handler)
|
MSSQLPool |
MSSQLPool.connectHandler(Handler<SqlConnection> handler) |
MSSQLConnection |
MSSQLConnection.exceptionHandler(Handler<Throwable> handler) |
MSSQLConnection |
MSSQLConnection.infoHandler(Handler<MSSQLInfo> handler)
Set a handler called when the connection receives an informational message from the server.
|
MSSQLConnection |
MSSQLConnection.prepare(String s,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
MySQLConnection |
MySQLConnection.changeUser(MySQLAuthOptions options,
Handler<AsyncResult<Void>> handler)
Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
|
MySQLConnection |
MySQLConnection.closeHandler(Handler<Void> handler) |
static void |
MySQLConnection.connect(Vertx vertx,
MySQLConnectOptions connectOptions,
Handler<AsyncResult<MySQLConnection>> handler)
Create a connection to MySQL server with the given
connectOptions. |
static void |
MySQLConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<MySQLConnection>> handler)
|
MySQLPool |
MySQLPool.connectHandler(Handler<SqlConnection> handler) |
MySQLConnection |
MySQLConnection.debug(Handler<AsyncResult<Void>> handler)
Send a DEBUG command to dump debug information to the server's stdout.
|
MySQLConnection |
MySQLConnection.exceptionHandler(Handler<Throwable> handler) |
MySQLConnection |
MySQLConnection.getInternalStatistics(Handler<AsyncResult<String>> handler)
Send a STATISTICS command to get a human readable string of the server internal status.
|
MySQLConnection |
MySQLConnection.ping(Handler<AsyncResult<Void>> handler)
Send a PING command to check if the server is alive.
|
MySQLConnection |
MySQLConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
MySQLConnection |
MySQLConnection.resetConnection(Handler<AsyncResult<Void>> handler)
Send a RESET_CONNECTION command to reset the session state.
|
MySQLConnection |
MySQLConnection.setOption(MySQLSetOption option,
Handler<AsyncResult<Void>> handler)
Send a SET_OPTION command to set options for the current connection.
|
MySQLConnection |
MySQLConnection.specifySchema(String schemaName,
Handler<AsyncResult<Void>> handler)
Send a INIT_DB command to change the default schema of the connection.
|
| Modifier and Type | Method and Description |
|---|---|
OracleConnection |
OracleConnection.closeHandler(Handler<Void> handler) |
static void |
OracleConnection.connect(Vertx vertx,
io.vertx.oracleclient.OracleConnectOptions connectOptions,
Handler<AsyncResult<OracleConnection>> handler)
Create a connection to Oracle with the given
connectOptions. |
OraclePool |
OraclePool.connectHandler(Handler<SqlConnection> handler) |
OracleConnection |
OracleConnection.exceptionHandler(Handler<Throwable> handler) |
OracleConnection |
OracleConnection.prepare(String s,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
PgConnection |
PgConnection.cancelRequest(Handler<AsyncResult<Void>> handler)
Send a request cancellation message to tell the server to cancel processing request in this connection.
|
PgConnection |
PgConnection.closeHandler(Handler<Void> handler) |
static void |
PgConnection.connect(Vertx vertx,
Handler<AsyncResult<PgConnection>> handler)
Like
PgConnection.connect(io.vertx.reactivex.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.pgclient.PgConnection>>) with options build from the environment variables. |
static void |
PgConnection.connect(Vertx vertx,
PgConnectOptions options,
Handler<AsyncResult<PgConnection>> handler)
Connects to the database and returns the connection if that succeeds.
|
static void |
PgConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<PgConnection>> handler)
|
PgPool |
PgPool.connectHandler(Handler<SqlConnection> handler) |
PgConnection |
PgConnection.exceptionHandler(Handler<Throwable> handler) |
PgConnection |
PgConnection.noticeHandler(Handler<PgNotice> handler)
Set a handler called when the connection receives a notice from the server.
|
PgConnection |
PgConnection.notificationHandler(Handler<PgNotification> handler)
Set a handler called when the connection receives notification on a channel.
|
PgConnection |
PgConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
void |
PgSubscriber.close(Handler<AsyncResult<Void>> handler)
Close the subscriber, the retry policy will not be invoked.
|
PgSubscriber |
PgSubscriber.closeHandler(Handler<Void> handler)
Set an handler called when the subscriber is closed.
|
PgSubscriber |
PgSubscriber.connect(Handler<AsyncResult<Void>> handler)
Connect the subscriber to Postgres.
|
PgChannel |
PgChannel.endHandler(Handler<Void> endHandler)
Set an handler to be called when no more notifications will be received.
|
PgChannel |
PgChannel.exceptionHandler(Handler<Throwable> handler) |
PgChannel |
PgChannel.handler(Handler<String> handler)
Set or unset an handler to be called when a the channel is notified by Postgres.
|
void |
PgChannel.pipeTo(WriteStream<String> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
PgChannel |
PgChannel.subscribeHandler(Handler<Void> handler)
Set an handler called when the the channel get subscribed.
|
| Modifier and Type | Method and Description |
|---|---|
void |
RabbitMQClient.addConfirmListener(int maxQueueSize,
Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)
Add a Confirm Listener to the channel.
|
void |
RabbitMQClient.basicAck(long deliveryTag,
boolean multiple,
Handler<AsyncResult<Void>> resultHandler)
Acknowledge one or several received messages.
|
void |
RabbitMQClient.basicConsumer(String queue,
Handler<AsyncResult<RabbitMQConsumer>> resultHandler) |
void |
RabbitMQClient.basicConsumer(String queue,
QueueOptions options,
Handler<AsyncResult<RabbitMQConsumer>> resultHandler)
Create a consumer with the given
options. |
void |
RabbitMQClient.basicGet(String queue,
boolean autoAck,
Handler<AsyncResult<RabbitMQMessage>> resultHandler)
Retrieve a message from a queue using AMQP.Basic.Get
|
void |
RabbitMQClient.basicNack(long deliveryTag,
boolean multiple,
boolean requeue,
Handler<AsyncResult<Void>> resultHandler)
Reject one or several received messages.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicQos(int prefetchCount,
boolean global,
Handler<AsyncResult<Void>> resultHandler)
Request a specific prefetchCount "quality of service" settings
for this channel.
|
void |
RabbitMQClient.basicQos(int prefetchCount,
Handler<AsyncResult<Void>> resultHandler)
Request a specific prefetchCount "quality of service" settings
for this channel.
|
void |
RabbitMQClient.basicQos(int prefetchSize,
int prefetchCount,
boolean global,
Handler<AsyncResult<Void>> resultHandler)
Request specific "quality of service" settings.
|
void |
RabbitMQConsumer.cancel(Handler<AsyncResult<Void>> cancelResult)
Stop message consumption from a queue.
|
void |
RabbitMQClient.confirmSelect(Handler<AsyncResult<Void>> resultHandler)
Enables publisher acknowledgements on this channel.
|
RabbitMQConsumer |
RabbitMQConsumer.endHandler(Handler<Void> endHandler)
Set an end handler.
|
RabbitMQConsumer |
RabbitMQConsumer.exceptionHandler(Handler<Throwable> exceptionHandler)
Set an exception handler on the read stream.
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
JsonObject config,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
|
void |
RabbitMQClient.exchangeDelete(String exchange,
Handler<AsyncResult<Void>> resultHandler)
Delete an exchange, without regard for whether it is in use or not.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
RabbitMQConsumer |
RabbitMQConsumer.handler(Handler<RabbitMQMessage> messageArrived)
Set a message handler.
|
void |
RabbitMQClient.messageCount(String queue,
Handler<AsyncResult<Long>> resultHandler)
Returns the number of messages in a queue ready to be delivered.
|
void |
RabbitMQConsumer.pipeTo(WriteStream<RabbitMQMessage> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
RabbitMQPublisher.publish(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Declare a queue
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
JsonObject config,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Declare a queue with config options
|
void |
RabbitMQClient.queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)
Actively declare a server-named exclusive, autodelete, non-durable queue.
|
void |
RabbitMQClient.queueDelete(String queue,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Delete a queue, without regard for whether it is in use or has messages on it
|
void |
RabbitMQClient.queueDeleteIf(String queue,
boolean ifUnused,
boolean ifEmpty,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Delete a queue
|
void |
RabbitMQClient.queueUnbind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind a queue from an exchange
|
void |
RabbitMQClient.queueUnbind(String queue,
String exchange,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Unbind a queue from an exchange
|
void |
RabbitMQClient.restartConnect(int attempts,
Handler<AsyncResult<Void>> resultHandler)
restart the rabbitMQ connect.
|
Completable |
RabbitMQClient.rxBasicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler)
Publish a message.
|
void |
RabbitMQClient.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ client.
|
void |
RabbitMQPublisher.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ publisher.
|
void |
RabbitMQClient.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ client.
|
void |
RabbitMQPublisher.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ publisher.
|
void |
RabbitMQClient.waitForConfirms(Handler<AsyncResult<Void>> resultHandler)
Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
|
void |
RabbitMQClient.waitForConfirms(long timeout,
Handler<AsyncResult<Void>> resultHandler)
Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(JsonObject filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(String id,
Handler<AsyncResult<Record>> resultHandler)
Looks up for a single record by its registration
id. |
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(JsonObject filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
ServiceDiscovery |
ServiceDiscovery.registerServiceExporter(ServiceExporter exporter,
JsonObject configuration,
Handler<AsyncResult<Void>> completionHandler)
Registers a discovery bridge.
|
ServiceDiscovery |
ServiceDiscovery.registerServiceImporter(ServiceImporter importer,
JsonObject configuration,
Handler<AsyncResult<Void>> completionHandler)
Registers a discovery service importer.
|
void |
ServiceDiscovery.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServiceDiscovery.update(Record record,
Handler<AsyncResult<Record>> resultHandler)
Updates the given record.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ServiceExporter.close(Handler<Void> closeHandler)
Close the exporter
|
void |
ServiceImporter.close(Handler<Void> closeHandler)
Closes the importer
|
void |
ServicePublisher.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
void |
ServicePublisher.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServicePublisher.update(Record record,
Handler<AsyncResult<Record>> resultHandler)
Updates an existing record.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject conf,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject conf,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static <T> void |
MessageSource.getConsumer(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<MessageConsumer<T>>> resultHandler)
Convenient method that looks for a message source and provides the configured .
|
static <T> void |
MessageSource.getConsumer(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<MessageConsumer<T>>> resultHandler)
Convenient method that looks for a message source and provides the configured .
|
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
MongoDataSource.getMongoClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<MongoClient>> resultHandler)
Convenient method that looks for a Mongo datasource source and provides the configured
MongoClient. |
static void |
MongoDataSource.getMongoClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<MongoClient>> resultHandler)
Convenient method that looks for a Mongo datasource source and provides the configured
MongoClient. |
static void |
MongoDataSource.getMongoClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<MongoClient>> resultHandler)
Convenient method that looks for a Mongo datasource source and provides the configured
MongoClient. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static <T> T |
EventBusService.getServiceProxy(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Class<T> clientClass,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> T |
EventBusService.getServiceProxy(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Class<T> clientClass,
JsonObject conf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> T |
EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery,
JsonObject filter,
Class<T> clientClass,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> T |
EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery,
JsonObject filter,
Class<T> clientClass,
JsonObject conf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject conf,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject conf,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
| Modifier and Type | Method and Description |
|---|---|
void |
SqlConnection.begin(Handler<AsyncResult<Transaction>> handler)
Begin a transaction and returns a
Transaction for controlling and tracking
this transaction. |
void |
PreparedStatement.close(Handler<AsyncResult<Void>> completionHandler)
Like
PreparedStatement.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but notifies the completionHandler when it's closed. |
void |
SqlConnection.close(Handler<AsyncResult<Void>> handler)
Close the current connection after all the pending commands have been processed.
|
void |
Pool.close(Handler<AsyncResult<Void>> handler)
Close the pool and release the associated resources.
|
void |
RowStream.close(Handler<AsyncResult<Void>> completionHandler)
Close the stream and release the resources.
|
void |
SqlClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release the associated resources.
|
void |
Cursor.close(Handler<AsyncResult<Void>> completionHandler)
Like
Cursor.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with a completionHandler called when the cursor has been released. |
SqlConnection |
SqlConnection.closeHandler(Handler<Void> handler)
Set an handler called when the connection is closed.
|
void |
Transaction.commit(Handler<AsyncResult<Void>> handler)
Like
Transaction.commit(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) with an handler to be notified when the transaction commit has completed |
void |
Transaction.completion(Handler<AsyncResult<Void>> handler)
Like
Transaction.completion(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with a callback |
Pool |
Pool.connectHandler(Handler<SqlConnection> handler)
Set an handler called when the pool has established a connection to the database.
|
RowStream<T> |
RowStream.endHandler(Handler<Void> endHandler) |
SqlConnection |
SqlConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called with connection errors.
|
RowStream<T> |
RowStream.exceptionHandler(Handler<Throwable> handler) |
void |
PreparedQuery.execute(Handler<AsyncResult<T>> handler)
Execute the query.
|
void |
Query.execute(Handler<AsyncResult<T>> handler)
Execute the query.
|
void |
PreparedQuery.execute(Tuple tuple,
Handler<AsyncResult<T>> handler)
Execute the query.
|
void |
PreparedQuery.executeBatch(List<Tuple> batch,
Handler<AsyncResult<T>> handler)
Execute the query with a batch of tuples.
|
void |
Pool.getConnection(Handler<AsyncResult<SqlConnection>> handler)
Get a connection from the pool.
|
RowStream<T> |
RowStream.handler(Handler<T> handler) |
void |
RowStream.pipeTo(WriteStream<T> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
SqlConnection |
SqlConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
SqlConnection |
SqlConnection.prepare(String sql,
PrepareOptions options,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
void |
Cursor.read(int count,
Handler<AsyncResult<RowSet<Row>>> handler)
Read rows from the cursor, the result is provided asynchronously to the
handler. |
void |
Transaction.rollback(Handler<AsyncResult<Void>> handler)
Like
Transaction.rollback(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) with an handler to be notified when the transaction rollback has completed |
<T> void |
Pool.withConnection(java.util.function.Function<SqlConnection,Future<T>> function,
Handler<AsyncResult<T>> handler)
Get a connection from the pool and execute the given
function. |
<T> void |
Pool.withConnection(Function<SqlConnection,Maybe<T>> function,
Handler<AsyncResult<T>> handler)
Get a connection from the pool and execute the given
function. |
<T> void |
Pool.withTransaction(java.util.function.Function<SqlConnection,Future<T>> function,
Handler<AsyncResult<T>> handler)
Execute the given
function within a transaction. |
<T> void |
Pool.withTransaction(Function<SqlConnection,Maybe<T>> function,
Handler<AsyncResult<T>> handler)
Execute the given
function within a transaction. |
| Modifier and Type | Method and Description |
|---|---|
void |
SqlTemplate.execute(I parameters,
Handler<AsyncResult<R>> handler)
Execute the query with the
parameters |
void |
SqlTemplate.executeBatch(List<I> batch,
Handler<AsyncResult<R>> handler)
Execute a batch query with the
batch. |
| Modifier and Type | Method and Description |
|---|---|
default RedisAPI |
RedisAPI.acl(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command acl.
|
default RedisAPI |
RedisAPI.append(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command append.
|
default RedisAPI |
RedisAPI.asking(Handler<AsyncResult<Response>> handler)
Redis command asking.
|
default RedisAPI |
RedisAPI.auth(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command auth.
|
default Redis |
Redis.batch(List<Request> commands,
Handler<AsyncResult<List<Response>>> onSend)
Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other
client users.
|
default RedisConnection |
RedisConnection.batch(List<Request> commands,
Handler<AsyncResult<List<Response>>> onSend)
Sends a list of commands in a single IO operation, this prevents any inter twinning to happen from other
client users.
|
default RedisAPI |
RedisAPI.bfAdd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfAdd.
|
default RedisAPI |
RedisAPI.bfDebug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfDebug.
|
default RedisAPI |
RedisAPI.bfExists(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfExists.
|
default RedisAPI |
RedisAPI.bfInfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfInfo.
|
default RedisAPI |
RedisAPI.bfInsert(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfInsert.
|
default RedisAPI |
RedisAPI.bfLoadchunk(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfLoadchunk.
|
default RedisAPI |
RedisAPI.bfMadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfMadd.
|
default RedisAPI |
RedisAPI.bfMexists(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfMexists.
|
default RedisAPI |
RedisAPI.bfReserve(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfReserve.
|
default RedisAPI |
RedisAPI.bfScandump(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bfScandump.
|
default RedisAPI |
RedisAPI.bgrewriteaof(Handler<AsyncResult<Response>> handler)
Redis command bgrewriteaof.
|
default RedisAPI |
RedisAPI.bgsave(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bgsave.
|
default RedisAPI |
RedisAPI.bitcount(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bitcount.
|
default RedisAPI |
RedisAPI.bitfield(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bitfield.
|
default RedisAPI |
RedisAPI.bitfieldRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bitfieldRo.
|
default RedisAPI |
RedisAPI.bitop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bitop.
|
default RedisAPI |
RedisAPI.bitpos(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bitpos.
|
default RedisAPI |
RedisAPI.blmove(String arg0,
String arg1,
String arg2,
String arg3,
String arg4,
Handler<AsyncResult<Response>> handler)
Redis command blmove.
|
default RedisAPI |
RedisAPI.blmpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command blmpop.
|
default RedisAPI |
RedisAPI.blpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command blpop.
|
default RedisAPI |
RedisAPI.brpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command brpop.
|
default RedisAPI |
RedisAPI.brpoplpush(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command brpoplpush.
|
default RedisAPI |
RedisAPI.bzmpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bzmpop.
|
default RedisAPI |
RedisAPI.bzpopmax(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bzpopmax.
|
default RedisAPI |
RedisAPI.bzpopmin(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command bzpopmin.
|
default RedisAPI |
RedisAPI.cfAdd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfAdd.
|
default RedisAPI |
RedisAPI.cfAddnx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfAddnx.
|
default RedisAPI |
RedisAPI.cfCompact(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfCompact.
|
default RedisAPI |
RedisAPI.cfCount(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfCount.
|
default RedisAPI |
RedisAPI.cfDebug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfDebug.
|
default RedisAPI |
RedisAPI.cfDel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfDel.
|
default RedisAPI |
RedisAPI.cfExists(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfExists.
|
default RedisAPI |
RedisAPI.cfInfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfInfo.
|
default RedisAPI |
RedisAPI.cfInsert(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfInsert.
|
default RedisAPI |
RedisAPI.cfInsertnx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfInsertnx.
|
default RedisAPI |
RedisAPI.cfLoadchunk(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfLoadchunk.
|
default RedisAPI |
RedisAPI.cfMexists(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfMexists.
|
default RedisAPI |
RedisAPI.cfReserve(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfReserve.
|
default RedisAPI |
RedisAPI.cfScandump(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cfScandump.
|
default RedisAPI |
RedisAPI.client(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command client.
|
default RedisConnection |
RedisConnection.close(Handler<AsyncResult<Void>> onClose)
Closes the connection or returns to the pool.
|
default RedisAPI |
RedisAPI.cluster(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cluster.
|
default RedisAPI |
RedisAPI.cmsIncrby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cmsIncrby.
|
default RedisAPI |
RedisAPI.cmsInfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cmsInfo.
|
default RedisAPI |
RedisAPI.cmsInitbydim(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cmsInitbydim.
|
default RedisAPI |
RedisAPI.cmsInitbyprob(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cmsInitbyprob.
|
default RedisAPI |
RedisAPI.cmsMerge(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cmsMerge.
|
default RedisAPI |
RedisAPI.cmsQuery(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command cmsQuery.
|
default RedisAPI |
RedisAPI.command(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command command.
|
default RedisAPI |
RedisAPI.config(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command config.
|
default Redis |
Redis.connect(Handler<AsyncResult<RedisConnection>> handler)
Connects to the redis server.
|
default RedisAPI |
RedisAPI.copy(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command copy.
|
default RedisAPI |
RedisAPI.dbsize(Handler<AsyncResult<Response>> handler)
Redis command dbsize.
|
default RedisAPI |
RedisAPI.debug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command debug.
|
default RedisAPI |
RedisAPI.decr(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command decr.
|
default RedisAPI |
RedisAPI.decrby(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command decrby.
|
default RedisAPI |
RedisAPI.del(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command del.
|
default RedisAPI |
RedisAPI.discard(Handler<AsyncResult<Response>> handler)
Redis command discard.
|
default RedisAPI |
RedisAPI.dump(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command dump.
|
default RedisAPI |
RedisAPI.echo(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command echo.
|
RedisConnection |
RedisConnection.endHandler(Handler<Void> endHandler)
Set an end handler.
|
default RedisAPI |
RedisAPI.eval(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command eval.
|
default RedisAPI |
RedisAPI.evalRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command evalRo.
|
default RedisAPI |
RedisAPI.evalsha(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command evalsha.
|
default RedisAPI |
RedisAPI.evalshaRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command evalshaRo.
|
RedisConnection |
RedisConnection.exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the read stream.
|
default RedisAPI |
RedisAPI.exec(Handler<AsyncResult<Response>> handler)
Redis command exec.
|
default RedisAPI |
RedisAPI.exists(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command exists.
|
default RedisAPI |
RedisAPI.expire(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command expire.
|
default RedisAPI |
RedisAPI.expireat(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command expireat.
|
default RedisAPI |
RedisAPI.expiretime(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command expiretime.
|
default RedisAPI |
RedisAPI.failover(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command failover.
|
default RedisAPI |
RedisAPI.fcall(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command fcall.
|
default RedisAPI |
RedisAPI.fcallRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command fcallRo.
|
default RedisAPI |
RedisAPI.flushall(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command flushall.
|
default RedisAPI |
RedisAPI.flushdb(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command flushdb.
|
default RedisAPI |
RedisAPI.ftAdd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAdd.
|
default RedisAPI |
RedisAPI.ftAggregate(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAggregate.
|
default RedisAPI |
RedisAPI.ftAliasadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAliasadd.
|
default RedisAPI |
RedisAPI.ftAliasaddifnx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAliasaddifnx.
|
default RedisAPI |
RedisAPI.ftAliasdel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAliasdel.
|
default RedisAPI |
RedisAPI.ftAliasdelifx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAliasdelifx.
|
default RedisAPI |
RedisAPI.ftAliasupdate(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAliasupdate.
|
default RedisAPI |
RedisAPI.ftAlter(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAlter.
|
default RedisAPI |
RedisAPI.ftAlterifnx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftAlterifnx.
|
default RedisAPI |
RedisAPI.ftConfig(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftConfig.
|
default RedisAPI |
RedisAPI.ftCreate(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftCreate.
|
default RedisAPI |
RedisAPI.ftCreateifnx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftCreateifnx.
|
default RedisAPI |
RedisAPI.ftCursor(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftCursor.
|
default RedisAPI |
RedisAPI.ftDebug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDebug.
|
default RedisAPI |
RedisAPI.ftDel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDel.
|
default RedisAPI |
RedisAPI.ftDictadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDictadd.
|
default RedisAPI |
RedisAPI.ftDictdel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDictdel.
|
default RedisAPI |
RedisAPI.ftDictdump(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDictdump.
|
default RedisAPI |
RedisAPI.ftDrop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDrop.
|
default RedisAPI |
RedisAPI.ftDropifx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDropifx.
|
default RedisAPI |
RedisAPI.ftDropindex(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDropindex.
|
default RedisAPI |
RedisAPI.ftDropindexifx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftDropindexifx.
|
default RedisAPI |
RedisAPI.ftExplain(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftExplain.
|
default RedisAPI |
RedisAPI.ftExplaincli(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftExplaincli.
|
default RedisAPI |
RedisAPI.ftGet(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftGet.
|
default RedisAPI |
RedisAPI.ftInfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftInfo.
|
default RedisAPI |
RedisAPI.ftList(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftList.
|
default RedisAPI |
RedisAPI.ftMget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftMget.
|
default RedisAPI |
RedisAPI.ftProfile(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftProfile.
|
default RedisAPI |
RedisAPI.ftSafeadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSafeadd.
|
default RedisAPI |
RedisAPI.ftSearch(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSearch.
|
default RedisAPI |
RedisAPI.ftSpellcheck(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSpellcheck.
|
default RedisAPI |
RedisAPI.ftSugadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSugadd.
|
default RedisAPI |
RedisAPI.ftSugdel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSugdel.
|
default RedisAPI |
RedisAPI.ftSugget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSugget.
|
default RedisAPI |
RedisAPI.ftSuglen(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSuglen.
|
default RedisAPI |
RedisAPI.ftSynadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSynadd.
|
default RedisAPI |
RedisAPI.ftSyndump(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSyndump.
|
default RedisAPI |
RedisAPI.ftSynupdate(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftSynupdate.
|
default RedisAPI |
RedisAPI.ftTagvals(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ftTagvals.
|
default RedisAPI |
RedisAPI.function(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command function.
|
default RedisAPI |
RedisAPI.geoadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command geoadd.
|
default RedisAPI |
RedisAPI.geodist(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command geodist.
|
default RedisAPI |
RedisAPI.geohash(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command geohash.
|
default RedisAPI |
RedisAPI.geopos(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command geopos.
|
default RedisAPI |
RedisAPI.georadius(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command georadius.
|
default RedisAPI |
RedisAPI.georadiusbymember(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command georadiusbymember.
|
default RedisAPI |
RedisAPI.georadiusbymemberRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command georadiusbymemberRo.
|
default RedisAPI |
RedisAPI.georadiusRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command georadiusRo.
|
default RedisAPI |
RedisAPI.geosearch(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command geosearch.
|
default RedisAPI |
RedisAPI.geosearchstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command geosearchstore.
|
default RedisAPI |
RedisAPI.get(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command get.
|
default RedisAPI |
RedisAPI.getbit(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command getbit.
|
default RedisAPI |
RedisAPI.getdel(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command getdel.
|
default RedisAPI |
RedisAPI.getex(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command getex.
|
default RedisAPI |
RedisAPI.getrange(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command getrange.
|
default RedisAPI |
RedisAPI.getset(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command getset.
|
default RedisAPI |
RedisAPI.graphBulk(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphBulk.
|
default RedisAPI |
RedisAPI.graphConfig(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphConfig.
|
default RedisAPI |
RedisAPI.graphDebug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphDebug.
|
default RedisAPI |
RedisAPI.graphDelete(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphDelete.
|
default RedisAPI |
RedisAPI.graphExplain(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphExplain.
|
default RedisAPI |
RedisAPI.graphList(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphList.
|
default RedisAPI |
RedisAPI.graphProfile(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphProfile.
|
default RedisAPI |
RedisAPI.graphQuery(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphQuery.
|
default RedisAPI |
RedisAPI.graphRoQuery(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphRoQuery.
|
default RedisAPI |
RedisAPI.graphSlowlog(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command graphSlowlog.
|
RedisConnection |
RedisConnection.handler(Handler<Response> handler)
Set a data handler.
|
default RedisAPI |
RedisAPI.hdel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hdel.
|
default RedisAPI |
RedisAPI.hello(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hello.
|
default RedisAPI |
RedisAPI.hexists(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command hexists.
|
default RedisAPI |
RedisAPI.hget(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command hget.
|
default RedisAPI |
RedisAPI.hgetall(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command hgetall.
|
default RedisAPI |
RedisAPI.hincrby(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command hincrby.
|
default RedisAPI |
RedisAPI.hincrbyfloat(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command hincrbyfloat.
|
default RedisAPI |
RedisAPI.hkeys(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command hkeys.
|
default RedisAPI |
RedisAPI.hlen(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command hlen.
|
default RedisAPI |
RedisAPI.hmget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hmget.
|
default RedisAPI |
RedisAPI.hmset(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hmset.
|
default RedisAPI |
RedisAPI.hrandfield(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hrandfield.
|
default RedisAPI |
RedisAPI.hscan(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hscan.
|
default RedisAPI |
RedisAPI.hset(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command hset.
|
default RedisAPI |
RedisAPI.hsetnx(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command hsetnx.
|
default RedisAPI |
RedisAPI.hstrlen(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command hstrlen.
|
default RedisAPI |
RedisAPI.hvals(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command hvals.
|
default RedisAPI |
RedisAPI.incr(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command incr.
|
default RedisAPI |
RedisAPI.incrby(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command incrby.
|
default RedisAPI |
RedisAPI.incrbyfloat(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command incrbyfloat.
|
default RedisAPI |
RedisAPI.info(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command info.
|
default RedisAPI |
RedisAPI.jsonArrappend(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonArrappend.
|
default RedisAPI |
RedisAPI.jsonArrindex(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonArrindex.
|
default RedisAPI |
RedisAPI.jsonArrinsert(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonArrinsert.
|
default RedisAPI |
RedisAPI.jsonArrlen(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonArrlen.
|
default RedisAPI |
RedisAPI.jsonArrpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonArrpop.
|
default RedisAPI |
RedisAPI.jsonArrtrim(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonArrtrim.
|
default RedisAPI |
RedisAPI.jsonClear(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonClear.
|
default RedisAPI |
RedisAPI.jsonDebug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonDebug.
|
default RedisAPI |
RedisAPI.jsonDel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonDel.
|
default RedisAPI |
RedisAPI.jsonForget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonForget.
|
default RedisAPI |
RedisAPI.jsonGet(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonGet.
|
default RedisAPI |
RedisAPI.jsonMget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonMget.
|
default RedisAPI |
RedisAPI.jsonNumincrby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonNumincrby.
|
default RedisAPI |
RedisAPI.jsonNummultby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonNummultby.
|
default RedisAPI |
RedisAPI.jsonNumpowby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonNumpowby.
|
default RedisAPI |
RedisAPI.jsonObjkeys(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonObjkeys.
|
default RedisAPI |
RedisAPI.jsonObjlen(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonObjlen.
|
default RedisAPI |
RedisAPI.jsonResp(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonResp.
|
default RedisAPI |
RedisAPI.jsonSet(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonSet.
|
default RedisAPI |
RedisAPI.jsonStrappend(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonStrappend.
|
default RedisAPI |
RedisAPI.jsonStrlen(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonStrlen.
|
default RedisAPI |
RedisAPI.jsonToggle(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonToggle.
|
default RedisAPI |
RedisAPI.jsonType(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command jsonType.
|
default RedisAPI |
RedisAPI.keys(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command keys.
|
default RedisAPI |
RedisAPI.lastsave(Handler<AsyncResult<Response>> handler)
Redis command lastsave.
|
default RedisAPI |
RedisAPI.latency(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command latency.
|
default RedisAPI |
RedisAPI.lcs(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lcs.
|
default RedisAPI |
RedisAPI.lindex(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command lindex.
|
default RedisAPI |
RedisAPI.linsert(String arg0,
String arg1,
String arg2,
String arg3,
Handler<AsyncResult<Response>> handler)
Redis command linsert.
|
default RedisAPI |
RedisAPI.llen(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command llen.
|
default RedisAPI |
RedisAPI.lmove(String arg0,
String arg1,
String arg2,
String arg3,
Handler<AsyncResult<Response>> handler)
Redis command lmove.
|
default RedisAPI |
RedisAPI.lmpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lmpop.
|
default RedisAPI |
RedisAPI.lolwut(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lolwut.
|
default RedisAPI |
RedisAPI.lpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lpop.
|
default RedisAPI |
RedisAPI.lpos(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lpos.
|
default RedisAPI |
RedisAPI.lpush(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lpush.
|
default RedisAPI |
RedisAPI.lpushx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command lpushx.
|
default RedisAPI |
RedisAPI.lrange(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command lrange.
|
default RedisAPI |
RedisAPI.lrem(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command lrem.
|
default RedisAPI |
RedisAPI.lset(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command lset.
|
default RedisAPI |
RedisAPI.ltrim(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command ltrim.
|
default RedisAPI |
RedisAPI.memory(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command memory.
|
default RedisAPI |
RedisAPI.mget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command mget.
|
default RedisAPI |
RedisAPI.migrate(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command migrate.
|
default RedisAPI |
RedisAPI.module(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command module.
|
default RedisAPI |
RedisAPI.monitor(Handler<AsyncResult<Response>> handler)
Redis command monitor.
|
default RedisAPI |
RedisAPI.move(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command move.
|
default RedisAPI |
RedisAPI.mset(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command mset.
|
default RedisAPI |
RedisAPI.msetnx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command msetnx.
|
default RedisAPI |
RedisAPI.multi(Handler<AsyncResult<Response>> handler)
Redis command multi.
|
default RedisAPI |
RedisAPI.object(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command object.
|
default RedisAPI |
RedisAPI.persist(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command persist.
|
default RedisAPI |
RedisAPI.pexpire(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pexpire.
|
default RedisAPI |
RedisAPI.pexpireat(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pexpireat.
|
default RedisAPI |
RedisAPI.pexpiretime(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command pexpiretime.
|
default RedisAPI |
RedisAPI.pfadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pfadd.
|
default RedisAPI |
RedisAPI.pfcount(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pfcount.
|
default RedisAPI |
RedisAPI.pfdebug(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pfdebug.
|
default RedisAPI |
RedisAPI.pfmerge(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pfmerge.
|
default RedisAPI |
RedisAPI.pfselftest(Handler<AsyncResult<Response>> handler)
Redis command pfselftest.
|
default RedisAPI |
RedisAPI.ping(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ping.
|
default RedisAPI |
RedisAPI.psetex(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command psetex.
|
default RedisAPI |
RedisAPI.psubscribe(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command psubscribe.
|
default RedisAPI |
RedisAPI.psync(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command psync.
|
default RedisAPI |
RedisAPI.pttl(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command pttl.
|
default RedisAPI |
RedisAPI.publish(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command publish.
|
default RedisAPI |
RedisAPI.pubsub(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command pubsub.
|
default RedisAPI |
RedisAPI.punsubscribe(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command punsubscribe.
|
default RedisAPI |
RedisAPI.quit(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command quit.
|
default RedisAPI |
RedisAPI.randomkey(Handler<AsyncResult<Response>> handler)
Redis command randomkey.
|
default RedisAPI |
RedisAPI.readonly(Handler<AsyncResult<Response>> handler)
Redis command readonly.
|
default RedisAPI |
RedisAPI.readwrite(Handler<AsyncResult<Response>> handler)
Redis command readwrite.
|
default RedisAPI |
RedisAPI.rename(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command rename.
|
default RedisAPI |
RedisAPI.renamenx(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command renamenx.
|
default RedisAPI |
RedisAPI.replconf(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command replconf.
|
default RedisAPI |
RedisAPI.replicaof(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command replicaof.
|
default RedisAPI |
RedisAPI.reset(Handler<AsyncResult<Response>> handler)
Redis command reset.
|
default RedisAPI |
RedisAPI.restore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command restore.
|
default RedisAPI |
RedisAPI.restoreAsking(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command restoreAsking.
|
default RedisAPI |
RedisAPI.role(Handler<AsyncResult<Response>> handler)
Redis command role.
|
default RedisAPI |
RedisAPI.rpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command rpop.
|
default RedisAPI |
RedisAPI.rpoplpush(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command rpoplpush.
|
default RedisAPI |
RedisAPI.rpush(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command rpush.
|
default RedisAPI |
RedisAPI.rpushx(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command rpushx.
|
default RedisAPI |
RedisAPI.sadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sadd.
|
default RedisAPI |
RedisAPI.save(Handler<AsyncResult<Response>> handler)
Redis command save.
|
default RedisAPI |
RedisAPI.scan(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command scan.
|
default RedisAPI |
RedisAPI.scard(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command scard.
|
default RedisAPI |
RedisAPI.script(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command script.
|
default RedisAPI |
RedisAPI.sdiff(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sdiff.
|
default RedisAPI |
RedisAPI.sdiffstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sdiffstore.
|
default RedisAPI |
RedisAPI.select(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command select.
|
default Redis |
Redis.send(Request command,
Handler<AsyncResult<Response>> onSend)
Send the given command to the redis server or cluster.
|
default RedisConnection |
RedisConnection.send(Request command,
Handler<AsyncResult<Response>> onSend)
Send the given command to the redis server or cluster.
|
default RedisAPI |
RedisAPI.set(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command set.
|
default RedisAPI |
RedisAPI.setbit(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command setbit.
|
default RedisAPI |
RedisAPI.setex(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command setex.
|
default RedisAPI |
RedisAPI.setnx(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command setnx.
|
default RedisAPI |
RedisAPI.setrange(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command setrange.
|
default RedisAPI |
RedisAPI.shutdown(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command shutdown.
|
default RedisAPI |
RedisAPI.sinter(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sinter.
|
default RedisAPI |
RedisAPI.sintercard(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sintercard.
|
default RedisAPI |
RedisAPI.sinterstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sinterstore.
|
default RedisAPI |
RedisAPI.sismember(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command sismember.
|
default RedisAPI |
RedisAPI.slaveof(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command slaveof.
|
default RedisAPI |
RedisAPI.slowlog(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command slowlog.
|
default RedisAPI |
RedisAPI.smembers(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command smembers.
|
default RedisAPI |
RedisAPI.smismember(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command smismember.
|
default RedisAPI |
RedisAPI.smove(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command smove.
|
default RedisAPI |
RedisAPI.sort(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sort.
|
default RedisAPI |
RedisAPI.sortRo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sortRo.
|
default RedisAPI |
RedisAPI.spop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command spop.
|
default RedisAPI |
RedisAPI.spublish(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command spublish.
|
default RedisAPI |
RedisAPI.srandmember(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command srandmember.
|
default RedisAPI |
RedisAPI.srem(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command srem.
|
default RedisAPI |
RedisAPI.sscan(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sscan.
|
default RedisAPI |
RedisAPI.ssubscribe(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command ssubscribe.
|
default RedisAPI |
RedisAPI.strlen(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command strlen.
|
default RedisAPI |
RedisAPI.subscribe(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command subscribe.
|
default RedisAPI |
RedisAPI.substr(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command substr.
|
default RedisAPI |
RedisAPI.sunion(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sunion.
|
default RedisAPI |
RedisAPI.sunionstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sunionstore.
|
default RedisAPI |
RedisAPI.sunsubscribe(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command sunsubscribe.
|
default RedisAPI |
RedisAPI.swapdb(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command swapdb.
|
default RedisAPI |
RedisAPI.sync(Handler<AsyncResult<Response>> handler)
Redis command sync.
|
default RedisAPI |
RedisAPI.time(Handler<AsyncResult<Response>> handler)
Redis command time.
|
default RedisAPI |
RedisAPI.timeseriesClusterset(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesClusterset.
|
default RedisAPI |
RedisAPI.timeseriesClustersetfromshard(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesClustersetfromshard.
|
default RedisAPI |
RedisAPI.timeseriesHello(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesHello.
|
default RedisAPI |
RedisAPI.timeseriesInfocluster(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesInfocluster.
|
default RedisAPI |
RedisAPI.timeseriesInnercommunication(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesInnercommunication.
|
default RedisAPI |
RedisAPI.timeseriesNetworktest(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesNetworktest.
|
default RedisAPI |
RedisAPI.timeseriesRefreshcluster(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command timeseriesRefreshcluster.
|
default RedisAPI |
RedisAPI.topkAdd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkAdd.
|
default RedisAPI |
RedisAPI.topkCount(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkCount.
|
default RedisAPI |
RedisAPI.topkIncrby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkIncrby.
|
default RedisAPI |
RedisAPI.topkInfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkInfo.
|
default RedisAPI |
RedisAPI.topkList(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkList.
|
default RedisAPI |
RedisAPI.topkQuery(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkQuery.
|
default RedisAPI |
RedisAPI.topkReserve(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command topkReserve.
|
default RedisAPI |
RedisAPI.touch(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command touch.
|
default RedisAPI |
RedisAPI.tsAdd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsAdd.
|
default RedisAPI |
RedisAPI.tsAlter(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsAlter.
|
default RedisAPI |
RedisAPI.tsCreate(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsCreate.
|
default RedisAPI |
RedisAPI.tsCreaterule(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsCreaterule.
|
default RedisAPI |
RedisAPI.tsDecrby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsDecrby.
|
default RedisAPI |
RedisAPI.tsDel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsDel.
|
default RedisAPI |
RedisAPI.tsDeleterule(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsDeleterule.
|
default RedisAPI |
RedisAPI.tsGet(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsGet.
|
default RedisAPI |
RedisAPI.tsIncrby(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsIncrby.
|
default RedisAPI |
RedisAPI.tsInfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsInfo.
|
default RedisAPI |
RedisAPI.tsMadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsMadd.
|
default RedisAPI |
RedisAPI.tsMget(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsMget.
|
default RedisAPI |
RedisAPI.tsMrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsMrange.
|
default RedisAPI |
RedisAPI.tsMrevrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsMrevrange.
|
default RedisAPI |
RedisAPI.tsQueryindex(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsQueryindex.
|
default RedisAPI |
RedisAPI.tsRange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsRange.
|
default RedisAPI |
RedisAPI.tsRevrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command tsRevrange.
|
default RedisAPI |
RedisAPI.ttl(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command ttl.
|
default RedisAPI |
RedisAPI.type(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command type.
|
default RedisAPI |
RedisAPI.unlink(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command unlink.
|
default RedisAPI |
RedisAPI.unsubscribe(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command unsubscribe.
|
default RedisAPI |
RedisAPI.unwatch(Handler<AsyncResult<Response>> handler)
Redis command unwatch.
|
default RedisAPI |
RedisAPI.wait(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command wait.
|
default RedisAPI |
RedisAPI.watch(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command watch.
|
default RedisAPI |
RedisAPI.xack(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xack.
|
default RedisAPI |
RedisAPI.xadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xadd.
|
default RedisAPI |
RedisAPI.xautoclaim(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xautoclaim.
|
default RedisAPI |
RedisAPI.xclaim(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xclaim.
|
default RedisAPI |
RedisAPI.xdel(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xdel.
|
default RedisAPI |
RedisAPI.xgroup(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xgroup.
|
default RedisAPI |
RedisAPI.xinfo(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xinfo.
|
default RedisAPI |
RedisAPI.xlen(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command xlen.
|
default RedisAPI |
RedisAPI.xpending(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xpending.
|
default RedisAPI |
RedisAPI.xrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xrange.
|
default RedisAPI |
RedisAPI.xread(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xread.
|
default RedisAPI |
RedisAPI.xreadgroup(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xreadgroup.
|
default RedisAPI |
RedisAPI.xrevrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xrevrange.
|
default RedisAPI |
RedisAPI.xsetid(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xsetid.
|
default RedisAPI |
RedisAPI.xtrim(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command xtrim.
|
default RedisAPI |
RedisAPI.zadd(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zadd.
|
default RedisAPI |
RedisAPI.zcard(String arg0,
Handler<AsyncResult<Response>> handler)
Redis command zcard.
|
default RedisAPI |
RedisAPI.zcount(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command zcount.
|
default RedisAPI |
RedisAPI.zdiff(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zdiff.
|
default RedisAPI |
RedisAPI.zdiffstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zdiffstore.
|
default RedisAPI |
RedisAPI.zincrby(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command zincrby.
|
default RedisAPI |
RedisAPI.zinter(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zinter.
|
default RedisAPI |
RedisAPI.zintercard(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zintercard.
|
default RedisAPI |
RedisAPI.zinterstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zinterstore.
|
default RedisAPI |
RedisAPI.zlexcount(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command zlexcount.
|
default RedisAPI |
RedisAPI.zmpop(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zmpop.
|
default RedisAPI |
RedisAPI.zmscore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zmscore.
|
default RedisAPI |
RedisAPI.zpopmax(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zpopmax.
|
default RedisAPI |
RedisAPI.zpopmin(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zpopmin.
|
default RedisAPI |
RedisAPI.zrandmember(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrandmember.
|
default RedisAPI |
RedisAPI.zrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrange.
|
default RedisAPI |
RedisAPI.zrangebylex(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrangebylex.
|
default RedisAPI |
RedisAPI.zrangebyscore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrangebyscore.
|
default RedisAPI |
RedisAPI.zrangestore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrangestore.
|
default RedisAPI |
RedisAPI.zrank(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command zrank.
|
default RedisAPI |
RedisAPI.zrem(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrem.
|
default RedisAPI |
RedisAPI.zremrangebylex(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command zremrangebylex.
|
default RedisAPI |
RedisAPI.zremrangebyrank(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command zremrangebyrank.
|
default RedisAPI |
RedisAPI.zremrangebyscore(String arg0,
String arg1,
String arg2,
Handler<AsyncResult<Response>> handler)
Redis command zremrangebyscore.
|
default RedisAPI |
RedisAPI.zrevrange(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrevrange.
|
default RedisAPI |
RedisAPI.zrevrangebylex(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrevrangebylex.
|
default RedisAPI |
RedisAPI.zrevrangebyscore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zrevrangebyscore.
|
default RedisAPI |
RedisAPI.zrevrank(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command zrevrank.
|
default RedisAPI |
RedisAPI.zscan(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zscan.
|
default RedisAPI |
RedisAPI.zscore(String arg0,
String arg1,
Handler<AsyncResult<Response>> handler)
Redis command zscore.
|
default RedisAPI |
RedisAPI.zunion(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zunion.
|
default RedisAPI |
RedisAPI.zunionstore(List<String> args,
Handler<AsyncResult<Response>> handler)
Redis command zunionstore.
|
| Modifier and Type | Class and Description |
|---|---|
class |
HandlerAdapter<T> |
| Modifier and Type | Field and Description |
|---|---|
protected java.util.function.Consumer<Handler<AsyncResult<T>>> |
SingleOnSubscribeAdapter.consumer |
| Modifier and Type | Method and Description |
|---|---|
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Action1<T> onNext)
Adapt an item callback as a
Handler<AsyncResult<T>>. |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Action1<T> onNext,
Action1<Throwable> onError)
Adapt an item callback and an error callback as a
Handler<AsyncResult<T>>. |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Action1<T> onNext,
Action1<Throwable> onError,
Action0 onComplete)
Adapt an item callback and an error callback as a
Handler<AsyncResult<T>>. |
static <T> Handler<AsyncResult<T>> |
RxHelper.toFuture(Observer<T> observer)
Adapt a
Subscriber as a Handler<AsyncResult<T>>;. |
Handler<T> |
ObservableHandler.toHandler() |
Handler<AsyncResult<T>> |
ObservableFuture.toHandler() |
static <T> Handler<T> |
RxHelper.toHandler(Action1<T> onNext)
Adapt an item callback as a
Handler<T>. |
static <T> Handler<T> |
RxHelper.toHandler(Observer<T> observer)
Adapt a
Subscriber as a Handler<T>;.
When the event handler completes, the observer
will complete immediatly after the event is received, as a single event is expected. |
static <T> Handler<T> |
RxHelper.toHandler(Observer<T> observer,
boolean multi)
Adapt a
Subscriber as a Handler<T>;.
When parameter is false and the event handler completes, the observer
will complete immediatly after the event is received, as a single event is expected. |
| Modifier and Type | Method and Description |
|---|---|
ReadStream<J> |
ReadStreamSubscriber.endHandler(Handler<Void> handler) |
ReadStream<J> |
ReadStreamSubscriber.exceptionHandler(Handler<Throwable> handler) |
ReadStream<J> |
ReadStreamSubscriber.handler(Handler<J> handler) |
static <T> Subscriber<T> |
RxHelper.toSubscriber(Handler<AsyncResult<T>> handler)
Adapts a Vert.x
Handler<AsyncResult<T>> to an RxJava Subscriber. |
| Constructor and Description |
|---|
SingleOnSubscribeAdapter(java.util.function.Consumer<Handler<AsyncResult<T>>> consumer) |
| Modifier and Type | Method and Description |
|---|---|
AmqpConnection |
AmqpConnection.close(Handler<AsyncResult<Void>> done)
Closes the AMQP connection, i.e.
|
void |
AmqpSender.close(Handler<AsyncResult<Void>> handler)
Closes the sender.
|
void |
AmqpReceiver.close(Handler<AsyncResult<Void>> handler)
Closes the receiver.
|
void |
AmqpClient.close(Handler<AsyncResult<Void>> closeHandler)
Closes the client.
|
AmqpClient |
AmqpClient.connect(Handler<AsyncResult<AmqpConnection>> connectionHandler)
Connects to the AMQP broker or router.
|
AmqpConnection |
AmqpConnection.createAnonymousSender(Handler<AsyncResult<AmqpSender>> completionHandler)
Creates an anonymous sender.
|
AmqpConnection |
AmqpConnection.createDynamicReceiver(Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a dynamic receiver.
|
AmqpConnection |
AmqpConnection.createReceiver(String address,
AmqpReceiverOptions receiverOptions,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consumer messages from the given address.
|
AmqpClient |
AmqpClient.createReceiver(String address,
AmqpReceiverOptions receiverOptions,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consumer messages from the given address.
|
AmqpConnection |
AmqpConnection.createReceiver(String address,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consume messages from the given address.
|
AmqpClient |
AmqpClient.createReceiver(String address,
Handler<AsyncResult<AmqpReceiver>> completionHandler)
Creates a receiver used to consume messages from the given address.
|
AmqpConnection |
AmqpConnection.createSender(String address,
AmqpSenderOptions options,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpClient |
AmqpClient.createSender(String address,
AmqpSenderOptions options,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpConnection |
AmqpConnection.createSender(String address,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
AmqpClient |
AmqpClient.createSender(String address,
Handler<AsyncResult<AmqpSender>> completionHandler)
Creates a sender used to send messages to the given address.
|
WriteStream<AmqpMessage> |
AmqpSender.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
void |
AmqpSender.end(AmqpMessage data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
AmqpSender.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
AmqpReceiver |
AmqpReceiver.endHandler(Handler<Void> endHandler) |
AmqpConnection |
AmqpConnection.exceptionHandler(Handler<Throwable> handler)
Registers a handler called on disconnection.
|
AmqpSender |
AmqpSender.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.handler(Handler<AmqpMessage> handler) |
void |
AmqpReceiver.pipeTo(WriteStream<AmqpMessage> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
AmqpSender |
AmqpSender.sendWithAck(AmqpMessage message,
Handler<AsyncResult<Void>> acknowledgementHandler)
Sends an AMQP message and waits for an acknowledgement.
|
void |
AmqpSender.write(AmqpMessage data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
ResultSet |
ResultSet.all(Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> handler)
The method should not be used concurrently with others like
ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.cassandra.ResultSet>>) or . |
CassandraClient |
CassandraClient.close(Handler<AsyncResult<Void>> closeHandler)
Closes this client.
|
CassandraRowStream |
CassandraRowStream.endHandler(Handler<Void> handler) |
CassandraRowStream |
CassandraRowStream.exceptionHandler(Handler<Throwable> handler) |
CassandraClient |
CassandraClient.execute(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<ResultSet>> resultHandler)
Execute the statement and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.execute(String query,
Handler<AsyncResult<ResultSet>> resultHandler)
Execute the query and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.executeWithFullFetch(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)
Execute the query and provide a handler for consuming results.
|
CassandraClient |
CassandraClient.executeWithFullFetch(String query,
Handler<AsyncResult<List<com.datastax.oss.driver.api.core.cql.Row>>> resultHandler)
Execute the query and provide a handler for consuming results.
|
void |
ResultSet.fetchNextPage(Handler<AsyncResult<ResultSet>> handler)
Like
ResultSet.fetchNextPage(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.cassandra.ResultSet>>) but with a direct callback. |
CassandraRowStream |
CassandraRowStream.handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler) |
void |
CassandraClient.metadata(Handler<AsyncResult<com.datastax.oss.driver.api.core.metadata.Metadata>> handler)
Get for the session.
|
void |
CassandraRowStream.pipeTo(WriteStream<com.datastax.oss.driver.api.core.cql.Row> dst,
Handler<AsyncResult<Void>> handler) |
CassandraClient |
CassandraClient.prepare(com.datastax.oss.driver.api.core.cql.SimpleStatement statement,
Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)
Prepares the provided a .
|
CassandraClient |
CassandraClient.prepare(String query,
Handler<AsyncResult<com.datastax.oss.driver.api.core.cql.PreparedStatement>> resultHandler)
Prepares the provided query string.
|
CassandraClient |
CassandraClient.queryStream(com.datastax.oss.driver.api.core.cql.Statement statement,
Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)
Executes the given SQL statement which returns the results of the query as a read stream.
|
CassandraClient |
CassandraClient.queryStream(String sql,
Handler<AsyncResult<CassandraRowStream>> rowStreamHandler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
| Modifier and Type | Method and Description |
|---|---|
void |
ConfigRetriever.getConfig(Handler<AsyncResult<JsonObject>> completionHandler)
Reads the configuration from the different
and computes the final configuration.
|
void |
ConfigRetriever.listen(Handler<ConfigChange> listener)
Registers a listener receiving configuration changes.
|
ConfigRetriever |
ConfigRetriever.setBeforeScanHandler(Handler<Void> handler)
Registers a handler called before every scan.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Vertx.close(Handler<AsyncResult<Void>> completionHandler)
Like
Vertx.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete |
void |
WorkerExecutor.close(Handler<AsyncResult<Void>> handler)
Close the executor.
|
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(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(String name,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete. |
void |
Vertx.deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by
invoking the verticleSupplier. |
void |
Vertx.deployVerticle(Verticle verticle,
DeploymentOptions options,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the
deployment. |
void |
Vertx.deployVerticle(Verticle verticle,
Handler<AsyncResult<String>> completionHandler)
Like
Vertx.deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete. |
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
Context |
Context.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called when the context runs an action throwing an uncaught throwable.
When this handler is called,
Vertx.currentContext() will return this context. |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
Vertx |
Vertx.exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context, set on Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>) at creation. |
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered,
Handler<AsyncResult<T>> resultHandler)
Safely execute some blocking code.
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
<T> void |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
Handler<AsyncResult<T>> resultHandler)
|
TimeoutStream |
TimeoutStream.handler(Handler<Long> handler) |
void |
TimeoutStream.pipeTo(WriteStream<Long> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
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.
|
<T> Single<T> |
Context.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> Single<T> |
Vertx.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> Single<T> |
WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
|
<T> Single<T> |
Context.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Single<T> |
Vertx.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Single<T> |
WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
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.setPeriodic(long initialDelay,
long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds with initial delay, at which point handler will be called with
the id of the timer. |
long |
Vertx.setTimer(long delay,
Handler<Long> handler)
Set a one-shot timer to fire after
delay milliseconds, at which point handler will be called with
the id of the timer. |
void |
Vertx.undeploy(String deploymentID,
Handler<AsyncResult<Void>> completionHandler)
Like
#undeploy(String) but the completionHandler will be notified when the undeployment is complete. |
| Modifier and Type | Method and Description |
|---|---|
DatagramSocket |
DatagramSocket.blockMulticastGroup(String multicastAddress,
String sourceToBlock,
Handler<AsyncResult<Void>> 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<Void>> 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. |
DatagramSocket |
DatagramSocket.endHandler(Handler<Void> endHandler) |
DatagramSocket |
DatagramSocket.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<Void>> handler)
Joins a multicast group and listens for packets send to it.
|
DatagramSocket |
DatagramSocket.listenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<Void>> handler)
Joins a multicast group and listens for packets send to it on the given network interface.
|
void |
DatagramSocket.pipeTo(WriteStream<DatagramPacket> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
DatagramSocket |
DatagramSocket.send(Buffer packet,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
Buffer to the SocketAddress. |
DatagramSocket |
DatagramSocket.send(String str,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
String to the SocketAddress using UTF8 encoding. |
DatagramSocket |
DatagramSocket.send(String str,
String enc,
int port,
String host,
Handler<AsyncResult<Void>> handler)
Write the given
String to the SocketAddress using the given encoding. |
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
Handler<AsyncResult<Void>> handler)
Leaves a multicast group and stops listening for packets send to it.
|
DatagramSocket |
DatagramSocket.unlistenMulticastGroup(String multicastAddress,
String networkInterface,
String source,
Handler<AsyncResult<Void>> 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 |
|---|---|
<T> EventBus |
EventBus.addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is received by Vert.x
|
<T> EventBus |
EventBus.addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is sent from Vert.x
|
void |
MessageProducer.close(Handler<AsyncResult<Void>> handler)
Same as
MessageProducer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
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.
|
MessageConsumer<T> |
MessageConsumer.endHandler(Handler<Void> endHandler) |
MessageConsumer<T> |
MessageConsumer.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. |
void |
MessageConsumer.pipeTo(WriteStream<Message<T>> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
<T> EventBus |
EventBus.removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava.core.eventbus.DeliveryContext<T>>) |
<T> EventBus |
EventBus.removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava.core.eventbus.DeliveryContext<T>>) |
<R> void |
Message.replyAndRequest(Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<R>>> replyHandler)
Like
Message.replyAndRequest(java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.eventbus.Message<R>>>) but specifying options that can be used
to configure the delivery. |
<R> void |
Message.replyAndRequest(Object message,
Handler<AsyncResult<Message<R>>> replyHandler)
Reply to this message, specifying a
replyHandler for the reply - i.e. |
<T> EventBus |
EventBus.request(String address,
Object message,
DeliveryOptions options,
Handler<AsyncResult<Message<T>>> replyHandler)
Like
EventBus.request(java.lang.String, java.lang.Object, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.eventbus.Message<T>>>) but specifying options that can be used to configure the delivery. |
<T> EventBus |
EventBus.request(String address,
Object message,
Handler<AsyncResult<Message<T>>> replyHandler)
Sends a message and specify a
replyHandler that will be called if the recipient
subsequently replies to the message. |
void |
MessageConsumer.unregister(Handler<AsyncResult<Void>> completionHandler)
Unregisters the handler which created this registration
|
void |
MessageProducer.write(T body,
Handler<AsyncResult<Void>> handler)
Write a message to the event-bus, either sending or publishing.
|
| 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,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Copy a file from the path
from to path to, asynchronously. |
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.createTempDirectory(String prefix,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempDirectory(String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the default temporary-file directory, using the given
prefix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempDirectory(String dir,
String prefix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new directory in the directory provided by the path
path, using the given
prefix to generate its name, asynchronously. |
FileSystem |
FileSystem.createTempFile(String prefix,
String suffix,
Handler<AsyncResult<String>> handler)
Creates a new file in the default temporary-file directory, using the given
prefix and suffix to generate its name, asynchronously.
|
FileSystem |
FileSystem.createTempFile(String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir, using the given
prefix and suffix to generate its name, asynchronously. |
FileSystem |
FileSystem.createTempFile(String dir,
String prefix,
String suffix,
String perms,
Handler<AsyncResult<String>> handler)
Creates a new file in the directory provided by the path
dir, using the given
prefix and suffix to generate its name, 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) |
void |
AsyncFile.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
AsyncFile.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
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(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) 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) |
void |
AsyncFileLock.isValid(Handler<AsyncResult<Boolean>> handler)
Like
AsyncFileLock.isValid(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Boolean>>) but the handler will be called when the operation completes or if an error occurs. |
FileSystem |
FileSystem.link(String link,
String existing,
Handler<AsyncResult<Void>> handler)
Create a hard link on the file system from
link to existing, asynchronously. |
void |
AsyncFile.lock(Handler<AsyncResult<AsyncFileLock>> handler)
Like
AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>) but the handler will be called when the operation is complete or if an error occurs. |
void |
AsyncFile.lock(long position,
long size,
boolean shared,
Handler<AsyncResult<AsyncFileLock>> handler)
Like
AsyncFile.lock(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.file.AsyncFileLock>>) but the handler will be called when the operation is complete or if an error occurs. |
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,
CopyOptions options,
Handler<AsyncResult<Void>> handler)
Move a file from the path
from to path to, 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. |
void |
AsyncFile.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
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. |
void |
AsyncFileLock.release(Handler<AsyncResult<Void>> handler)
Like
AsyncFileLock.release(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the handler will be called when the operation completes or if an error occurs. |
void |
AsyncFile.size(Handler<AsyncResult<Long>> handler)
Like
AsyncFile.size(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Long>>) but the handler will be called when the operation is complete or if an error occurs. |
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. |
void |
AsyncFile.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
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 |
|---|---|
WebSocketBase |
ServerWebSocket.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
WebSocketBase |
WebSocket.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
WebSocketBase |
WebSocketBase.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
HttpClientResponse |
HttpClientResponse.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpClientResponse.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.buffer.Buffer>>) but with an handler called when the operation completes |
HttpServerRequest |
HttpServerRequest.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.buffer.Buffer>>) but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.bodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
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 |
ServerWebSocket.close(Handler<AsyncResult<Void>> handler)
Same as
ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
HttpServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but supplying a handler that will be called when the server is actually closed (or has failed). |
void |
WebSocket.close(Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpConnection.close(Handler<AsyncResult<Void>> handler)
Close the connection and all the currently active streams.
|
void |
HttpClient.close(Handler<AsyncResult<Void>> handler)
Close the client.
|
void |
WebSocketBase.close(Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocketBase.close(short statusCode,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocketBase.close(short statusCode,
String reason,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.closeHandler(Handler<Void> handler)
Set a close handler for the response, this is called when the underlying connection is closed and the response
was still using the connection.
|
ServerWebSocket |
ServerWebSocket.closeHandler(Handler<Void> handler) |
WebSocket |
WebSocket.closeHandler(Handler<Void> handler) |
HttpConnection |
HttpConnection.closeHandler(Handler<Void> handler)
Set a close handler.
|
WebSocketBase |
WebSocketBase.closeHandler(Handler<Void> handler)
Set a close handler.
|
void |
HttpClientRequest.connect(Handler<AsyncResult<HttpClientResponse>> handler)
Create an HTTP tunnel to the server.
|
HttpServer |
HttpServer.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the server.
|
HttpClient |
HttpClient.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the client.
|
HttpClientRequest |
HttpClientRequest.continueHandler(Handler<Void> handler)
If you send an HTTP request with the header
Expect set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100 and a continue handler
has been set using this method, then the handler will be called. |
HttpClientResponse |
HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)
Set an custom frame handler.
|
HttpServerRequest |
HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)
Set a custom frame handler.
|
HttpServerResponse |
HttpServerResponse.drainHandler(Handler<Void> handler) |
ServerWebSocket |
ServerWebSocket.drainHandler(Handler<Void> handler) |
HttpClientRequest |
HttpClientRequest.drainHandler(Handler<Void> handler) |
WebSocket |
WebSocket.drainHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.drainHandler(Handler<Void> handler) |
void |
HttpServerResponse.end(Buffer chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpClientRequest.end(Buffer chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
WebSocketBase.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpClientResponse.end(Handler<AsyncResult<Void>> handler)
Same as
HttpClientResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServerResponse.end(Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
ServerWebSocket.end(Handler<AsyncResult<Void>> handler)
|
void |
HttpClientRequest.end(Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocket.end(Handler<AsyncResult<Void>> handler)
|
void |
HttpServerRequest.end(Handler<AsyncResult<Void>> handler)
Same as
HttpServerRequest.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WebSocketBase.end(Handler<AsyncResult<Void>> handler)
|
void |
HttpServerResponse.end(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.end(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServerResponse.end(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.end(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.end(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
HttpClientResponse |
HttpClientResponse.endHandler(Handler<Void> endHandler) |
HttpServerResponse |
HttpServerResponse.endHandler(Handler<Void> handler)
Set an end handler for the response.
|
ServerWebSocket |
ServerWebSocket.endHandler(Handler<Void> endHandler) |
WebSocket |
WebSocket.endHandler(Handler<Void> endHandler) |
HttpServerFileUpload |
HttpServerFileUpload.endHandler(Handler<Void> endHandler) |
HttpServerRequest |
HttpServerRequest.endHandler(Handler<Void> endHandler) |
WebSocketBase |
WebSocketBase.endHandler(Handler<Void> endHandler) |
HttpClientResponse |
HttpClientResponse.exceptionHandler(Handler<Throwable> handler) |
HttpServerResponse |
HttpServerResponse.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpServer |
HttpServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called for socket errors happening before the HTTP connection
is established, e.g during the TLS handshake.
|
HttpClientRequest |
HttpClientRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocket |
WebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpConnection |
HttpConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called when a connection error happens
|
HttpServerFileUpload |
HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequest |
HttpServerRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocketBase |
WebSocketBase.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.
|
HttpConnection |
HttpConnection.goAwayHandler(Handler<GoAway> handler)
Set an handler called when a frame is received.
|
HttpClientResponse |
HttpClientResponse.handler(Handler<Buffer> handler) |
ServerWebSocket |
ServerWebSocket.handler(Handler<Buffer> handler) |
WebSocket |
WebSocket.handler(Handler<Buffer> handler) |
HttpServerFileUpload |
HttpServerFileUpload.handler(Handler<Buffer> handler) |
HttpServerRequest |
HttpServerRequest.handler(Handler<Buffer> handler) |
WebSocketBase |
WebSocketBase.handler(Handler<Buffer> handler) |
HttpServerResponse |
HttpServerResponse.headersEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the headers are written to the wire.
|
HttpServer |
HttpServer.invalidRequestHandler(Handler<HttpServerRequest> handler)
Set a
handler for handling invalid requests. |
HttpServer |
HttpServer.listen(Handler<AsyncResult<HttpServer>> listenHandler)
Like
HttpServer.listen(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.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(int, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServer>>) 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, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServer>>) but supplying a handler that will be called when the server is actually
listening (or has failed). |
HttpServer |
HttpServer.listen(SocketAddress address,
Handler<AsyncResult<HttpServer>> listenHandler)
Tell the server to start listening on the given address supplying
a handler that will be called when the server is actually
listening (or has failed).
|
HttpConnection |
HttpConnection.ping(Buffer data,
Handler<AsyncResult<Buffer>> pongHandler)
Send a frame to the remote endpoint.
|
HttpConnection |
HttpConnection.pingHandler(Handler<Buffer> handler)
Set an handler notified when a frame is received from the remote endpoint.
|
void |
HttpClientResponse.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
ServerWebSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
WebSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
HttpServerFileUpload.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
HttpServerRequest.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
WebSocketBase.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
WebSocketBase |
ServerWebSocket.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
WebSocketBase |
WebSocket.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
WebSocketBase |
WebSocketBase.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Like
HttpServerResponse.push(io.vertx.core.http.HttpMethod, java.lang.String, java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.http.HttpServerResponse>>) with the host copied from the current request. |
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
Handler<AsyncResult<HttpServerResponse>> handler)
|
HttpServerResponse |
HttpServerResponse.push(HttpMethod method,
String host,
String path,
MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler)
Push a response to the client.
The
handler will be notified with a success when the push can be sent and with
a failure when the client has disabled push or reset the push before it has been sent.
The handler may be queued if the client has reduced the maximum number of streams the server can push
concurrently.
Push can be sent only for peer initiated streams and if the response is not ended. |
HttpClientRequest |
HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)
Set a push handler for this request.
The handler is called when the client receives a push promise from the server.
|
HttpConnection |
HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)
Set an handler that is called when remote endpoint
Http2Settings are updated. |
void |
HttpClient.request(HttpMethod method,
int port,
String host,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the
host and port. |
void |
HttpClient.request(HttpMethod method,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the default host and port.
|
void |
HttpClient.request(HttpMethod method,
String host,
String requestURI,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server at the
host and default port. |
void |
HttpClient.request(RequestOptions options,
Handler<AsyncResult<HttpClientRequest>> handler)
Create an HTTP request to send to the server.
|
HttpServer |
HttpServer.requestHandler(Handler<HttpServerRequest> handler)
Set the request handler for the server to
requestHandler. |
HttpClientRequest |
HttpClientRequest.response(Handler<AsyncResult<HttpClientResponse>> handler)
Set a callback for the associated
HttpClientResponse. |
void |
HttpClientRequest.send(Buffer body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a buffer
body. |
void |
HttpServerResponse.send(Buffer body,
Handler<AsyncResult<Void>> handler)
Send the request with a buffer
body. |
void |
HttpClientRequest.send(Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with an empty body.
|
void |
HttpServerResponse.send(Handler<AsyncResult<Void>> handler)
Send the request with an empty body.
|
void |
HttpClientRequest.send(Observable<Buffer> body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a stream
body. |
void |
HttpServerResponse.send(Observable<Buffer> body,
Handler<AsyncResult<Void>> handler)
Send the request with a stream
body. |
void |
HttpClientRequest.send(ReadStream<Buffer> body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a stream
body. |
void |
HttpServerResponse.send(ReadStream<Buffer> body,
Handler<AsyncResult<Void>> handler)
Send the request with a stream
body. |
void |
HttpClientRequest.send(String body,
Handler<AsyncResult<HttpClientResponse>> handler)
Send the request with a string
body. |
void |
HttpServerResponse.send(String body,
Handler<AsyncResult<Void>> handler)
Send the request with a string
body. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but providing a handler which will be notified once the file has been completely
written to the wire. |
HttpServerResponse |
HttpServerResponse.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Like
HttpServerResponse.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but providing a handler which will be notified once the file has been
completely written to the wire. |
HttpClientRequest |
HttpClientRequest.sendHead(Handler<AsyncResult<Void>> completionHandler)
Like
HttpClientRequest.sendHead(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler after headers have been sent. |
void |
ServerWebSocket.setHandshake(Future<Integer> future,
Handler<AsyncResult<Integer>> handler)
Set an asynchronous result for the handshake, upon completion of the specified
future, the
WebSocket will either be
accepted when the future succeeds with the HTTP status code
rejected when the future is succeeds with an HTTP status code different than
rejected when the future fails with the HTTP status code 500
The provided future might be completed by the WebSocket itself, e.g calling the ServerWebSocket.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) method
will try to accept the handshake and close the WebSocket afterward. |
void |
HttpConnection.shutdown(Handler<AsyncResult<Void>> handler)
Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests
are processed, otherwise after 30 seconds the connection will be closed.
|
void |
HttpConnection.shutdown(long timeout,
Handler<AsyncResult<Void>> handler)
Like
HttpConnection.shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with a specific timeout in milliseconds. |
HttpConnection |
HttpConnection.shutdownHandler(Handler<Void> handler)
Set an handler called when a frame has been sent or received and all connections are closed.
|
HttpClientResponse |
HttpClientResponse.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes.
|
HttpServerRequest |
HttpServerRequest.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes
|
void |
HttpServerFileUpload.streamToFileSystem(String filename,
Handler<AsyncResult<Void>> handler)
Stream the content of this upload to the given file on storage.
|
WebSocketBase |
ServerWebSocket.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
WebSocketBase |
WebSocket.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
WebSocketBase |
WebSocketBase.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
void |
HttpServerRequest.toNetSocket(Handler<AsyncResult<NetSocket>> handler)
Establish a TCP tunnel with the client.
|
void |
HttpServerRequest.toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler)
Upgrade the connection of the current request to a WebSocket.
|
HttpConnection |
HttpConnection.updateSettings(Http2Settings settings,
Handler<AsyncResult<Void>> completionHandler)
Send to the remote endpoint an update of this endpoint settings
The
completionHandler will be notified when the remote endpoint has acknowledged the settings. |
HttpServerRequest |
HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)
Set an upload handler.
|
void |
HttpClient.webSocket(int port,
String host,
String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket to the specified port, host and relative request URI
|
void |
HttpClient.webSocket(String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket at the relative request URI using the default host and port
|
void |
HttpClient.webSocket(String host,
String requestURI,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket to the host and relative request URI and default port
|
void |
HttpClient.webSocket(WebSocketConnectOptions options,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket with the specified options.
|
void |
HttpClient.webSocketAbs(String url,
MultiMap headers,
WebsocketVersion version,
List<String> subProtocols,
Handler<AsyncResult<WebSocket>> handler)
Connect a WebSocket with the specified absolute url, 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. |
void |
HttpServerResponse.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
ServerWebSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpClientRequest.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
WebSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
WebSocketBase.write(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
HttpServerResponse.write(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.write(String chunk,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpServerResponse.write(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpServerResponse.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
HttpClientRequest.write(String chunk,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
HttpClientRequest.write(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeBinaryMessage(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeBinaryMessage(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFinalBinaryFrame(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFinalBinaryFrame(io.vertx.rxjava.core.buffer.Buffer, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFinalTextFrame(String text,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFinalTextFrame(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
ServerWebSocket |
ServerWebSocket.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeFrame(WebSocketFrame frame,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeFrame(io.vertx.rxjava.core.http.WebSocketFrame, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
WebSocketBase |
ServerWebSocket.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
WebSocket.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
WebSocketBase.writePing(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a ping frame to the connection.
|
WebSocketBase |
ServerWebSocket.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
WebSocketBase |
WebSocket.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
WebSocketBase |
WebSocketBase.writePong(Buffer data,
Handler<AsyncResult<Void>> handler)
Writes a pong frame to the connection.
|
ServerWebSocket |
ServerWebSocket.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler) |
WebSocket |
WebSocket.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler) |
WebSocketBase |
WebSocketBase.writeTextMessage(String text,
Handler<AsyncResult<Void>> handler)
Same as
WebSocketBase.writeTextMessage(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
void |
NetClient.close(Handler<AsyncResult<Void>> handler)
Close the client.
|
void |
NetSocket.close(Handler<AsyncResult<Void>> handler)
Close the NetSocket and notify the
handler when the operation completes. |
void |
NetServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
NetServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) 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. |
NetClient |
NetClient.connect(int port,
String host,
String serverName,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
port and host. |
NetClient |
NetClient.connect(SocketAddress remoteAddress,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
remoteAddress. |
NetClient |
NetClient.connect(SocketAddress remoteAddress,
String serverName,
Handler<AsyncResult<NetSocket>> connectHandler)
Open a connection to a server at the specific
remoteAddress. |
NetServer |
NetServer.connectHandler(Handler<NetSocket> handler)
Supply a connect handler for this server.
|
NetSocket |
NetSocket.drainHandler(Handler<Void> handler) |
void |
NetSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
NetSocket.end(Handler<AsyncResult<Void>> handler)
|
NetSocket |
NetSocket.endHandler(Handler<Void> endHandler)
This handler might be called after the close handler when the socket is paused and there are still
buffers to deliver.
|
NetSocket |
NetSocket.exceptionHandler(Handler<Throwable> handler) |
NetSocket |
NetSocket.handler(Handler<Buffer> handler) |
NetServer |
NetServer.listen(Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>) 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(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>) 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(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>) but providing a handler that will be notified when the server is listening, or fails. |
NetServer |
NetServer.listen(SocketAddress localAddress,
Handler<AsyncResult<NetServer>> listenHandler)
Like
NetServer.listen(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.net.NetServer>>) but providing a handler that will be notified when the server is listening, or fails. |
void |
NetSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
NetSocket |
NetSocket.sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Same as
NetSocket.sendFile(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
NetSocket.upgradeToSsl(Handler<AsyncResult<Void>> handler)
Upgrade channel to use SSL/TLS.
|
NetSocket |
NetSocket.upgradeToSsl(String serverName,
Handler<AsyncResult<Void>> handler)
Upgrade channel to use SSL/TLS.
|
void |
NetSocket.write(Buffer message,
Handler<AsyncResult<Void>> handler)
Like
WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the message has been written
or failed to be written. |
void |
NetSocket.write(String str,
Handler<AsyncResult<Void>> handler)
Same as
NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
NetSocket.write(String str,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
NetSocket.write(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
RecordParser |
RecordParser.endHandler(Handler<Void> endHandler) |
JsonParser |
JsonParser.endHandler(Handler<Void> endHandler) |
RecordParser |
RecordParser.exceptionHandler(Handler<Throwable> handler) |
JsonParser |
JsonParser.exceptionHandler(Handler<Throwable> handler) |
RecordParser |
RecordParser.handler(Handler<Buffer> handler) |
JsonParser |
JsonParser.handler(Handler<JsonEvent> handler) |
static RecordParser |
RecordParser.newDelimited(Buffer delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.core.buffer.Buffer>) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newDelimited(String delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava.core.buffer.Buffer>) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newFixed(int size,
Handler<Buffer> output)
Like
RecordParser.newFixed(int) but set the output that will receive whole records
which have been parsed. |
void |
RecordParser.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
JsonParser.pipeTo(WriteStream<JsonEvent> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
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.getAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the
AsyncMap with the specified name. |
<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 an asynchronous counter.
|
<K,V> void |
SharedData.getLocalAsyncMap(String name,
Handler<AsyncResult<AsyncMap<K,V>>> resultHandler)
Get the
AsyncMap with the specified name. |
void |
SharedData.getLocalCounter(String name,
Handler<AsyncResult<Counter>> resultHandler)
Get an asynchronous local counter.
|
void |
SharedData.getLocalLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get an asynchronous local lock with the specified name.
|
void |
SharedData.getLocalLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
|
void |
SharedData.getLock(String name,
Handler<AsyncResult<Lock>> resultHandler)
Get an asynchronous lock with the specified name.
|
void |
SharedData.getLockWithTimeout(String name,
long timeout,
Handler<AsyncResult<Lock>> resultHandler)
Like
SharedData.getLock(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.shareddata.Lock>>) but specifying a timeout. |
void |
Counter.incrementAndGet(Handler<AsyncResult<Long>> resultHandler)
Increment the counter atomically and return the new count
|
void |
AsyncMap.keys(Handler<AsyncResult<Set<K>>> resultHandler)
Get the keys of the map, asynchronously.
|
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 time to live for the entry. |
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 time to live for the entry. |
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.replace(K k,
V v,
long ttl,
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.replaceIfPresent(K k,
V oldValue,
V newValue,
long ttl,
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
|
void |
AsyncMap.values(Handler<AsyncResult<List<V>>> resultHandler)
Get the values of the map, asynchronously.
|
| Modifier and Type | Method and Description |
|---|---|
WriteStream<T> |
WriteStream.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
void |
WriteStream.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
WriteStream.end(T data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
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.
|
void |
ReadStream.pipeTo(WriteStream<T> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
Pipe.to(WriteStream<T> dst,
Handler<AsyncResult<Void>> completionHandler)
Start to pipe the elements to the destination
WriteStream. |
void |
WriteStream.write(T data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
DB2Connection |
DB2Connection.closeHandler(Handler<Void> handler) |
static void |
DB2Connection.connect(Vertx vertx,
DB2ConnectOptions connectOptions,
Handler<AsyncResult<DB2Connection>> handler)
Create a connection to DB2 server with the given
connectOptions. |
static void |
DB2Connection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<DB2Connection>> handler)
|
DB2Pool |
DB2Pool.connectHandler(Handler<SqlConnection> handler) |
DB2Connection |
DB2Connection.debug(Handler<AsyncResult<Void>> handler)
Send a DEBUG command to dump debug information to the server's stdout.
|
DB2Connection |
DB2Connection.exceptionHandler(Handler<Throwable> handler) |
DB2Connection |
DB2Connection.ping(Handler<AsyncResult<Void>> handler)
Send a PING command to check if the server is alive.
|
DB2Connection |
DB2Connection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
User |
User.isAuthorized(Authorization authority,
Handler<AsyncResult<Boolean>> resultHandler)
Deprecated.
|
User |
User.isAuthorized(String authority,
Handler<AsyncResult<Boolean>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
AuthenticationProvider.authenticate(Credentials credentials,
Handler<AsyncResult<User>> resultHandler)
Authenticate a user.
|
void |
AuthenticationProvider.authenticate(JsonObject credentials,
Handler<AsyncResult<User>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
AuthorizationProvider.getAuthorizations(User user,
Handler<AsyncResult<Void>> handler)
Updates the user with the set of authorizations.
|
| Modifier and Type | Method and Description |
|---|---|
JDBCUserUtil |
JDBCUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
JDBCUserUtil |
JDBCUserUtil.createRolePermission(String role,
String permission,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
JDBCUserUtil |
JDBCUserUtil.createUser(String username,
String password,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
JDBCUserUtil |
JDBCUserUtil.createUserRole(String username,
String role,
Handler<AsyncResult<Void>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
MongoUserUtil |
MongoUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<String>> resultHandler)
Insert a user into a database.
|
MongoUserUtil |
MongoUserUtil.createUser(String username,
String password,
Handler<AsyncResult<String>> resultHandler)
Insert a user into a database.
|
MongoUserUtil |
MongoUserUtil.createUserRolesAndPermissions(String username,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Insert a user role into a database.
|
void |
MongoAuth.insertUser(String username,
String password,
List<String> roles,
List<String> permissions,
Handler<AsyncResult<String>> resultHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
OAuth2Auth |
OAuth2Auth.jWKSet(Handler<AsyncResult<Void>> handler)
Retrieve the public server JSON Web Key (JWK) required to verify the authenticity
of issued ID and access tokens.
|
OAuth2Auth |
OAuth2Auth.missingKeyHandler(Handler<String> handler)
Handled to be called when a key (mentioned on a JWT) is missing from the current config.
|
OAuth2Auth |
OAuth2Auth.refresh(User user,
Handler<AsyncResult<User>> handler)
Refresh the current User (access token).
|
OAuth2Auth |
OAuth2Auth.revoke(User user,
Handler<AsyncResult<Void>> handler)
Revoke an obtained access token.
|
OAuth2Auth |
OAuth2Auth.revoke(User user,
String tokenType,
Handler<AsyncResult<Void>> handler)
Revoke an obtained access or refresh token.
|
OAuth2Auth |
OAuth2Auth.userInfo(User user,
Handler<AsyncResult<JsonObject>> handler)
Retrieve profile information and other attributes for a logged-in end-user.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
SalesforceAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
IBMCloudAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
GoogleAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
AzureADAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
OpenIDConnectAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
KeycloakAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
static void |
AmazonCognitoAuth.discover(Vertx vertx,
OAuth2Options config,
Handler<AsyncResult<OAuth2Auth>> handler)
Create a OAuth2Auth provider for OpenID Connect Discovery.
|
| Modifier and Type | Method and Description |
|---|---|
SqlUserUtil |
SqlUserUtil.createHashedUser(String username,
String hash,
Handler<AsyncResult<Void>> resultHandler)
Insert a user into a database.
|
SqlUserUtil |
SqlUserUtil.createRolePermission(String role,
String permission,
Handler<AsyncResult<Void>> resultHandler)
Insert a role permission into a database.
|
SqlUserUtil |
SqlUserUtil.createUser(String username,
String password,
Handler<AsyncResult<Void>> resultHandler)
Insert a user into a database.
|
SqlUserUtil |
SqlUserUtil.createUserRole(String username,
String role,
Handler<AsyncResult<Void>> resultHandler)
Insert a user role into a database.
|
| Modifier and Type | Method and Description |
|---|---|
WebAuthn |
WebAuthn.createCredentialsOptions(JsonObject user,
Handler<AsyncResult<JsonObject>> handler)
Gets a challenge and any other parameters for the
navigator.credentials.create() call. |
MetaDataService |
MetaDataService.fetchTOC(Handler<AsyncResult<Boolean>> handler)
Fetches the FIDO2 MDS3 TOC and process the entries to the metadata store.
|
MetaDataService |
MetaDataService.fetchTOC(String url,
Handler<AsyncResult<Boolean>> handler)
Fetches the FIDO2 TOC for the given URL and process the entries to the metadata store.
|
WebAuthn |
WebAuthn.getCredentialsOptions(String name,
Handler<AsyncResult<JsonObject>> handler)
Creates an assertion challenge and any other parameters for the
navigator.credentials.get() call. |
| Modifier and Type | Method and Description |
|---|---|
ConsulClient |
ConsulClient.agentInfo(Handler<AsyncResult<JsonObject>> resultHandler)
Returns the configuration and member information of the local agent
|
ConsulClient |
ConsulClient.catalogDatacenters(Handler<AsyncResult<List<String>>> resultHandler)
Return all the datacenters that are known by the Consul server
|
ConsulClient |
ConsulClient.catalogNodes(Handler<AsyncResult<NodeList>> resultHandler)
Returns the nodes registered in a datacenter
|
ConsulClient |
ConsulClient.catalogNodeServices(String node,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the node's registered services
|
ConsulClient |
ConsulClient.catalogNodeServicesWithOptions(String node,
BlockingQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the node's registered services
This is blocking query unlike
ConsulClient.catalogNodeServices(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>) |
ConsulClient |
ConsulClient.catalogNodesWithOptions(NodeQueryOptions options,
Handler<AsyncResult<NodeList>> resultHandler)
Returns the nodes registered in a datacenter
|
ConsulClient |
ConsulClient.catalogServiceNodes(String service,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the nodes providing a service
|
ConsulClient |
ConsulClient.catalogServiceNodesWithOptions(String service,
ServiceQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the nodes providing a service
|
ConsulClient |
ConsulClient.catalogServices(Handler<AsyncResult<ServiceList>> resultHandler)
Returns the services registered in a datacenter
|
ConsulClient |
ConsulClient.catalogServicesWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<ServiceList>> resultHandler)
Returns the services registered in a datacenter
This is blocking query unlike
ConsulClient.catalogServices(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.ServiceList>>) |
ConsulClient |
ConsulClient.cloneAclToken(String id,
Handler<AsyncResult<String>> idHandler)
Clone Acl token
|
ConsulClient |
ConsulClient.coordinateDatacenters(Handler<AsyncResult<List<DcCoordinates>>> resultHandler)
Returns the WAN network coordinates for all Consul servers, organized by DCs
|
ConsulClient |
ConsulClient.coordinateNodes(Handler<AsyncResult<CoordinateList>> resultHandler)
Returns the LAN network coordinates for all nodes in a given DC
|
ConsulClient |
ConsulClient.coordinateNodesWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<CoordinateList>> resultHandler)
Returns the LAN network coordinates for all nodes in a given DC
This is blocking query unlike
ConsulClient.coordinateNodes(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.CoordinateList>>) |
ConsulClient |
ConsulClient.createAclToken(AclToken token,
Handler<AsyncResult<String>> idHandler)
Create new Acl token
|
ConsulClient |
ConsulClient.createPreparedQuery(PreparedQueryDefinition definition,
Handler<AsyncResult<String>> resultHandler) |
ConsulClient |
ConsulClient.createSession(Handler<AsyncResult<String>> idHandler)
Initialize a new session
|
ConsulClient |
ConsulClient.createSessionWithOptions(SessionOptions options,
Handler<AsyncResult<String>> idHandler)
Initialize a new session
|
ConsulClient |
ConsulClient.deletePreparedQuery(String id,
Handler<AsyncResult<Void>> resultHandler)
Deletes an existing prepared query
|
ConsulClient |
ConsulClient.deleteValue(String key,
Handler<AsyncResult<Void>> resultHandler)
Remove the key/value pair that corresponding to the specified key
|
ConsulClient |
ConsulClient.deleteValues(String keyPrefix,
Handler<AsyncResult<Void>> resultHandler)
Removes all the key/value pair that corresponding to the specified key prefix
|
ConsulClient |
ConsulClient.deregisterCatalogService(String nodeId,
String serviceId,
Handler<AsyncResult<Void>> resultHandler)
Deregister entities from the node or deregister the node itself.
|
ConsulClient |
ConsulClient.deregisterCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Remove a check from the local agent.
|
ConsulClient |
ConsulClient.deregisterService(String id,
Handler<AsyncResult<Void>> resultHandler)
Remove a service from the local agent.
|
ConsulClient |
ConsulClient.destroyAclToken(String id,
Handler<AsyncResult<Void>> resultHandler)
Destroy Acl token
|
ConsulClient |
ConsulClient.destroySession(String id,
Handler<AsyncResult<Void>> resultHandler)
Destroys the given session
|
ConsulClient |
ConsulClient.executePreparedQuery(String query,
Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)
Executes an existing prepared query.
|
ConsulClient |
ConsulClient.executePreparedQueryWithOptions(String query,
PreparedQueryExecuteOptions options,
Handler<AsyncResult<PreparedQueryExecuteResponse>> resultHandler)
Executes an existing prepared query.
|
ConsulClient |
ConsulClient.failCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "critical".
|
ConsulClient |
ConsulClient.failCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "critical".
|
ConsulClient |
ConsulClient.fireEvent(String name,
Handler<AsyncResult<Event>> resultHandler)
Fires a new user event
|
ConsulClient |
ConsulClient.fireEventWithOptions(String name,
EventOptions options,
Handler<AsyncResult<Event>> resultHandler)
Fires a new user event
|
ConsulClient |
ConsulClient.getAllPreparedQueries(Handler<AsyncResult<List<PreparedQueryDefinition>>> resultHandler)
Returns a list of all prepared queries.
|
ConsulClient |
ConsulClient.getKeys(String keyPrefix,
Handler<AsyncResult<List<String>>> resultHandler)
Returns the list of keys that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getKeysWithOptions(String keyPrefix,
BlockingQueryOptions options,
Handler<AsyncResult<List<String>>> resultHandler)
Returns the list of keys that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getPreparedQuery(String id,
Handler<AsyncResult<PreparedQueryDefinition>> resultHandler)
Returns an existing prepared query
|
ConsulClient |
ConsulClient.getValue(String key,
Handler<AsyncResult<KeyValue>> resultHandler)
Returns key/value pair that corresponding to the specified key.
|
ConsulClient |
ConsulClient.getValues(String keyPrefix,
Handler<AsyncResult<KeyValueList>> resultHandler)
Returns the list of key/value pairs that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getValuesWithOptions(String keyPrefix,
BlockingQueryOptions options,
Handler<AsyncResult<KeyValueList>> resultHandler)
Returns the list of key/value pairs that corresponding to the specified key prefix.
|
ConsulClient |
ConsulClient.getValueWithOptions(String key,
BlockingQueryOptions options,
Handler<AsyncResult<KeyValue>> resultHandler)
Returns key/value pair that corresponding to the specified key.
|
ConsulClient |
ConsulClient.healthChecks(String service,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks associated with the service
|
ConsulClient |
ConsulClient.healthChecksWithOptions(String service,
CheckQueryOptions options,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks associated with the service
|
ConsulClient |
ConsulClient.healthServiceNodes(String service,
boolean passing,
Handler<AsyncResult<ServiceEntryList>> resultHandler)
Returns the nodes providing the service.
|
ConsulClient |
ConsulClient.healthServiceNodesWithOptions(String service,
boolean passing,
ServiceQueryOptions options,
Handler<AsyncResult<ServiceEntryList>> resultHandler)
Returns the nodes providing the service.
|
ConsulClient |
ConsulClient.healthState(HealthState healthState,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks in the specified status
|
ConsulClient |
ConsulClient.healthStateWithOptions(HealthState healthState,
CheckQueryOptions options,
Handler<AsyncResult<CheckList>> resultHandler)
Returns the checks in the specified status
|
ConsulClient |
ConsulClient.infoAclToken(String id,
Handler<AsyncResult<AclToken>> tokenHandler)
Get info of Acl token
|
ConsulClient |
ConsulClient.infoSession(String id,
Handler<AsyncResult<Session>> resultHandler)
Returns the requested session information
|
ConsulClient |
ConsulClient.infoSessionWithOptions(String id,
BlockingQueryOptions options,
Handler<AsyncResult<Session>> resultHandler)
Returns the requested session information
This is blocking query unlike
ConsulClient.infoSession(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.Session>>) |
ConsulClient |
ConsulClient.leaderStatus(Handler<AsyncResult<String>> resultHandler)
Get the Raft leader for the datacenter in which the agent is running.
|
ConsulClient |
ConsulClient.listAclTokens(Handler<AsyncResult<List<AclToken>>> resultHandler)
Get list of Acl token
|
ConsulClient |
ConsulClient.listEvents(Handler<AsyncResult<EventList>> resultHandler)
Returns the most recent events known by the agent
|
ConsulClient |
ConsulClient.listEventsWithOptions(EventListOptions options,
Handler<AsyncResult<EventList>> resultHandler)
Returns the most recent events known by the agent.
|
ConsulClient |
ConsulClient.listNodeSessions(String nodeId,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions for a given node
|
ConsulClient |
ConsulClient.listNodeSessionsWithOptions(String nodeId,
BlockingQueryOptions options,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions for a given node
This is blocking query unlike
ConsulClient.listNodeSessions(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>) |
ConsulClient |
ConsulClient.listSessions(Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions
|
ConsulClient |
ConsulClient.listSessionsWithOptions(BlockingQueryOptions options,
Handler<AsyncResult<SessionList>> resultHandler)
Returns the active sessions
This is blocking query unlike
ConsulClient.listSessions(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.ext.consul.SessionList>>) |
ConsulClient |
ConsulClient.localChecks(Handler<AsyncResult<List<Check>>> resultHandler)
Return all the checks that are registered with the local agent.
|
ConsulClient |
ConsulClient.localServices(Handler<AsyncResult<List<Service>>> resultHandler)
Returns list of services registered with the local agent.
|
ConsulClient |
ConsulClient.maintenanceService(MaintenanceOptions maintenanceOptions,
Handler<AsyncResult<Void>> resultHandler)
Places a given service into "maintenance mode"
|
ConsulClient |
ConsulClient.passCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "passing".
|
ConsulClient |
ConsulClient.passCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "passing".
|
ConsulClient |
ConsulClient.peersStatus(Handler<AsyncResult<List<String>>> resultHandler)
Retrieves the Raft peers for the datacenter in which the the agent is running.
|
ConsulClient |
ConsulClient.putValue(String key,
String value,
Handler<AsyncResult<Boolean>> resultHandler)
Adds specified key/value pair
|
ConsulClient |
ConsulClient.putValueWithOptions(String key,
String value,
KeyValueOptions options,
Handler<AsyncResult<Boolean>> resultHandler) |
ConsulClient |
ConsulClient.registerCatalogService(Node nodeOptions,
ServiceOptions serviceOptions,
Handler<AsyncResult<Void>> resultHandler)
Register node with external service
|
ConsulClient |
ConsulClient.registerCheck(CheckOptions checkOptions,
Handler<AsyncResult<Void>> resultHandler)
Add a new check to the local agent.
|
ConsulClient |
ConsulClient.registerService(ServiceOptions serviceOptions,
Handler<AsyncResult<Void>> resultHandler)
Adds a new service, with an optional health check, to the local agent.
|
ConsulClient |
ConsulClient.renewSession(String id,
Handler<AsyncResult<Session>> resultHandler)
Renews the given session.
|
Watch<T> |
Watch.setHandler(Handler<WatchResult<T>> handler)
Set the result handler.
|
ConsulClient |
ConsulClient.transaction(TxnRequest request,
Handler<AsyncResult<TxnResponse>> resultHandler)
Manages multiple operations inside a single, atomic transaction.
|
ConsulClient |
ConsulClient.updateAclToken(AclToken token,
Handler<AsyncResult<String>> idHandler)
Update Acl token
|
ConsulClient |
ConsulClient.updateCheck(String checkId,
CheckStatus status,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to given status.
|
ConsulClient |
ConsulClient.updateCheckWithNote(String checkId,
CheckStatus status,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to given status.
|
ConsulClient |
ConsulClient.updatePreparedQuery(PreparedQueryDefinition definition,
Handler<AsyncResult<Void>> resultHandler) |
ConsulClient |
ConsulClient.warnCheck(String checkId,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "warning".
|
ConsulClient |
ConsulClient.warnCheckWithNote(String checkId,
String note,
Handler<AsyncResult<Void>> resultHandler)
Set status of the check to "warning".
|
| Modifier and Type | Method and Description |
|---|---|
void |
TcpEventBusBridge.close(Handler<AsyncResult<Void>> handler)
Close the current socket.
|
static TcpEventBusBridge |
TcpEventBusBridge.create(Vertx vertx,
BridgeOptions options,
NetServerOptions netServerOptions,
Handler<BridgeEvent> eventHandler) |
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 |
HealthChecks.checkStatus(Handler<AsyncResult<CheckResult>> resultHandler)
Invokes the registered procedures.
|
void |
HealthChecks.checkStatus(String name,
Handler<AsyncResult<CheckResult>> resultHandler)
Invokes the registered procedure with the given name and sub-procedures.
|
HealthChecks |
HealthChecks.invoke(Handler<JsonObject> resultHandler)
Invokes the registered procedures and computes the outcome.
|
HealthChecks |
HealthChecks.invoke(String name,
Handler<AsyncResult<JsonObject>> resultHandler)
Invokes the registered procedure with the given name and sub-procedures.
|
HealthChecks |
HealthChecks.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthChecks |
HealthChecks.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
| Modifier and Type | Method and Description |
|---|---|
SQLOperations |
JDBCClient.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
JDBCClient.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
| Modifier and Type | Method and Description |
|---|---|
MailClient |
MailClient.sendMail(MailMessage email,
Handler<AsyncResult<MailResult>> resultHandler)
send a single mail via MailClient
|
| Modifier and Type | Method and Description |
|---|---|
MongoClient |
MongoClient.bulkWrite(String collection,
List<BulkOperation> operations,
Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)
Execute a bulk operation.
|
MongoClient |
MongoClient.bulkWriteWithOptions(String collection,
List<BulkOperation> operations,
BulkWriteOptions bulkWriteOptions,
Handler<AsyncResult<MongoClientBulkWriteResult>> resultHandler)
Execute a bulk operation with the specified write options.
|
void |
MongoClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release its resources
|
MongoClient |
MongoClient.count(String collection,
JsonObject query,
Handler<AsyncResult<Long>> resultHandler)
Count matching documents in a collection.
|
MongoClient |
MongoClient.countWithOptions(String collection,
JsonObject query,
CountOptions countOptions,
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.createCollectionWithOptions(String collectionName,
CreateCollectionOptions collectionOptions,
Handler<AsyncResult<Void>> resultHandler)
Create a new collection with options
|
MongoClient |
MongoClient.createDefaultGridFsBucketService(Handler<AsyncResult<MongoGridFsClient>> resultHandler)
Creates a
MongoGridFsClient used to interact with Mongo GridFS. |
MongoClient |
MongoClient.createGridFsBucketService(String bucketName,
Handler<AsyncResult<MongoGridFsClient>> resultHandler)
Creates a
MongoGridFsClient used to interact with Mongo GridFS. |
MongoClient |
MongoClient.createIndex(String collection,
JsonObject key,
Handler<AsyncResult<Void>> resultHandler)
Creates an index.
|
MongoClient |
MongoClient.createIndexes(String collection,
List<IndexModel> indexes,
Handler<AsyncResult<Void>> resultHandler)
creates an indexes
|
MongoClient |
MongoClient.createIndexWithOptions(String collection,
JsonObject key,
IndexOptions options,
Handler<AsyncResult<Void>> resultHandler)
Creates an index.
|
MongoGridFsClient |
MongoGridFsClient.delete(String id,
Handler<AsyncResult<Void>> resultHandler)
Deletes a file by it's ID
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
DistinctOptions distinctOptions,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinct(String collection,
String fieldName,
String resultClassname,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name.
|
MongoClient |
MongoClient.distinctWithQuery(String collection,
String fieldName,
String resultClassname,
JsonObject query,
DistinctOptions distinctOptions,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name filtered by specified query.
|
MongoClient |
MongoClient.distinctWithQuery(String collection,
String fieldName,
String resultClassname,
JsonObject query,
Handler<AsyncResult<JsonArray>> resultHandler)
Gets the distinct values of the specified field name filtered by specified query.
|
MongoGridFsClient |
MongoGridFsClient.downloadByFileName(WriteStream<Buffer> stream,
String fileName,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadByFileNameWithOptions(WriteStream<Buffer> stream,
String fileName,
GridFsDownloadOptions options,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadById(WriteStream<Buffer> stream,
String id,
Handler<AsyncResult<Long>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.downloadFile(String fileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file.
|
MongoGridFsClient |
MongoGridFsClient.downloadFileAs(String fileName,
String newFileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file and gives it a new name.
|
MongoGridFsClient |
MongoGridFsClient.downloadFileByID(String id,
String fileName,
Handler<AsyncResult<Long>> resultHandler)
Downloads a file using the ID generated by GridFs.
|
MongoGridFsClient |
MongoGridFsClient.drop(Handler<AsyncResult<Void>> resultHandler)
Drops the entire file bucket with all of its contents
|
MongoClient |
MongoClient.dropCollection(String collection,
Handler<AsyncResult<Void>> resultHandler)
Drop a collection
|
MongoClient |
MongoClient.dropIndex(String collection,
String indexName,
Handler<AsyncResult<Void>> resultHandler)
Drops the index given its name.
|
MongoClient |
MongoClient.find(String collection,
JsonObject query,
Handler<AsyncResult<List<JsonObject>>> resultHandler)
Find matching documents in the specified collection
|
MongoGridFsClient |
MongoGridFsClient.findAllIds(Handler<AsyncResult<List<String>>> resultHandler)
Finds all file ids in the bucket
|
MongoGridFsClient |
MongoGridFsClient.findIds(JsonObject query,
Handler<AsyncResult<List<String>>> resultHandler)
Finds all file ids that match a query.
|
MongoClient |
MongoClient.findOne(String collection,
JsonObject query,
JsonObject fields,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection
|
MongoClient |
MongoClient.findOneAndDelete(String collection,
JsonObject query,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and delete it.
|
MongoClient |
MongoClient.findOneAndDeleteWithOptions(String collection,
JsonObject query,
FindOptions findOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and delete it.
|
MongoClient |
MongoClient.findOneAndReplace(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and replace it.
|
MongoClient |
MongoClient.findOneAndReplaceWithOptions(String collection,
JsonObject query,
JsonObject replace,
FindOptions findOptions,
UpdateOptions updateOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and replace it.
|
MongoClient |
MongoClient.findOneAndUpdate(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and update it.
|
MongoClient |
MongoClient.findOneAndUpdateWithOptions(String collection,
JsonObject query,
JsonObject update,
FindOptions findOptions,
UpdateOptions updateOptions,
Handler<AsyncResult<JsonObject>> resultHandler)
Find a single matching document in the specified collection and update it.
|
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.listIndexes(String collection,
Handler<AsyncResult<JsonArray>> resultHandler)
Get all the indexes in this collection.
|
MongoClient |
MongoClient.removeDocument(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocuments(String collection,
JsonObject query,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocumentsWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove matching documents from a collection with the specified write option and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.removeDocumentWithOptions(String collection,
JsonObject query,
WriteOption writeOption,
Handler<AsyncResult<MongoClientDeleteResult>> resultHandler)
Remove a single matching document from a collection with the specified write option and return the handler with
MongoClientDeleteResult result |
MongoClient |
MongoClient.replaceDocuments(String collection,
JsonObject query,
JsonObject replace,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.replaceDocumentsWithOptions(String collection,
JsonObject query,
JsonObject replace,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Replace matching documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.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.updateCollection(String collection,
JsonObject query,
JsonArray update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Use an aggregation pipeline to update documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollection(String collection,
JsonObject query,
JsonObject update,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonArray update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Use an aggregation pipeline to update documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoClient |
MongoClient.updateCollectionWithOptions(String collection,
JsonObject query,
JsonObject update,
UpdateOptions options,
Handler<AsyncResult<MongoClientUpdateResult>> resultHandler)
Update matching documents in the specified collection, specifying options and return the handler with
MongoClientUpdateResult result |
MongoGridFsClient |
MongoGridFsClient.uploadByFileName(Observable<Buffer> stream,
String fileName,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileName(ReadStream<Buffer> stream,
String fileName,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileNameWithOptions(Observable<Buffer> stream,
String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadByFileNameWithOptions(ReadStream<Buffer> stream,
String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler) |
MongoGridFsClient |
MongoGridFsClient.uploadFile(String fileName,
Handler<AsyncResult<String>> resultHandler)
Upload a file to gridfs
|
MongoGridFsClient |
MongoGridFsClient.uploadFileWithOptions(String fileName,
GridFsUploadOptions options,
Handler<AsyncResult<String>> resultHandler)
Upload a file to gridfs with 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 |
ShellServer.shellHandler(Handler<Shell> shellHandler)
Called when a new shell is created.
|
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.
|
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 | Method and Description |
|---|---|
void |
TermServer.close(Handler<AsyncResult<Void>> completionHandler)
Like
TermServer.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) 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<Void>> 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.
|
Tty |
Tty.resizehandler(Handler<Void> handler)
Set a resize handler, the handler is called when the tty size changes.
|
Term |
Term.resizehandler(Handler<Void> handler) |
Tty |
Tty.stdinHandler(Handler<String> handler)
Set a stream handler on the standard input to read the data.
|
Term |
Term.stdinHandler(Handler<String> handler) |
Pty |
Pty.stdoutHandler(Handler<String> handler)
Set the standard out handler of the pseudo terminal.
|
SockJSTermHandler |
SockJSTermHandler.termHandler(Handler<Term> handler) |
TermServer |
TermServer.termHandler(Handler<Term> handler)
Set the term handler that will receive incoming client connections.
|
| Modifier and Type | Method and Description |
|---|---|
SQLConnection |
SQLConnection.batch(List<String> sqlStatements,
Handler<AsyncResult<List<Integer>>> handler)
Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
|
SQLConnection |
SQLConnection.batchCallableWithParams(String sqlStatement,
List<JsonArray> inArgs,
List<JsonArray> outArgs,
Handler<AsyncResult<List<Integer>>> handler)
Batch a callable statement with all entries from the args list.
|
SQLConnection |
SQLConnection.batchWithParams(String sqlStatement,
List<JsonArray> args,
Handler<AsyncResult<List<Integer>>> handler)
Batch a prepared statement with all entries from the args list.
|
SQLConnection |
SQLConnection.call(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLClient |
SQLClient.call(String sql,
Handler<AsyncResult<ResultSet>> handler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLOperations |
SQLOperations.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. |
SQLClient |
SQLClient.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> handler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
SQLOperations |
SQLOperations.callWithParams(String sql,
JsonArray params,
JsonArray outputs,
Handler<AsyncResult<ResultSet>> resultHandler)
Calls the given SQL
PROCEDURE which returns the result from the procedure. |
void |
SQLRowStream.close(Handler<AsyncResult<Void>> handler)
Closes the stream/underlying cursor(s).
|
void |
SQLConnection.close(Handler<AsyncResult<Void>> handler)
Closes the connection.
|
void |
SQLClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release all resources.
|
SQLConnection |
SQLConnection.commit(Handler<AsyncResult<Void>> handler)
Commits all changes made since the previous commit/rollback.
|
SQLRowStream |
SQLRowStream.endHandler(Handler<Void> endHandler) |
SQLRowStream |
SQLRowStream.exceptionHandler(Handler<Throwable> handler) |
SQLConnection |
SQLConnection.execute(String sql,
Handler<AsyncResult<Void>> resultHandler)
Executes the given SQL statement
|
SQLClient |
SQLClient.getConnection(Handler<AsyncResult<SQLConnection>> handler)
Returns a connection that can be used to perform SQL operations on.
|
SQLConnection |
SQLConnection.getTransactionIsolation(Handler<AsyncResult<TransactionIsolation>> handler)
Attempts to return the transaction isolation level for this Connection object to the one given.
|
SQLRowStream |
SQLRowStream.handler(Handler<JsonArray> handler) |
void |
SQLRowStream.pipeTo(WriteStream<JsonArray> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
SQLConnection |
SQLConnection.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
SQLClient |
SQLClient.query(String sql,
Handler<AsyncResult<ResultSet>> handler)
Execute a single SQL statement, this method acquires a connection from the the pool and executes the SQL
statement and returns it back after the execution.
|
SQLOperations |
SQLOperations.query(String sql,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT statement which returns the results of the query. |
SQLOperations |
SQLConnection.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
SQLClient.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
SQLOperations.querySingle(String sql,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement that returns a single SQL row.
|
SQLOperations |
SQLConnection.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLOperations |
SQLClient.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLOperations |
SQLOperations.querySingleWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<JsonArray>> handler)
Execute a one shot SQL statement with arguments that returns a single SQL row.
|
SQLConnection |
SQLConnection.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLClient |
SQLClient.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLOperations |
SQLOperations.queryStream(String sql,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLConnection |
SQLConnection.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLClient |
SQLClient.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
SQLOperations |
SQLOperations.queryStreamWithParams(String sql,
JsonArray params,
Handler<AsyncResult<SQLRowStream>> handler)
Executes the given SQL
SELECT statement which returns the results of the query as a read stream. |
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. |
SQLClient |
SQLClient.queryWithParams(String sql,
JsonArray arguments,
Handler<AsyncResult<ResultSet>> handler)
Execute a single SQL prepared statement, this method acquires a connection from the the pool and executes the SQL
prepared statement and returns it back after the execution.
|
SQLOperations |
SQLOperations.queryWithParams(String sql,
JsonArray params,
Handler<AsyncResult<ResultSet>> resultHandler)
Executes the given SQL
SELECT prepared statement which returns the results of the query. |
SQLRowStream |
SQLRowStream.resultSetClosedHandler(Handler<Void> handler)
Event handler when a resultset is closed.
|
SQLConnection |
SQLConnection.rollback(Handler<AsyncResult<Void>> handler)
Rolls back all changes made since the previous commit/rollback.
|
SQLConnection |
SQLConnection.setAutoCommit(boolean autoCommit,
Handler<AsyncResult<Void>> resultHandler)
Sets the auto commit flag for this connection.
|
SQLConnection |
SQLConnection.setTransactionIsolation(TransactionIsolation isolation,
Handler<AsyncResult<Void>> handler)
Attempts to change the transaction isolation level for this Connection object to the one given.
|
SQLConnection |
SQLConnection.update(String sql,
Handler<AsyncResult<UpdateResult>> resultHandler)
Executes the given SQL statement which may be an
INSERT, UPDATE, or DELETE
statement. |
SQLClient |
SQLClient.update(String sql,
Handler<AsyncResult<UpdateResult>> handler)
Executes the given SQL statement which may be an
INSERT, UPDATE, or DELETE
statement. |
SQLOperations |
SQLOperations.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 |
SQLClient |
SQLClient.updateWithParams(String sql,
JsonArray params,
Handler<AsyncResult<UpdateResult>> handler)
Executes the given prepared statement which may be an
INSERT, UPDATE, or DELETE
statement with the given parameters |
SQLOperations |
SQLOperations.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 | Method and Description |
|---|---|
Handler<ServerWebSocket> |
StompServer.webSocketHandler()
Gets the able to manage web socket connections.
|
| Modifier and Type | Method and Description |
|---|---|
StompClientConnection |
StompClientConnection.abort(String id,
Handler<AsyncResult<Frame>> receiptHandler)
Aborts a transaction.
|
StompClientConnection |
StompClientConnection.abort(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Sends an acknowledgement for a specific message.
|
StompClientConnection |
StompClientConnection.ack(String id,
String txId,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Begins a transaction.
|
StompClientConnection |
StompClientConnection.beginTX(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Commits a transaction.
|
StompClientConnection |
StompClientConnection.commit(String id,
Map<String,String> headers,
Handler<AsyncResult<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<AsyncResult<Frame>> receiptHandler)
Disconnects the client.
|
StompClientConnection |
StompClientConnection.disconnect(Handler<AsyncResult<Frame>> receiptHandler)
Disconnects the client.
|
StompServerHandler |
StompServerHandler.disconnectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
DISCONNECT frame is received. |
StompClient |
StompClient.errorFrameHandler(Handler<Frame> handler)
A general error frame handler.
|
StompClientConnection |
StompClientConnection.errorHandler(Handler<Frame> handler)
Sets a handler notified when an
ERROR frame is received by the client. |
StompClientConnection |
StompClientConnection.exceptionHandler(Handler<Throwable> exceptionHandler)
Configures the exception handler notified upon TCP-level errors.
|
StompClient |
StompClient.exceptionHandler(Handler<Throwable> handler)
Sets an exception handler notified for TCP-level errors.
|
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<AsyncResult<Frame>> receiptHandler)
Sends a non-acknowledgement for the given message.
|
StompClientConnection |
StompClientConnection.nack(String id,
String txId,
Handler<AsyncResult<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(StompServerConnection connection,
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.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that get notified when a STOMP frame is received by the client.
|
StompClient |
StompClient.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that gets notified when a STOMP frame is received by the client.
|
StompServerHandler |
StompServerHandler.receivedFrameHandler(Handler<ServerFrame> handler)
Configures a handler that get notified when a STOMP frame is received by the server.
|
Single<String> |
StompClientConnection.rxSubscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
Single<String> |
StompClientConnection.rxSubscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.send(Frame frame,
Handler<AsyncResult<Frame>> receiptHandler)
Sends the given frame to the server.
|
StompClientConnection |
StompClientConnection.send(Map<String,String> headers,
Buffer body,
Handler<AsyncResult<Frame>> receiptHandler)
Sends a
SEND frame to the server. |
StompClientConnection |
StompClientConnection.send(String destination,
Buffer body,
Handler<AsyncResult<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<AsyncResult<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. |
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<AsyncResult<String>> receiptHandler)
Subscribes to the given destination.
|
StompClientConnection |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler,
Handler<AsyncResult<String>> 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<AsyncResult<Frame>> receiptHandler)
Un-subscribes from the given destination.
|
StompClientConnection |
StompClientConnection.unsubscribe(String destination,
Map<String,String> headers,
Handler<AsyncResult<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. |
StompClientConnection |
StompClientConnection.writingFrameHandler(Handler<Frame> handler)
Configures a handler notified when a frame is going to be written on the wire.
|
StompClient |
StompClient.writingFrameHandler(Handler<Frame> handler)
Configures a writing handler that gets notified when a STOMP frame is written on the wire.
|
StompServer |
StompServer.writingFrameHandler(Handler<ServerFrame> handler)
Configures the handler that is invoked every time a frame is going to be written to the "wire".
|
| Modifier and Type | Method and Description |
|---|---|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it completes the async operation.
When the returned handler is called back with a failed result it fails the test with the cause of the failure.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
Handler<Throwable> |
TestContext.exceptionHandler() |
| Modifier and Type | Method and Description |
|---|---|
TestSuite |
TestSuite.after(Handler<TestContext> callback)
Set a callback executed after the tests.
|
TestSuite |
TestSuite.afterEach(Handler<TestContext> callback)
Set a callback executed after each test and before the suite
after callback. |
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
TestSuite |
TestSuite.before(Handler<TestContext> callback)
Set a callback executed before the tests.
|
TestSuite |
TestSuite.beforeEach(Handler<TestContext> callback)
Set a callback executed before each test and after the suite
before callback. |
static TestCase |
TestCase.create(String name,
Handler<TestContext> testCase)
Create a test case.
|
void |
Completion.handler(Handler<AsyncResult<T>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
void |
Async.handler(Handler<AsyncResult<Void>> completionHandler)
Completion handler to receive a completion signal when this completions completes.
|
void |
TestCompletion.handler(Handler<AsyncResult<Void>> 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.
|
TestContext |
TestContext.verify(Handler<Void> block)
Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.
|
| 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) |
void |
TestSuiteReport.pipeTo(WriteStream<TestCaseReport> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
| Modifier and Type | Method and Description |
|---|---|
int |
RoutingContext.addBodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
int |
RoutingContext.addEndHandler(Handler<AsyncResult<Void>> handler)
Add an end handler for the request/response context.
|
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.
|
RoutingContext |
RoutingContext.end(Buffer buffer,
Handler<AsyncResult<Void>> handler)
|
RoutingContext |
RoutingContext.end(Handler<AsyncResult<Void>> handler)
|
RoutingContext |
RoutingContext.end(String chunk,
Handler<AsyncResult<Void>> handler)
|
Router |
Router.errorHandler(int statusCode,
Handler<RoutingContext> errorHandler)
Specify an handler to handle an error for a particular status code.
|
Route |
Route.failureHandler(Handler<RoutingContext> failureHandler)
Append a failure handler to the route failure handlers list.
|
Route |
Route.handler(Handler<RoutingContext> requestHandler)
Append a request handler to the route handlers list.
|
RoutingContext |
RoutingContext.json(Object json,
Handler<AsyncResult<Void>> handler)
|
Router |
Router.modifiedHandler(Handler<Router> handler)
When a Router routes are changed this handler is notified.
|
RoutingContext |
RoutingContext.redirect(String url,
Handler<AsyncResult<Void>> handler)
|
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
RouterFactory.getValidationFailureHandler()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
RouterFactory |
RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
|
RouterFactory |
RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
|
RouterFactory |
RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
OpenAPI3RouterFactory.getValidationFailureHandler()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addFailureHandlerByOperationId(String operationId,
Handler<RoutingContext> failureHandler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addHandlerByOperationId(String operationId,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String securitySchemaName,
String scopeName,
Handler<RoutingContext> handler)
Deprecated.
|
static void |
OpenAPI3RouterFactory.create(Vertx vertx,
String url,
Handler<AsyncResult<OpenAPI3RouterFactory>> handler)
Deprecated.
|
static void |
OpenAPI3RouterFactory.create(Vertx vertx,
String url,
List<JsonObject> auth,
Handler<AsyncResult<OpenAPI3RouterFactory>> handler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
TemplateEngine.render(JsonObject context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render the template.
|
void |
TemplateEngine.render(Map<String,Object> context,
String templateFileName,
Handler<AsyncResult<Buffer>> handler)
Render the template.
|
| Modifier and Type | Method and Description |
|---|---|
MultiTenantHandler |
MultiTenantHandler.addDefaultHandler(Handler<RoutingContext> handler)
Add a default handler for the case when no tenant was matched.
|
MultiTenantHandler |
MultiTenantHandler.addTenantHandler(String tenant,
Handler<RoutingContext> handler)
Add a handler for a given tenant to this handler.
|
SessionHandler |
SessionHandler.flush(RoutingContext ctx,
boolean ignoreStatus,
Handler<AsyncResult<Void>> handler)
Flush a context session earlier to the store, this will allow the end user to have full control on the event of
a failure at the store level.
|
SessionHandler |
SessionHandler.flush(RoutingContext ctx,
Handler<AsyncResult<Void>> handler)
Flush a context session earlier to the store, this will allow the end user to have full control on the event of
a failure at the store level.
|
SessionHandler |
SessionHandler.setUser(RoutingContext context,
User user,
Handler<AsyncResult<Void>> handler)
Set the user for the session
|
| Modifier and Type | Method and Description |
|---|---|
ApolloWSHandler |
ApolloWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<ApolloWSMessage>> config)
Set a callback to invoke before executing a GraphQL query.
|
GraphQLHandler |
GraphQLHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<RoutingContext>> config)
Set a callback to invoke before executing a GraphQL query.
|
ApolloWSHandler |
ApolloWSHandler.connectionHandler(Handler<ServerWebSocket> connectionHandler)
Customize the connection .
|
ApolloWSHandler |
ApolloWSHandler.connectionInitHandler(Handler<ApolloWSConnectionInitEvent> connectionInitHandler)
Customize the connection init .
|
ApolloWSHandler |
ApolloWSHandler.endHandler(Handler<ServerWebSocket> endHandler)
Customize the end .
|
ApolloWSHandler |
ApolloWSHandler.messageHandler(Handler<ApolloWSMessage> messageHandler)
Customize the message .
|
| Modifier and Type | Method and Description |
|---|---|
GraphQLWSHandler |
GraphQLWSHandler.beforeExecute(Handler<ExecutionInputBuilderWithContext<Message>> config)
Set a callback to invoke before executing a GraphQL query.
|
GraphQLWSHandler |
GraphQLWSHandler.connectionInitHandler(Handler<ConnectionInitEvent> connectionInitHandler)
Customize the connection init .
|
| Modifier and Type | Method and Description |
|---|---|
Router |
SockJSHandler.bridge(AuthorizationProvider authorizationProvider,
SockJSBridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions) but specifying a handler
that will receive bridge events. |
Router |
SockJSHandler.bridge(SockJSBridgeOptions bridgeOptions,
Handler<BridgeEvent> bridgeEventHandler)
Like
SockJSHandler.bridge(io.vertx.ext.web.handler.sockjs.SockJSBridgeOptions) but specifying a handler
that will receive bridge events. |
SockJSSocket |
SockJSSocket.closeHandler(Handler<Void> closeHandler) |
SockJSSocket |
SockJSSocket.drainHandler(Handler<Void> handler) |
void |
SockJSSocket.end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
SockJSSocket.end(Handler<AsyncResult<Void>> handler)
Same as
SockJSSocket.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
SockJSSocket |
SockJSSocket.endHandler(Handler<Void> endHandler) |
SockJSSocket |
SockJSSocket.exceptionHandler(Handler<Throwable> handler) |
SockJSSocket |
SockJSSocket.handler(Handler<Buffer> handler) |
void |
SockJSSocket.pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
Router |
SockJSHandler.socketHandler(Handler<SockJSSocket> handler)
Set a SockJS socket handler.
|
void |
SockJSSocket.write(Buffer data,
Handler<AsyncResult<Void>> handler) |
void |
SockJSSocket.write(String data,
Handler<AsyncResult<Void>> handler) |
| Modifier and Type | Method and Description |
|---|---|
SessionStore |
SessionStore.clear(Handler<AsyncResult<Void>> resultHandler)
Remove all sessions from the store.
|
SessionStore |
SessionStore.delete(String id,
Handler<AsyncResult<Void>> resultHandler)
Delete the session with the specified ID.
|
SessionStore |
SessionStore.get(String cookieValue,
Handler<AsyncResult<Session>> resultHandler)
Get the session with the specified ID.
|
SessionStore |
SessionStore.put(Session session,
Handler<AsyncResult<Void>> resultHandler)
Add a session with the specified ID.
|
SessionStore |
SessionStore.size(Handler<AsyncResult<Integer>> resultHandler)
Get the number of sessions in the store.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SchemaRouter.resolveRef(JsonPointer pointer,
JsonPointer scope,
SchemaParser schemaParser,
Handler<AsyncResult<Schema>> handler)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KafkaAdminClient.close(Handler<AsyncResult<Void>> handler)
Close the admin client
|
void |
KafkaAdminClient.close(long timeout,
Handler<AsyncResult<Void>> handler)
Close the admin client
|
void |
KafkaAdminClient.createAcls(List<org.apache.kafka.common.acl.AclBinding> aclBindings,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Create the ACL rules.
|
void |
KafkaAdminClient.createPartitions(Map<String,NewPartitions> partitions,
Handler<AsyncResult<Void>> completionHandler)
Creates a batch of new partitions in the Kafka topic
|
void |
KafkaAdminClient.createTopics(List<NewTopic> topics,
Handler<AsyncResult<Void>> completionHandler)
Creates a batch of new Kafka topics
|
void |
KafkaAdminClient.deleteAcls(List<org.apache.kafka.common.acl.AclBindingFilter> aclBindings,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Delete the ACL rules.
|
void |
KafkaAdminClient.deleteConsumerGroupOffsets(String groupId,
Set<TopicPartition> partitions,
Handler<AsyncResult<Void>> completionHandler)
Delete committed offsets for a set of partitions in a consumer group.
|
void |
KafkaAdminClient.deleteConsumerGroups(List<String> groupIds,
Handler<AsyncResult<Void>> completionHandler)
Delete consumer groups from the cluster.
|
void |
KafkaAdminClient.deleteTopics(List<String> topicNames,
Handler<AsyncResult<Void>> completionHandler)
Deletes a batch of Kafka topics
|
void |
KafkaAdminClient.describeAcls(org.apache.kafka.common.acl.AclBindingFilter aclBindingFilter,
Handler<AsyncResult<List<org.apache.kafka.common.acl.AclBinding>>> completionHandler)
Describe the ACL rules.
|
void |
KafkaAdminClient.describeCluster(DescribeClusterOptions options,
Handler<AsyncResult<ClusterDescription>> completionHandler)
Like
KafkaAdminClient.describeCluster(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.kafka.admin.ClusterDescription>>) but allows customized options. |
void |
KafkaAdminClient.describeCluster(Handler<AsyncResult<ClusterDescription>> completionHandler)
Describe the nodes in the cluster with the default options
|
void |
KafkaAdminClient.describeConsumerGroups(List<String> groupIds,
DescribeConsumerGroupsOptions options,
Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)
|
void |
KafkaAdminClient.describeConsumerGroups(List<String> groupIds,
Handler<AsyncResult<Map<String,ConsumerGroupDescription>>> completionHandler)
Describe some group ids in the cluster, with the default options
|
void |
KafkaAdminClient.describeTopics(List<String> topicNames,
DescribeTopicsOptions options,
Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)
|
void |
KafkaAdminClient.describeTopics(List<String> topicNames,
Handler<AsyncResult<Map<String,TopicDescription>>> completionHandler)
Describe some topics in the cluster, with the default options.
|
void |
KafkaAdminClient.listConsumerGroups(Handler<AsyncResult<List<ConsumerGroupListing>>> completionHandler)
Get the the consumer groups available in the cluster with the default options
|
void |
KafkaAdminClient.listTopics(Handler<AsyncResult<Set<String>>> completionHandler)
List the topics available in the cluster with the default options.
|
| Modifier and Type | Method and Description |
|---|---|
KafkaConsumer<K,V> |
KafkaConsumer.assign(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a list of partition to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assign(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Manually assign a partition to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.assignment(Handler<AsyncResult<Set<TopicPartition>>> handler)
Get the set of partitions currently assigned to this consumer.
|
KafkaConsumer<K,V> |
KafkaConsumer.batchHandler(Handler<KafkaConsumerRecords<K,V>> handler)
Set the handler to be used when batches of messages are fetched
from the Kafka server.
|
void |
KafkaConsumer.beginningOffsets(TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the first offset for the given partitions.
|
void |
KafkaConsumer.close(Handler<AsyncResult<Void>> completionHandler)
Close the consumer
|
void |
KafkaConsumer.commit(Handler<AsyncResult<Void>> completionHandler)
Commit current offsets for all the subscribed list of topics and partition.
|
void |
KafkaConsumer.committed(TopicPartition topicPartition,
Handler<AsyncResult<OffsetAndMetadata>> handler)
Get the last committed offset for the given partition (whether the commit happened by this process or another).
|
KafkaConsumer<K,V> |
KafkaConsumer.endHandler(Handler<Void> endHandler) |
void |
KafkaConsumer.endOffsets(TopicPartition topicPartition,
Handler<AsyncResult<Long>> handler)
Get the last offset for the given partition.
|
KafkaConsumer<K,V> |
KafkaConsumer.exceptionHandler(Handler<Throwable> handler) |
KafkaConsumer<K,V> |
KafkaConsumer.handler(Handler<KafkaConsumerRecord<K,V>> handler) |
void |
KafkaConsumer.offsetsForTimes(TopicPartition topicPartition,
Long timestamp,
Handler<AsyncResult<OffsetAndTimestamp>> handler)
Look up the offset for the given partition by timestamp.
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsAssignedHandler(Handler<Set<TopicPartition>> handler)
Set the handler called when topic partitions are assigned to the consumer
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsFor(String topic,
Handler<AsyncResult<List<PartitionInfo>>> handler)
Get metadata about the partitions for a given topic.
|
KafkaConsumer<K,V> |
KafkaConsumer.partitionsRevokedHandler(Handler<Set<TopicPartition>> handler)
Set the handler called when topic partitions are revoked to the consumer
|
KafkaConsumer<K,V> |
KafkaConsumer.pause(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.pause(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Suspend fetching from the requested partition.
|
void |
KafkaConsumer.paused(Handler<AsyncResult<Set<TopicPartition>>> handler)
Get the set of partitions that were previously paused by a call to pause(Set).
|
void |
KafkaConsumer.pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
KafkaConsumer.poll(java.time.Duration timeout,
Handler<AsyncResult<KafkaConsumerRecords<K,V>>> handler)
Executes a poll for getting messages from Kafka.
|
void |
KafkaConsumer.position(TopicPartition partition,
Handler<AsyncResult<Long>> handler)
Get the offset of the next record that will be fetched (if a record with that offset exists).
|
KafkaConsumer<K,V> |
KafkaConsumer.resume(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partitions which have been paused with pause.
|
KafkaConsumer<K,V> |
KafkaConsumer.resume(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Resume specified partition which have been paused with pause.
|
KafkaConsumer<K,V> |
KafkaConsumer.seek(TopicPartition topicPartition,
long offset,
Handler<AsyncResult<Void>> completionHandler)
Overrides the fetch offsets that the consumer will use on the next poll.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToBeginning(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToBeginning(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Seek to the first offset for each of the given partition.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToEnd(Set<TopicPartition> topicPartitions,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.seekToEnd(TopicPartition topicPartition,
Handler<AsyncResult<Void>> completionHandler)
Seek to the last offset for each of the given partition.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(Set<String> topics,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given list of topics to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscribe(String topic,
Handler<AsyncResult<Void>> completionHandler)
Subscribe to the given topic to get dynamically assigned partitions.
|
KafkaConsumer<K,V> |
KafkaConsumer.subscription(Handler<AsyncResult<Set<String>>> handler)
Get the current subscription.
|
KafkaConsumer<K,V> |
KafkaConsumer.unsubscribe(Handler<AsyncResult<Void>> completionHandler)
Unsubscribe from topics currently subscribed with subscribe.
|
| Modifier and Type | Method and Description |
|---|---|
KafkaProducer<K,V> |
KafkaProducer.abortTransaction(Handler<AsyncResult<Void>> handler)
Aborts the ongoing transaction.
|
KafkaProducer<K,V> |
KafkaProducer.beginTransaction(Handler<AsyncResult<Void>> handler)
Starts a new kafka transaction.
|
void |
KafkaProducer.close(Handler<AsyncResult<Void>> completionHandler)
Close the producer
|
void |
KafkaProducer.close(long timeout,
Handler<AsyncResult<Void>> completionHandler)
Close the producer
|
KafkaProducer<K,V> |
KafkaProducer.commitTransaction(Handler<AsyncResult<Void>> handler)
Commits the ongoing transaction.
|
KafkaProducer<K,V> |
KafkaProducer.drainHandler(Handler<Void> handler) |
void |
KafkaProducer.end(Handler<AsyncResult<Void>> handler)
Same as
WriteStream.end(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with an handler called when the operation completes |
void |
KafkaProducer.end(KafkaProducerRecord<K,V> data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
KafkaProducer<K,V> |
KafkaProducer.exceptionHandler(Handler<Throwable> handler) |
KafkaProducer<K,V> |
KafkaProducer.flush(Handler<AsyncResult<Void>> completionHandler)
Invoking this method makes all buffered records immediately available to write
|
KafkaProducer<K,V> |
KafkaProducer.initTransactions(Handler<AsyncResult<Void>> handler)
Initializes the underlying kafka transactional producer.
|
KafkaProducer<K,V> |
KafkaProducer.partitionsFor(String topic,
Handler<AsyncResult<List<PartitionInfo>>> handler)
Get the partition metadata for the give topic.
|
KafkaProducer<K,V> |
KafkaProducer.send(KafkaProducerRecord<K,V> record,
Handler<AsyncResult<RecordMetadata>> handler)
Asynchronously write a record to a topic
|
void |
KafkaProducer.write(KafkaProducerRecord<K,V> data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
| Modifier and Type | Method and Description |
|---|---|
static Handler<RoutingContext> |
PrometheusScrapingHandler.create()
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
static Handler<RoutingContext> |
PrometheusScrapingHandler.create(io.micrometer.prometheus.PrometheusMeterRegistry registry)
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
static Handler<RoutingContext> |
PrometheusScrapingHandler.create(String registryName)
Creates a Vert.x Web
Route handler for Prometheus metrics scraping. |
| Modifier and Type | Method and Description |
|---|---|
void |
MqttServer.close(Handler<AsyncResult<Void>> completionHandler)
Close the server supplying an handler that will be called when the server is actually closed (or has failed).
|
MqttClient |
MqttClient.closeHandler(Handler<Void> closeHandler)
Set a handler that will be called when the connection with server is closed
|
MqttEndpoint |
MqttEndpoint.closeHandler(Handler<Void> handler)
Set a close handler.
|
MqttClient |
MqttClient.connect(int port,
String host,
Handler<AsyncResult<MqttConnAckMessage>> connectHandler)
Connects to an MQTT server calling connectHandler after connection
|
MqttClient |
MqttClient.connect(int port,
String host,
String serverName,
Handler<AsyncResult<MqttConnAckMessage>> connectHandler)
Connects to an MQTT server calling connectHandler after connection
|
MqttClient |
MqttClient.disconnect(Handler<AsyncResult<Void>> disconnectHandler)
Disconnects from the MQTT server calling disconnectHandler after disconnection
|
MqttEndpoint |
MqttEndpoint.disconnectHandler(Handler<Void> handler)
Set a disconnect handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.disconnectMessageHandler(Handler<MqttDisconnectMessage> handler)
Set a disconnect handler on the MQTT endpoint.
|
MqttServer |
MqttServer.endpointHandler(Handler<MqttEndpoint> handler)
Set the endpoint handler for the server.
|
MqttClient |
MqttClient.exceptionHandler(Handler<Throwable> handler)
Set an exception handler for the client, that will be called when an error happens
in internal netty structures.
|
MqttEndpoint |
MqttEndpoint.exceptionHandler(Handler<Throwable> handler)
Set an exception handler.
|
MqttServer |
MqttServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler for the server, that will be called when an error happens independantly of an
accepted
MqttEndpoint, like a rejected connection |
MqttServer |
MqttServer.listen(Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections using the specified options
through the constructor
|
MqttServer |
MqttServer.listen(int port,
Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections on the port specified but on
"0.0.0.0" as host.
|
MqttServer |
MqttServer.listen(int port,
String host,
Handler<AsyncResult<MqttServer>> listenHandler)
Start the server listening for incoming connections on the port and host specified
It ignores any options specified through the constructor
|
MqttEndpoint |
MqttEndpoint.pingHandler(Handler<Void> handler)
Set the pingreq handler on the MQTT endpoint.
|
MqttClient |
MqttClient.pingResponseHandler(Handler<Void> pingResponseHandler)
Sets handler which will be called after PINGRESP packet receiving
|
MqttClient |
MqttClient.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
int messageId,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
|
MqttEndpoint |
MqttEndpoint.publish(String topic,
Buffer payload,
io.netty.handler.codec.mqtt.MqttQoS qosLevel,
boolean isDup,
boolean isRetain,
int messageId,
io.netty.handler.codec.mqtt.MqttProperties properties,
Handler<AsyncResult<Integer>> publishSentHandler)
Sends the PUBLISH message to the remote MQTT server explicitly specifying the messageId
|
MqttEndpoint |
MqttEndpoint.publishAcknowledgeHandler(Handler<Integer> handler)
Set the puback handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishAcknowledgeMessageHandler(Handler<MqttPubAckMessage> handler)
Set the puback handler on the MQTT endpoint.
|
MqttClient |
MqttClient.publishCompletionExpirationHandler(Handler<Integer> publishCompletionExpirationHandler)
Sets a handler which will be called when the client does not receive a PUBACK or
PUBREC/PUBCOMP for a message published using QoS 1 or 2 respectively.
|
MqttClient |
MqttClient.publishCompletionHandler(Handler<Integer> publishCompletionHandler)
Sets a handler which will be called each time the publishing of a message has been completed.
|
MqttEndpoint |
MqttEndpoint.publishCompletionHandler(Handler<Integer> handler)
Set the pubcomp handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishCompletionMessageHandler(Handler<MqttPubCompMessage> handler)
Set the pubcomp handler on the MQTT endpoint.
|
MqttClient |
MqttClient.publishCompletionUnknownPacketIdHandler(Handler<Integer> publishCompletionPhantomHandler)
Sets a handler which will be called when the client receives a PUBACK/PUBREC/PUBCOMP with an unknown
packet ID.
|
MqttClient |
MqttClient.publishHandler(Handler<MqttPublishMessage> publishHandler)
Sets handler which will be called each time server publish something to client
|
MqttEndpoint |
MqttEndpoint.publishHandler(Handler<MqttPublishMessage> handler)
Set the publish handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReceivedHandler(Handler<Integer> handler)
Set the pubrec handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReceivedMessageHandler(Handler<MqttPubRecMessage> handler)
Set the pubrec handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReleaseHandler(Handler<Integer> handler)
Set the pubrel handler on the MQTT endpoint.
|
MqttEndpoint |
MqttEndpoint.publishReleaseMessageHandler(Handler<MqttPubRelMessage> handler)
Set the pubrel handler on the MQTT endpoint.
|
MqttClient |
MqttClient.subscribe(Map<String,Integer> topics,
Handler<AsyncResult<Integer>> subscribeSentHandler)
Subscribes to the topic and adds a handler which will be called after the request is sent
|
MqttClient |
MqttClient.subscribe(String topic,
int qos,
Handler<AsyncResult<Integer>> subscribeSentHandler)
Subscribes to the topic with a specified QoS level
|
MqttClient |
MqttClient.subscribeCompletionHandler(Handler<MqttSubAckMessage> subscribeCompletionHandler)
Sets handler which will be called after SUBACK packet receiving
|
MqttEndpoint |
MqttEndpoint.subscribeHandler(Handler<MqttSubscribeMessage> handler)
Set a subscribe handler on the MQTT endpoint.
|
MqttClient |
MqttClient.unsubscribe(String topic,
Handler<AsyncResult<Integer>> unsubscribeSentHandler)
Unsubscribe from receiving messages on given topic
|
MqttClient |
MqttClient.unsubscribeCompletionHandler(Handler<Integer> unsubscribeCompletionHandler)
Sets handler which will be called after UNSUBACK packet receiving
|
MqttEndpoint |
MqttEndpoint.unsubscribeHandler(Handler<MqttUnsubscribeMessage> handler)
Set a unsubscribe handler on the MQTT endpoint.
|
| Modifier and Type | Method and Description |
|---|---|
MSSQLConnection |
MSSQLConnection.closeHandler(Handler<Void> handler) |
static void |
MSSQLConnection.connect(Vertx vertx,
MSSQLConnectOptions connectOptions,
Handler<AsyncResult<MSSQLConnection>> handler)
Create a connection to SQL Server with the given
connectOptions. |
static void |
MSSQLConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<MSSQLConnection>> handler)
|
MSSQLPool |
MSSQLPool.connectHandler(Handler<SqlConnection> handler) |
MSSQLConnection |
MSSQLConnection.exceptionHandler(Handler<Throwable> handler) |
MSSQLConnection |
MSSQLConnection.infoHandler(Handler<MSSQLInfo> handler)
Set a handler called when the connection receives an informational message from the server.
|
MSSQLConnection |
MSSQLConnection.prepare(String s,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
MySQLConnection |
MySQLConnection.changeUser(MySQLAuthOptions options,
Handler<AsyncResult<Void>> handler)
Send a CHANGE_USER command to change the user of the current connection, this operation will also reset connection state.
|
MySQLConnection |
MySQLConnection.closeHandler(Handler<Void> handler) |
static void |
MySQLConnection.connect(Vertx vertx,
MySQLConnectOptions connectOptions,
Handler<AsyncResult<MySQLConnection>> handler)
Create a connection to MySQL server with the given
connectOptions. |
static void |
MySQLConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<MySQLConnection>> handler)
|
MySQLPool |
MySQLPool.connectHandler(Handler<SqlConnection> handler) |
MySQLConnection |
MySQLConnection.debug(Handler<AsyncResult<Void>> handler)
Send a DEBUG command to dump debug information to the server's stdout.
|
MySQLConnection |
MySQLConnection.exceptionHandler(Handler<Throwable> handler) |
MySQLConnection |
MySQLConnection.getInternalStatistics(Handler<AsyncResult<String>> handler)
Send a STATISTICS command to get a human readable string of the server internal status.
|
MySQLConnection |
MySQLConnection.ping(Handler<AsyncResult<Void>> handler)
Send a PING command to check if the server is alive.
|
MySQLConnection |
MySQLConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
MySQLConnection |
MySQLConnection.resetConnection(Handler<AsyncResult<Void>> handler)
Send a RESET_CONNECTION command to reset the session state.
|
MySQLConnection |
MySQLConnection.setOption(MySQLSetOption option,
Handler<AsyncResult<Void>> handler)
Send a SET_OPTION command to set options for the current connection.
|
MySQLConnection |
MySQLConnection.specifySchema(String schemaName,
Handler<AsyncResult<Void>> handler)
Send a INIT_DB command to change the default schema of the connection.
|
| Modifier and Type | Method and Description |
|---|---|
OracleConnection |
OracleConnection.closeHandler(Handler<Void> handler) |
static void |
OracleConnection.connect(Vertx vertx,
io.vertx.oracleclient.OracleConnectOptions connectOptions,
Handler<AsyncResult<OracleConnection>> handler)
Create a connection to Oracle with the given
connectOptions. |
OraclePool |
OraclePool.connectHandler(Handler<SqlConnection> handler) |
OracleConnection |
OracleConnection.exceptionHandler(Handler<Throwable> handler) |
OracleConnection |
OracleConnection.prepare(String s,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
PgConnection |
PgConnection.cancelRequest(Handler<AsyncResult<Void>> handler)
Send a request cancellation message to tell the server to cancel processing request in this connection.
|
PgConnection |
PgConnection.closeHandler(Handler<Void> handler) |
static void |
PgConnection.connect(Vertx vertx,
Handler<AsyncResult<PgConnection>> handler)
Like
PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.pgclient.PgConnection>>) with options build from the environment variables. |
static void |
PgConnection.connect(Vertx vertx,
PgConnectOptions options,
Handler<AsyncResult<PgConnection>> handler)
Connects to the database and returns the connection if that succeeds.
|
static void |
PgConnection.connect(Vertx vertx,
String connectionUri,
Handler<AsyncResult<PgConnection>> handler)
Like
PgConnection.connect(io.vertx.rxjava.core.Vertx, io.vertx.pgclient.PgConnectOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.pgclient.PgConnection>>) with options build from connectionUri. |
PgPool |
PgPool.connectHandler(Handler<SqlConnection> handler) |
PgConnection |
PgConnection.exceptionHandler(Handler<Throwable> handler) |
PgConnection |
PgConnection.noticeHandler(Handler<PgNotice> handler)
Set a handler called when the connection receives a notice from the server.
|
PgConnection |
PgConnection.notificationHandler(Handler<PgNotification> handler)
Set a handler called when the connection receives notification on a channel.
|
PgConnection |
PgConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler) |
| Modifier and Type | Method and Description |
|---|---|
void |
PgSubscriber.close(Handler<AsyncResult<Void>> handler)
Close the subscriber, the retry policy will not be invoked.
|
PgSubscriber |
PgSubscriber.closeHandler(Handler<Void> handler)
Set an handler called when the subscriber is closed.
|
PgSubscriber |
PgSubscriber.connect(Handler<AsyncResult<Void>> handler)
Connect the subscriber to Postgres.
|
PgChannel |
PgChannel.endHandler(Handler<Void> endHandler)
Set an handler to be called when no more notifications will be received.
|
PgChannel |
PgChannel.exceptionHandler(Handler<Throwable> handler) |
PgChannel |
PgChannel.handler(Handler<String> handler)
Set or unset an handler to be called when a the channel is notified by Postgres.
|
void |
PgChannel.pipeTo(WriteStream<String> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
PgChannel |
PgChannel.subscribeHandler(Handler<Void> handler)
Set an handler called when the the channel get subscribed.
|
| Modifier and Type | Method and Description |
|---|---|
void |
RabbitMQClient.addConfirmListener(int maxQueueSize,
Handler<AsyncResult<ReadStream<RabbitMQConfirmation>>> resultHandler)
Add a Confirm Listener to the channel.
|
void |
RabbitMQClient.basicAck(long deliveryTag,
boolean multiple,
Handler<AsyncResult<Void>> resultHandler)
Acknowledge one or several received messages.
|
void |
RabbitMQClient.basicConsumer(String queue,
Handler<AsyncResult<RabbitMQConsumer>> resultHandler) |
void |
RabbitMQClient.basicConsumer(String queue,
QueueOptions options,
Handler<AsyncResult<RabbitMQConsumer>> resultHandler)
Create a consumer with the given
options. |
void |
RabbitMQClient.basicGet(String queue,
boolean autoAck,
Handler<AsyncResult<RabbitMQMessage>> resultHandler)
Retrieve a message from a queue using AMQP.Basic.Get
|
void |
RabbitMQClient.basicNack(long deliveryTag,
boolean multiple,
boolean requeue,
Handler<AsyncResult<Void>> resultHandler)
Reject one or several received messages.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublish(String exchange,
String routingKey,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.basicQos(int prefetchCount,
boolean global,
Handler<AsyncResult<Void>> resultHandler)
Request a specific prefetchCount "quality of service" settings
for this channel.
|
void |
RabbitMQClient.basicQos(int prefetchCount,
Handler<AsyncResult<Void>> resultHandler)
Request a specific prefetchCount "quality of service" settings
for this channel.
|
void |
RabbitMQClient.basicQos(int prefetchSize,
int prefetchCount,
boolean global,
Handler<AsyncResult<Void>> resultHandler)
Request specific "quality of service" settings.
|
void |
RabbitMQConsumer.cancel(Handler<AsyncResult<Void>> cancelResult)
Stop message consumption from a queue.
|
void |
RabbitMQClient.confirmSelect(Handler<AsyncResult<Void>> resultHandler)
Enables publisher acknowledgements on this channel.
|
RabbitMQConsumer |
RabbitMQConsumer.endHandler(Handler<Void> endHandler)
Set an end handler.
|
RabbitMQConsumer |
RabbitMQConsumer.exceptionHandler(Handler<Throwable> exceptionHandler)
Set an exception handler on the read stream.
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeBind(String destination,
String source,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Bind an exchange to an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange.
|
void |
RabbitMQClient.exchangeDeclare(String exchange,
String type,
boolean durable,
boolean autoDelete,
JsonObject config,
Handler<AsyncResult<Void>> resultHandler)
Declare an exchange with additional parameters such as dead lettering, an alternate exchange or TTL.
|
void |
RabbitMQClient.exchangeDelete(String exchange,
Handler<AsyncResult<Void>> resultHandler)
Delete an exchange, without regard for whether it is in use or not.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
void |
RabbitMQClient.exchangeUnbind(String destination,
String source,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Unbind an exchange from an exchange.
|
RabbitMQConsumer |
RabbitMQConsumer.handler(Handler<RabbitMQMessage> messageArrived)
Set a message handler.
|
void |
RabbitMQClient.messageCount(String queue,
Handler<AsyncResult<Long>> resultHandler)
Returns the number of messages in a queue ready to be delivered.
|
void |
RabbitMQConsumer.pipeTo(WriteStream<RabbitMQMessage> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
void |
RabbitMQPublisher.publish(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<AsyncResult<Void>> resultHandler)
Publish a message.
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueBind(String queue,
String exchange,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Bind a queue to an exchange
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Declare a queue
|
void |
RabbitMQClient.queueDeclare(String queue,
boolean durable,
boolean exclusive,
boolean autoDelete,
JsonObject config,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeclareOk>> resultHandler)
Declare a queue with config options
|
void |
RabbitMQClient.queueDeclareAuto(Handler<AsyncResult<JsonObject>> resultHandler)
Actively declare a server-named exclusive, autodelete, non-durable queue.
|
void |
RabbitMQClient.queueDelete(String queue,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Delete a queue, without regard for whether it is in use or has messages on it
|
void |
RabbitMQClient.queueDeleteIf(String queue,
boolean ifUnused,
boolean ifEmpty,
Handler<AsyncResult<com.rabbitmq.client.AMQP.Queue.DeleteOk>> resultHandler)
Delete a queue
|
void |
RabbitMQClient.queueUnbind(String queue,
String exchange,
String routingKey,
Handler<AsyncResult<Void>> resultHandler)
Unbind a queue from an exchange
|
void |
RabbitMQClient.queueUnbind(String queue,
String exchange,
String routingKey,
Map<String,Object> arguments,
Handler<AsyncResult<Void>> resultHandler)
Unbind a queue from an exchange
|
void |
RabbitMQClient.restartConnect(int attempts,
Handler<AsyncResult<Void>> resultHandler)
restart the rabbitMQ connect.
|
Single<Void> |
RabbitMQClient.rxBasicPublishWithDeliveryTag(String exchange,
String routingKey,
com.rabbitmq.client.BasicProperties properties,
Buffer body,
Handler<Long> deliveryTagHandler)
Publish a message.
|
void |
RabbitMQClient.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ client.
|
void |
RabbitMQPublisher.start(Handler<AsyncResult<Void>> resultHandler)
Start the rabbitMQ publisher.
|
void |
RabbitMQClient.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ client.
|
void |
RabbitMQPublisher.stop(Handler<AsyncResult<Void>> resultHandler)
Stop the rabbitMQ publisher.
|
void |
RabbitMQClient.waitForConfirms(Handler<AsyncResult<Void>> resultHandler)
Wait until all messages published since the last call have been either ack'd or nack'd by the broker.
|
void |
RabbitMQClient.waitForConfirms(long timeout,
Handler<AsyncResult<Void>> resultHandler)
Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(JsonObject filter,
Handler<AsyncResult<Record>> resultHandler)
Lookups for a single record.
|
void |
ServiceDiscovery.getRecord(String id,
Handler<AsyncResult<Record>> resultHandler)
Looks up for a single record by its registration
id. |
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
boolean includeOutOfService,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.getRecords(JsonObject filter,
Handler<AsyncResult<List<Record>>> resultHandler)
Lookups for a set of records.
|
void |
ServiceDiscovery.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
ServiceDiscovery |
ServiceDiscovery.registerServiceExporter(ServiceExporter exporter,
JsonObject configuration,
Handler<AsyncResult<Void>> completionHandler)
Registers a discovery bridge.
|
ServiceDiscovery |
ServiceDiscovery.registerServiceImporter(ServiceImporter importer,
JsonObject configuration,
Handler<AsyncResult<Void>> completionHandler)
Registers a discovery service importer.
|
void |
ServiceDiscovery.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServiceDiscovery.update(Record record,
Handler<AsyncResult<Record>> resultHandler)
Updates the given record.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ServiceExporter.close(Handler<Void> closeHandler)
Close the exporter
|
void |
ServiceImporter.close(Handler<Void> closeHandler)
Closes the importer
|
void |
ServicePublisher.publish(Record record,
Handler<AsyncResult<Record>> resultHandler)
Publishes a record.
|
void |
ServicePublisher.unpublish(String id,
Handler<AsyncResult<Void>> resultHandler)
Un-publishes a record.
|
void |
ServicePublisher.update(Record record,
Handler<AsyncResult<Record>> resultHandler)
Updates an existing record.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject conf,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject conf,
Handler<AsyncResult<HttpClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static <T> void |
MessageSource.getConsumer(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<MessageConsumer<T>>> resultHandler)
Convenient method that looks for a message source and provides the configured .
|
static <T> void |
MessageSource.getConsumer(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<MessageConsumer<T>>> resultHandler)
Convenient method that looks for a message source and provides the configured .
|
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
JDBCDataSource.getJDBCClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<JDBCClient>> resultHandler)
Convenient method that looks for a JDBC datasource source and provides the configured
JDBCClient. |
static void |
MongoDataSource.getMongoClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<MongoClient>> resultHandler)
Convenient method that looks for a Mongo datasource source and provides the configured
MongoClient. |
static void |
MongoDataSource.getMongoClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<MongoClient>> resultHandler)
Convenient method that looks for a Mongo datasource source and provides the configured
MongoClient. |
static void |
MongoDataSource.getMongoClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<MongoClient>> resultHandler)
Convenient method that looks for a Mongo datasource source and provides the configured
MongoClient. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static void |
RedisDataSource.getRedisClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject consumerConfiguration,
Handler<AsyncResult<Redis>> resultHandler)
Convenient method that looks for a Redis data source and provides the configured
Redis. |
static <T> T |
EventBusService.getServiceProxy(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Class<T> clientClass,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> T |
EventBusService.getServiceProxy(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Class<T> clientClass,
JsonObject conf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> T |
EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery,
JsonObject filter,
Class<T> clientClass,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static <T> T |
EventBusService.getServiceProxyWithJsonFilter(ServiceDiscovery discovery,
JsonObject filter,
Class<T> clientClass,
JsonObject conf,
Handler<AsyncResult<T>> resultHandler)
Lookup for a service record and if found, retrieve it and return the service object (used to consume the service).
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
java.util.function.Function<Record,Boolean> filter,
JsonObject conf,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
JsonObject filter,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
static void |
HttpEndpoint.getWebClient(ServiceDiscovery discovery,
JsonObject filter,
JsonObject conf,
Handler<AsyncResult<WebClient>> resultHandler)
Convenient method that looks for a HTTP endpoint and provides the configured .
|
| Modifier and Type | Method and Description |
|---|---|
void |
SqlConnection.begin(Handler<AsyncResult<Transaction>> handler)
Begin a transaction and returns a
Transaction for controlling and tracking
this transaction. |
void |
PreparedStatement.close(Handler<AsyncResult<Void>> completionHandler)
Like
PreparedStatement.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but notifies the completionHandler when it's closed. |
void |
SqlConnection.close(Handler<AsyncResult<Void>> handler)
Close the current connection after all the pending commands have been processed.
|
void |
Pool.close(Handler<AsyncResult<Void>> handler)
Close the pool and release the associated resources.
|
void |
RowStream.close(Handler<AsyncResult<Void>> completionHandler)
Close the stream and release the resources.
|
void |
SqlClient.close(Handler<AsyncResult<Void>> handler)
Close the client and release the associated resources.
|
void |
Cursor.close(Handler<AsyncResult<Void>> completionHandler)
Like
Cursor.close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with a completionHandler called when the cursor has been released. |
SqlConnection |
SqlConnection.closeHandler(Handler<Void> handler)
Set an handler called when the connection is closed.
|
void |
Transaction.commit(Handler<AsyncResult<Void>> handler)
Like
Transaction.commit(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) with an handler to be notified when the transaction commit has completed |
void |
Transaction.completion(Handler<AsyncResult<Void>> handler)
Like
Transaction.completion(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but with a callback |
Pool |
Pool.connectHandler(Handler<SqlConnection> handler)
Set an handler called when the pool has established a connection to the database.
|
RowStream<T> |
RowStream.endHandler(Handler<Void> endHandler) |
SqlConnection |
SqlConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called with connection errors.
|
RowStream<T> |
RowStream.exceptionHandler(Handler<Throwable> handler) |
void |
PreparedQuery.execute(Handler<AsyncResult<T>> handler)
Execute the query.
|
void |
Query.execute(Handler<AsyncResult<T>> handler)
Execute the query.
|
void |
PreparedQuery.execute(Tuple tuple,
Handler<AsyncResult<T>> handler)
Execute the query.
|
void |
PreparedQuery.executeBatch(List<Tuple> batch,
Handler<AsyncResult<T>> handler)
Execute the query with a batch of tuples.
|
void |
Pool.getConnection(Handler<AsyncResult<SqlConnection>> handler)
Get a connection from the pool.
|
RowStream<T> |
RowStream.handler(Handler<T> handler) |
void |
RowStream.pipeTo(WriteStream<T> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream. |
SqlConnection |
SqlConnection.prepare(String sql,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
SqlConnection |
SqlConnection.prepare(String sql,
PrepareOptions options,
Handler<AsyncResult<PreparedStatement>> handler)
Create a prepared statement using the given
sql string. |
void |
Cursor.read(int count,
Handler<AsyncResult<RowSet<Row>>> handler)
Read rows from the cursor, the result is provided asynchronously to the
handler. |
void |
Transaction.rollback(Handler<AsyncResult<Void>> handler)
Like
Transaction.rollback(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) with an handler to be notified when the transaction rollback has completed |
<T> void |
Pool.withConnection(java.util.function.Function<SqlConnection,Future<T>> function,
Handler<AsyncResult<T>> handler)
Get a connection from the pool and execute the given
function. |
<T> void |
Pool.withTransaction(java.util.function.Function<SqlConnection,Future<T>> function,
Handler<AsyncResult<T>> handler)
Execute the given
function within a transaction. |
| Modifier and Type | Method and Description |
|---|---|
static <T> MaybeObserver<T> |
MaybeHelper.toObserver(Handler<AsyncResult<T>> handler)
Adapts an Vert.x
Handler<AsyncResult<T>> to an RxJava2 MaybeObserver. |
static <T> SingleObserver<T> |
SingleHelper.toObserver(Handler<AsyncResult<T>> handler)
Adapts an Vert.x
Handler<AsyncResult<T>> to an RxJava2 SingleObserver. |
static <T> CompletableObserver |
CompletableHelper.toObserver(Handler<AsyncResult<T>> handler)
Adapts an Vert.x
Handler<AsyncResult<T>> to an RxJava2 SingleObserver. |
| Modifier and Type | Method and Description |
|---|---|
static Completable |
CompletableHelper.toCompletable(java.util.function.Consumer<Handler<AsyncResult<Void>>> handler)
Returns a
Completable that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method. |
static <T> Maybe<T> |
MaybeHelper.toMaybe(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)
Returns a
Maybe that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method. |
static <T> Single<T> |
SingleHelper.toSingle(java.util.function.Consumer<Handler<AsyncResult<T>>> handler)
Returns a
Single that, when subscribed, uses the provided handler to adapt a callback-based asynchronous method. |
| Modifier and Type | Method and Description |
|---|---|
WriteStream<AmqpMessage> |
AmqpSender.drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
AmqpReceiver |
AmqpReceiver.endHandler(Handler<Void> endHandler) |
AmqpConnection |
AmqpConnection.exceptionHandler(Handler<Throwable> handler)
Registers a handler called on disconnection.
|
AmqpSender |
AmqpSender.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.exceptionHandler(Handler<Throwable> handler) |
AmqpReceiver |
AmqpReceiver.handler(Handler<AmqpMessage> handler) |
| Modifier and Type | Method and Description |
|---|---|
CassandraRowStream |
CassandraRowStream.endHandler(Handler<Void> handler) |
CassandraRowStream |
CassandraRowStream.exceptionHandler(Handler<Throwable> handler) |
CassandraRowStream |
CassandraRowStream.handler(Handler<com.datastax.oss.driver.api.core.cql.Row> handler) |
| Modifier and Type | Class and Description |
|---|---|
class |
HystrixMetricHandler
A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ConfigRetriever.listen(Handler<ConfigChange> listener)
Registers a listener receiving configuration changes.
|
ConfigRetriever |
ConfigRetriever.setBeforeScanHandler(Handler<Void> handler)
Registers a handler called before every scan.
|
| Modifier and Type | Method and Description |
|---|---|
TimeoutStream |
TimeoutStream.endHandler(Handler<Void> endHandler) |
Context |
Context.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called when the context runs an action throwing an uncaught throwable.
When this handler is called,
Vertx.currentContext() will return this context. |
TimeoutStream |
TimeoutStream.exceptionHandler(Handler<Throwable> handler) |
Vertx |
Vertx.exceptionHandler(Handler<Throwable> handler)
Set a default exception handler for
Context, set on Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>) at creation. |
<T> Maybe<T> |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
Invoke
Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, boolean) with order = true. |
<T> Maybe<T> |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
Like
Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, boolean) called with ordered = true. |
<T> Maybe<T> |
WorkerExecutor.executeBlocking(Handler<Promise<T>> blockingCodeHandler)
Like
WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, boolean) called with ordered = true. |
<T> Maybe<T> |
Context.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Maybe<T> |
Vertx.executeBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Maybe<T> |
WorkerExecutor.executeBlocking(Handler<Promise<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.
|
<T> Maybe<T> |
Context.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
Invoke
Context.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, boolean) with order = true. |
<T> Maybe<T> |
Vertx.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
Like
Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, boolean) called with ordered = true. |
<T> Maybe<T> |
WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)
Like
WorkerExecutor.executeBlocking(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, boolean) called with ordered = true. |
<T> Maybe<T> |
Context.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Maybe<T> |
Vertx.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
<T> Maybe<T> |
WorkerExecutor.rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
boolean ordered)
Safely execute some blocking code.
|
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.setPeriodic(long initialDelay,
long delay,
Handler<Long> handler)
Set a periodic timer to fire every
delay milliseconds with initial delay, 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. |
| Modifier and Type | Method and Description |
|---|---|
DatagramSocket |
DatagramSocket.endHandler(Handler<Void> endHandler) |
DatagramSocket |
DatagramSocket.exceptionHandler(Handler<Throwable> handler) |
DatagramSocket |
DatagramSocket.handler(Handler<DatagramPacket> handler) |
| Modifier and Type | Method and Description |
|---|---|
<T> EventBus |
EventBus.addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is received by Vert.x
|
<T> EventBus |
EventBus.addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Add an interceptor that will be called whenever a message is sent from Vert.x
|
<T> MessageConsumer<T> |
EventBus.consumer(String address,
Handler<Message<T>> handler)
Create a consumer and register it against the specified address.
|
MessageConsumer<T> |
MessageConsumer.endHandler(Handler<Void> endHandler) |
MessageConsumer<T> |
MessageConsumer.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. |
<T> EventBus |
EventBus.removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addInboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava3.core.eventbus.DeliveryContext<T>>) |
<T> EventBus |
EventBus.removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
Remove an interceptor that was added by
EventBus.addOutboundInterceptor(io.vertx.core.Handler<io.vertx.rxjava3.core.eventbus.DeliveryContext<T>>) |
| Modifier and Type | Method and Description |
|---|---|
AsyncFile |
AsyncFile.drainHandler(Handler<Void> handler) |
AsyncFile |
AsyncFile.endHandler(Handler<Void> endHandler) |
AsyncFile |
AsyncFile.exceptionHandler(Handler<Throwable> handler) |
AsyncFile |
AsyncFile.handler(Handler<Buffer> handler) |
| Modifier and Type | Method and Description |
|---|---|
WebSocketBase |
ServerWebSocket.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
WebSocketBase |
WebSocket.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
WebSocketBase |
WebSocketBase.binaryMessageHandler(Handler<Buffer> handler)
Set a binary message handler on the connection.
|
HttpServerRequest |
HttpServerRequest.body(Handler<AsyncResult<Buffer>> handler)
Same as
HttpServerRequest.body(io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava3.core.buffer.Buffer>>) but with an handler called when the operation completes |
HttpServerResponse |
HttpServerResponse.bodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
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.
|
HttpServerResponse |
HttpServerResponse.closeHandler(Handler<Void> handler)
Set a close handler for the response, this is called when the underlying connection is closed and the response
was still using the connection.
|
ServerWebSocket |
ServerWebSocket.closeHandler(Handler<Void> handler) |
WebSocket |
WebSocket.closeHandler(Handler<Void> handler) |
HttpConnection |
HttpConnection.closeHandler(Handler<Void> handler)
Set a close handler.
|
WebSocketBase |
WebSocketBase.closeHandler(Handler<Void> handler)
Set a close handler.
|
HttpServer |
HttpServer.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the server.
|
HttpClient |
HttpClient.connectionHandler(Handler<HttpConnection> handler)
Set a connection handler for the client.
|
HttpClientRequest |
HttpClientRequest.continueHandler(Handler<Void> handler)
If you send an HTTP request with the header
Expect set to the value 100-continue
and the server responds with an interim HTTP response with a status code of 100 and a continue handler
has been set using this method, then the handler will be called. |
HttpClientResponse |
HttpClientResponse.customFrameHandler(Handler<HttpFrame> handler)
Set an custom frame handler.
|
HttpServerRequest |
HttpServerRequest.customFrameHandler(Handler<HttpFrame> handler)
Set a custom frame handler.
|
HttpServerResponse |
HttpServerResponse.drainHandler(Handler<Void> handler) |
ServerWebSocket |
ServerWebSocket.drainHandler(Handler<Void> handler) |
HttpClientRequest |
HttpClientRequest.drainHandler(Handler<Void> handler) |
WebSocket |
WebSocket.drainHandler(Handler<Void> handler) |
WebSocketBase |
WebSocketBase.drainHandler(Handler<Void> handler) |
HttpClientResponse |
HttpClientResponse.endHandler(Handler<Void> endHandler) |
HttpServerResponse |
HttpServerResponse.endHandler(Handler<Void> handler)
Set an end handler for the response.
|
ServerWebSocket |
ServerWebSocket.endHandler(Handler<Void> endHandler) |
WebSocket |
WebSocket.endHandler(Handler<Void> endHandler) |
HttpServerFileUpload |
HttpServerFileUpload.endHandler(Handler<Void> endHandler) |
HttpServerRequest |
HttpServerRequest.endHandler(Handler<Void> endHandler) |
WebSocketBase |
WebSocketBase.endHandler(Handler<Void> endHandler) |
HttpClientResponse |
HttpClientResponse.exceptionHandler(Handler<Throwable> handler) |
HttpServerResponse |
HttpServerResponse.exceptionHandler(Handler<Throwable> handler) |
ServerWebSocket |
ServerWebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpServer |
HttpServer.exceptionHandler(Handler<Throwable> handler)
Set an exception handler called for socket errors happening before the HTTP connection
is established, e.g during the TLS handshake.
|
HttpClientRequest |
HttpClientRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocket |
WebSocket.exceptionHandler(Handler<Throwable> handler) |
HttpConnection |
HttpConnection.exceptionHandler(Handler<Throwable> handler)
Set an handler called when a connection error happens
|
HttpServerFileUpload |
HttpServerFileUpload.exceptionHandler(Handler<Throwable> handler) |
HttpServerRequest |
HttpServerRequest.exceptionHandler(Handler<Throwable> handler) |
WebSocketBase |
WebSocketBase.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.
|
HttpConnection |
HttpConnection.goAwayHandler(Handler<GoAway> handler)
Set an handler called when a frame is received.
|
HttpClientResponse |
HttpClientResponse.handler(Handler<Buffer> handler) |
ServerWebSocket |
ServerWebSocket.handler(Handler<Buffer> handler) |
WebSocket |
WebSocket.handler(Handler<Buffer> handler) |
HttpServerFileUpload |
HttpServerFileUpload.handler(Handler<Buffer> handler) |
HttpServerRequest |
HttpServerRequest.handler(Handler<Buffer> handler) |
WebSocketBase |
WebSocketBase.handler(Handler<Buffer> handler) |
HttpServerResponse |
HttpServerResponse.headersEndHandler(Handler<Void> handler)
Provide a handler that will be called just before the headers are written to the wire.
|
HttpServer |
HttpServer.invalidRequestHandler(Handler<HttpServerRequest> handler)
Set a
handler for handling invalid requests. |
HttpConnection |
HttpConnection.pingHandler(Handler<Buffer> handler)
Set an handler notified when a frame is received from the remote endpoint.
|
WebSocketBase |
ServerWebSocket.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
WebSocketBase |
WebSocket.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
WebSocketBase |
WebSocketBase.pongHandler(Handler<Buffer> handler)
Set a pong frame handler on the connection.
|
HttpClientRequest |
HttpClientRequest.pushHandler(Handler<HttpClientRequest> handler)
Set a push handler for this request.
The handler is called when the client receives a push promise from the server.
|
HttpConnection |
HttpConnection.remoteSettingsHandler(Handler<Http2Settings> handler)
Set an handler that is called when remote endpoint
Http2Settings are updated. |
HttpServer |
HttpServer.requestHandler(Handler<HttpServerRequest> handler)
Set the request handler for the server to
requestHandler. |
HttpConnection |
HttpConnection.shutdownHandler(Handler<Void> handler)
Set an handler called when a frame has been sent or received and all connections are closed.
|
HttpClientResponse |
HttpClientResponse.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes.
|
HttpServerRequest |
HttpServerRequest.streamPriorityHandler(Handler<StreamPriority> handler)
Set an handler for stream priority changes
|
WebSocketBase |
ServerWebSocket.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
WebSocketBase |
WebSocket.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
WebSocketBase |
WebSocketBase.textMessageHandler(Handler<String> handler)
Set a text message handler on the connection.
|
HttpServerRequest |
HttpServerRequest.uploadHandler(Handler<HttpServerFileUpload> uploadHandler)
Set an upload handler.
|
HttpServer |
HttpServer.webSocketHandler(Handler<ServerWebSocket> handler)
Set the WebSocket handler for the server to
wsHandler. |
| Modifier and Type | Method and Description |
|---|---|
NetSocket |
NetSocket.closeHandler(Handler<Void> handler)
Set a handler that will be called when the NetSocket is closed
|
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)
This handler might be called after the close handler when the socket is paused and there are still
buffers to deliver.
|
NetSocket |
NetSocket.exceptionHandler(Handler<Throwable> handler) |
NetSocket |
NetSocket.handler(Handler<Buffer> handler) |
| Modifier and Type | Class and Description |
|---|---|
class |
JsonParser
A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json
element fully.
|
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 |
|---|---|
RecordParser |
RecordParser.endHandler(Handler<Void> endHandler) |
JsonParser |
JsonParser.endHandler(Handler<Void> endHandler) |
RecordParser |
RecordParser.exceptionHandler(Handler<Throwable> handler) |
JsonParser |
JsonParser.exceptionHandler(Handler<Throwable> handler) |
RecordParser |
RecordParser.handler(Handler<Buffer> handler) |
JsonParser |
JsonParser.handler(Handler<JsonEvent> handler) |
static RecordParser |
RecordParser.newDelimited(Buffer delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava3.core.buffer.Buffer>) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newDelimited(String delim,
Handler<Buffer> output)
Like
RecordParser.newDelimited(java.lang.String, io.vertx.core.Handler<io.vertx.rxjava3.core.buffer.Buffer>) but set the output that will receive whole records
which have been parsed. |
static RecordParser |
RecordParser.newFixed(int size,
Handler<Buffer> output)
Like
RecordParser.newFixed(int) but set the output that will receive whole records
which have been parsed. |
void |
RecordParser.setOutput(Handler<Buffer> output) |
| 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 |
|---|---|
DB2Connection |
DB2Connection.closeHandler(Handler<Void> handler) |
DB2Pool |
DB2Pool.connectHandler(Handler<SqlConnection> handler) |
DB2Connection |
DB2Connection.exceptionHandler(Handler<Throwable> handler) |
| Modifier and Type | Method and Description |
|---|---|
OAuth2Auth |
OAuth2Auth.missingKeyHandler(Handler<String> handler)
Handled to be called when a key (mentioned on a JWT) is missing from the current config.
|
| Modifier and Type | Method and Description |
|---|---|
Watch<T> |
Watch.setHandler(Handler<WatchResult<T>> handler)
Set the result handler.
|
| Modifier and Type | Method and Description |
|---|---|
static TcpEventBusBridge |
TcpEventBusBridge.create(Vertx vertx,
BridgeOptions options,
NetServerOptions netServerOptions,
Handler<BridgeEvent> eventHandler) |
| Modifier and Type | Class and Description |
|---|---|
class |
HealthCheckHandler
A Vert.x Web handler on which you register health check procedure.
|
| Modifier and Type | Method and Description |
|---|---|
HealthChecks |
HealthChecks.invoke(Handler<JsonObject> resultHandler)
Invokes the registered procedures and computes the outcome.
|
HealthChecks |
HealthChecks.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthChecks |
HealthChecks.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
HealthCheckHandler |
HealthCheckHandler.register(String name,
long timeout,
Handler<Promise<Status>> procedure)
Registers a health check procedure.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ShellServer.shellHandler(Handler<Shell> shellHandler)
Called when a new shell is created.
|
| 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.
|
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. |
| 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.
|
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
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen. |
| Modifier and Type | Method and Description |
|---|---|
Term |
Term.closeHandler(Handler<Void> handler)
Set a handler that will be called when the terminal is closed.
|
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.
|
Tty |
Tty.resizehandler(Handler<Void> handler)
Set a resize handler, the handler is called when the tty size changes.
|
Term |
Term.resizehandler(Handler<Void> handler) |
Tty |
Tty.stdinHandler(Handler<String> handler)
Set a stream handler on the standard input to read the data.
|
Term |
Term.stdinHandler(Handler<String> handler) |
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 | Class and Description |
|---|---|
class |
StompServerHandler
STOMP server handler implements the behavior of the STOMP server when a specific event occurs.
|
| Modifier and Type | Method and Description |
|---|---|
Handler<ServerWebSocket> |
StompServer.webSocketHandler()
Gets the able to manage web socket connections.
|
| Modifier and Type | Method and Description |
|---|---|
StompServerHandler |
StompServerHandler.abortHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
ABORT frame is received. |
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.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.
|
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.
|
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. |
StompServerHandler |
StompServerHandler.disconnectHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
DISCONNECT frame is received. |
StompClient |
StompClient.errorFrameHandler(Handler<Frame> handler)
A general error frame handler.
|
StompClientConnection |
StompClientConnection.errorHandler(Handler<Frame> handler)
Sets a handler notified when an
ERROR frame is received by the client. |
StompClientConnection |
StompClientConnection.exceptionHandler(Handler<Throwable> exceptionHandler)
Configures the exception handler notified upon TCP-level errors.
|
StompClient |
StompClient.exceptionHandler(Handler<Throwable> handler)
Sets an exception handler notified for TCP-level errors.
|
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.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.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that get notified when a STOMP frame is received by the client.
|
StompClient |
StompClient.receivedFrameHandler(Handler<Frame> handler)
Configures a received handler that gets notified when a STOMP frame is received by the client.
|
StompServerHandler |
StompServerHandler.receivedFrameHandler(Handler<ServerFrame> handler)
Configures a handler that get notified when a STOMP frame is received by the server.
|
Single<String> |
StompClientConnection.rxSubscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
Single<String> |
StompClientConnection.rxSubscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes 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. |
Single<String> |
StompClientConnection.subscribe(String destination,
Handler<Frame> handler)
Subscribes to the given destination.
|
Single<String> |
StompClientConnection.subscribe(String destination,
Map<String,String> headers,
Handler<Frame> handler)
Subscribes to the given destination.
|
StompServerHandler |
StompServerHandler.subscribeHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
SUBSCRIBE frame is received. |
StompServerHandler |
StompServerHandler.unsubscribeHandler(Handler<ServerFrame> handler)
Configures the action to execute when a
UNSUBSCRIBE frame is received. |
StompClientConnection |
StompClientConnection.writingFrameHandler(Handler<Frame> handler)
Configures a handler notified when a frame is going to be written on the wire.
|
StompClient |
StompClient.writingFrameHandler(Handler<Frame> handler)
Configures a writing handler that gets notified when a STOMP frame is written on the wire.
|
StompServer |
StompServer.writingFrameHandler(Handler<ServerFrame> handler)
Configures the handler that is invoked every time a frame is going to be written to the "wire".
|
| Modifier and Type | Method and Description |
|---|---|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess()
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it completes the async operation.
When the returned handler is called back with a failed result it fails the test with the cause of the failure.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
Handler<Throwable> |
TestContext.exceptionHandler() |
| Modifier and Type | Method and Description |
|---|---|
TestSuite |
TestSuite.after(Handler<TestContext> callback)
Set a callback executed after the tests.
|
TestSuite |
TestSuite.afterEach(Handler<TestContext> callback)
Set a callback executed after each test and before the suite
after callback. |
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertFailure(Handler<Throwable> causeHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a failed result it completes the async operation.
When the returned handler is called back with a succeeded result it fails the test.
|
<T> Handler<AsyncResult<T>> |
TestContext.asyncAssertSuccess(Handler<T> resultHandler)
Creates and returns a new async handler, the returned handler controls the completion of the test.
When the returned handler is called back with a succeeded result it invokes the
resultHandler argument
with the async result. |
TestSuite |
TestSuite.before(Handler<TestContext> callback)
Set a callback executed before the tests.
|
TestSuite |
TestSuite.beforeEach(Handler<TestContext> callback)
Set a callback executed before each test and after the suite
before callback. |
static TestCase |
TestCase.create(String name,
Handler<TestContext> testCase)
Create a test case.
|
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.
|
TestContext |
TestContext.verify(Handler<Void> block)
Execute the provided handler, which may contain assertions, possibly from any third-party assertion framework.
|
| 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 | Class and Description |
|---|---|
class |
Router
A router receives request from an
HttpServer and routes it to the first matching
Route that it contains. |
| Modifier and Type | Method and Description |
|---|---|
int |
RoutingContext.addBodyEndHandler(Handler<Void> handler)
Provides a handler that will be called after the last part of the body is written to the wire.
|
int |
RoutingContext.addEndHandler(Handler<AsyncResult<Void>> handler)
Add an end handler for the request/response context.
|
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.rxjava3.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.errorHandler(int statusCode,
Handler<RoutingContext> errorHandler)
Specify an handler to handle an error for a particular status code.
|
Route |
Route.failureHandler(Handler<RoutingContext> failureHandler)
Append a failure handler to the route failure handlers list.
|
Route |
Route.handler(Handler<RoutingContext> requestHandler)
Append a request handler to the route handlers list.
|
Router |
Router.modifiedHandler(Handler<Router> handler)
When a Router routes are changed this handler is notified.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
HTTPOperationRequestValidationHandler
Base interface for HTTP request validation with API specification
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen. |
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
RouterFactory.getValidationFailureHandler()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
RouterFactory |
RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
|
RouterFactory |
RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
|
RouterFactory |
RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
|
| Modifier and Type | Class and Description |
|---|---|
class |
OpenAPI3RequestValidationHandler
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen. |
| Modifier and Type | Method and Description |
|---|---|
Handler<RoutingContext> |
OpenAPI3RouterFactory.getValidationFailureHandler()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addFailureHandlerByOperationId(String operationId,
Handler<RoutingContext> failureHandler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.addGlobalHandler(Handler<RoutingContext> globalHandler)
Deprecated.
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addHandlerByOperationId(String operationId,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.addSecurityHandler(String securitySchemaName,
Handler<RoutingContext> handler)
Deprecated.
|
OpenAPI3RouterFactory |
OpenAPI3RouterFactory.addSecuritySchemaScopeValidator(String securitySchemaName,
String scopeName,
Handler<RoutingContext> handler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.setNotImplementedFailureHandler(Handler<RoutingContext> notImplementedFailureHandler)
Deprecated.
|
RouterFactory |
OpenAPI3RouterFactory.setValidationFailureHandler(Handler<RoutingContext> validationFailureHandler)
Deprecated.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ValidationHandler
Base interface for validation.
|
| Modifier and Type | Class and Description |
|---|---|
class |
HTTPRequestValidationHandler
An interface for add HTTP Request validation.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
AuthenticationHandler
Base interface for auth handlers.
|
interface |
InputTrustHandler
Base input trust interface for handlers that verify the trust of the request.
|
interface |
PlatformHandler
Base platform interface for handlers that provide functionality to the application platform.
|
interface |
ProtocolUpgradeHandler
Base interface for handlers that perform protocol upgrades.
|
interface |
SecurityPolicyHandler
Base security policy interface for handlers that provide HTTP security related headers.
|
| Modifier and Type | Class and Description |
|---|---|
class |
APIKeyHandler
An authentication handler that provides API Key support.
|
class |
AuthorizationHandler
Base interface for authorization handlers that provide authorization support.
|
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 |
ChainAuthHandler
An auth handler that chains to a sequence of handlers.
|
class |
CorsHandler
A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
|
class |
CSPHandler
Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of
attacks, including Cross Site Scripting (XSS) and data injection attacks.
|
class |
CSRFHandler
This handler adds a CSRF token to requests which mutate state.
|
class |
DigestAuthHandler
An auth handler that provides HTTP Basic Authentication support.
|
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 |
HSTSHandler
HTTP Strict Transport Security (HSTS) RFC6797.
|
class |
JWTAuthHandler
An auth handler that provides JWT Authentication support.
|
class |
LoggerHandler
A handler which logs request information to the Vert.x logger.
|
class |
MethodOverrideHandler
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen. |
class |
MultiTenantHandler
A handler which selectively executes another handler if a precondition is met.
|
class |
OAuth2AuthHandler
An auth handler that provides OAuth2 Authentication support.
|
class |
OtpAuthHandler
An auth handler that provides One Time Password (Multi-Factor) Authentication support.
|
class |
RedirectAuthHandler
An auth handler that's used to handle auth by redirecting user to a custom login page.
|
class |
ResponseContentTypeHandler
A handler which sets the response content type automatically according to the best
Accept header match. |
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 |
SimpleAuthenticationHandler
A user customizable authentication handler.
|
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 |
WebAuthnHandler
An auth handler that provides FIDO2 WebAuthN Relay Party support.
|
class |
XFrameHandler
The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render
a page in a |