Eclipse Vert.x

https://vertx.io/docs
Admin
Eclipse Vert.x is a polyglot, event-driven application framework for the JVM, designed for building...
Tokens:2,561,021
Snippets:30,932
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Create and start a terminal server

Source: https://vertx.io/docs/vertx-shell/java

Examples for initializing and listening on different terminal server protocols.

```java
TermServer server = TermServer
  .createSSHTermServer(vertx,
    new SSHTermOptions().setPort(5000).setHost("localhost"));

server.termHandler(term -> term.stdinHandler(term::write));
server.listen();
```

```java
TermServer server = TermServer
  .createTelnetTermServer(vertx,
    new TelnetTermOptions().setPort(5000).setHost("localhost"));

server.termHandler(term -> term.stdinHandler(term::write));
server.listen();
```

```java
TermServer server = TermServer
  .createHttpTermServer(vertx,
    new HttpTermOptions().setPort(5000).setHost("localhost"));

server.termHandler(term -> term.stdinHandler(term::write));
server.listen();
```

```java
TermServer server = TermServer
  .createHttpTermServer(vertx,
    router,
    new HttpTermOptions().setPort(5000).setHost("localhost"));

server.termHandler(term -> term.stdinHandler(term::write));
server.listen();
```

--------------------------------

### Initialize a user object

Source: https://vertx.io/docs/vertx-sql-client-templates/java

Example setup for a user object used in parameter mapping.

```java
User user = new User();
user.id = 1;
user.firstName = "Dale";
user.firstName = "Cooper";
```

--------------------------------

### start

Source: https://vertx.io/docs/apidocs/io/vertx/rabbitmq/RabbitMQClient.html

Starts the RabbitMQ client service.

```APIDOC
## start

### Description
Start the rabbitMQ client.

### Method
`Future<Void>`
```

--------------------------------

### Example Property File Configuration

Source: https://vertx.io/docs/vertx-auth-properties/java

A complete example showing user definitions and role-based permission assignments.

```text
user.tim = mypassword,administrator,developer
user.bob = hispassword,developer
user.joe = anotherpassword,manager
role.administrator=*
role.manager=play_golf,say_buzzwords
role.developer=do_actual_work
```

--------------------------------

### Start listening on a QUIC server

Source: https://vertx.io/docs/vertx-core/java

Starts the server using configured options or by explicitly providing host and port.

```java
QuicServer server = vertx.createQuicServer(sslOptions);
server.listen();
```

```java
QuicServer server = vertx.createQuicServer(sslOptions);
server.listen(1234, "localhost");
```

--------------------------------

### start()

Source: https://vertx.io/docs/apidocs/io/vertx/ext/shell/ShellService.html

Starts the shell service asynchronously.

```APIDOC
## start()

### Description
Start the shell service. This is an asynchronous operation.

### Method
instance

### Returns
(Future<Void>) - A Future that completes when the service has been started.
```

--------------------------------

### start

Source: https://vertx.io/docs/apidocs/io/vertx/rabbitmq/RabbitMQPublisher.html

Starts the RabbitMQ publisher. It is expected that the underlying RabbitMQClient has already been started.

```APIDOC
## start

### Description
Start the rabbitMQ publisher. The RabbitMQClient should have been started before this.

### Method
Future<Void>

### Returns
- Future<Void> - A Future that completes when the publisher has been successfully started.
```

--------------------------------

### Run Vert.x in clustered mode via CLI

Source: https://vertx.io/docs/vertx-ignite/java

Command line example to start a Vert.x application in clustered mode with a specific host address.

```bash
vertx run myverticle.js -cluster -cluster-host your-ip-address
```

--------------------------------

### rxStart

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/rabbitmq/RabbitMQClient.html

Start the RabbitMQ client.

```APIDOC
## rxStart

### Description
Start the RabbitMQ client.

### Method
APIDOC

### Endpoint
APIDOC
```

--------------------------------

### Configure and start a ShellServer

Source: https://vertx.io/docs/vertx-shell/java

Sets up a ShellServer with HTTP and SSH terminal servers, registers base commands, and starts the server.

```java
ShellServer server = ShellServer.create(vertx); __**(1)**

Router shellRouter = Router.router(vertx); __**(2)**
router.route("/shell/*").subRouter(shellRouter);
TermServer httpTermServer = TermServer.createHttpTermServer(vertx, router);

TermServer sshTermServer = TermServer.createSSHTermServer(vertx); __**(3)**

server.registerTermServer(httpTermServer); __**(4)**
server.registerTermServer(sshTermServer);

server.registerCommandResolver(CommandResolver.baseCommands(vertx)); __**(5)**

server.listen(); __**(6)**
```

--------------------------------

### Start Server Listening

Source: https://vertx.io/docs/vertx-core/java

Methods to start the server using configured options or explicit host and port parameters.

```java
NetServer server = vertx.createNetServer();
server.listen();
```

```java
NetServer server = vertx.createNetServer();
server.listen(1234, "localhost");
```

--------------------------------

### start

Source: https://vertx.io/docs/apidocs/io/vertx/servicediscovery/consul/ConsulServiceImporter.html

Starts the ConsulServiceImporter, registering it with the ServicePublisher.

```APIDOC
## start

### Description
Starts the importer. This method is called by the Vert.x framework to initialize the importer and begin publishing services.

### Method
`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`

### Parameters
* `vertx` (Vertx) - The Vert.x instance.
* `publisher` (ServicePublisher) - The service publisher instance.
* `configuration` (JsonObject) - The bridge configuration, if any.
* `completion` (Promise<Void>) - A future on which the bridge must report the completion of the starting process.
```

--------------------------------

### Full start method implementation

Source: https://vertx.io/docs/howtos/resilience4j-howto

The complete start method combining circuit breaker configuration, routing, and server startup.

```java
@Override
public Future<?> start() {
  CircuitBreaker cb = CircuitBreaker.of("my-circuit-breaker", CircuitBreakerConfig.custom()
    .minimumNumberOfCalls(5)
    .build());

  Router router = Router.router(vertx);
  WebClient client = WebClient.create(vertx);

  router.get("/").handler(ctx -> {
    VertxCircuitBreaker.executeFuture(cb, () -> {
      return client.get(8080, "localhost", "/does-not-exist")
        .as(BodyCodec.string())
        .send()
        .expecting(HttpResponseExpectation.SC_SUCCESS);
    })
      .onSuccess(response -> ctx.end("Got: " + response.body() + "\n"))
      .onFailure(error -> ctx.end("Failed with: " + error.toString() + "\n"));
  });

  return vertx.createHttpServer()
    .requestHandler(router)
    .listen(8080)
    .onSuccess(server -> {
      System.out.println("HTTP server started on port " + server.actualPort());
    });
}
```

--------------------------------

### start (with Promise)

Source: https://vertx.io/docs/apidocs/io/vertx/core/AbstractVerticle.html

Start the verticle. This is called by Vert.x when the verticle instance is deployed. Don't call it yourself.

```APIDOC
## start

### Description
Start the verticle. This is called by Vert.x when the verticle instance is deployed. Don't call it yourself. If your verticle does things in its startup which take some time then you can override this method and call the startFuture some time later when start up is complete.

### Method
public void start(Promise<Void> startPromise)

### Parameters
#### Path Parameters
- **startPromise** (Promise<Void>) - a promise which should be called when verticle start-up is complete.

### Throws
- Exception
```

--------------------------------

### Start StompServer

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/ext/stomp/class-use/StompServer.html

Methods for starting the StompServer and making it listen for connections.

```APIDOC
## StompServer.listen

### Description
Connects the STOMP server to the default port (61613) and network interface (`0.0.0.0`).

### Method
`Future<StompServer>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

## StompServer.listen

### Description
Connects the STOMP server to the given port.

### Method
`Future<StompServer>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

## StompServer.listen

### Description
Connects the STOMP server to the given port and interface.

### Method
`Future<StompServer>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

## StompServer.rxListen

### Description
Connects the STOMP server to the default port (61613) and network interface (`0.0.0.0`) using RxJava.

### Method
`Single<StompServer>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

## StompServer.rxListen

### Description
Connects the STOMP server to the given port using RxJava.

### Method
`Single<StompServer>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

## StompServer.rxListen

### Description
Connects the STOMP server to the given port and interface using RxJava.

### Method
`Single<StompServer>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None
```

--------------------------------

### start

Source: https://vertx.io/docs/apidocs/io/vertx/servicediscovery/docker/DockerLinksServiceImporter.html

Starts the importer. This method is called to begin the service discovery process.

```APIDOC
## start

### Description
Starts the importer. This method is called to begin the service discovery process, analyzing environment variables for Docker links.

### Method
`start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
- `completion` (Promise<Void>) - A future on which the bridge must report the completion of the starting.

#### Response Example
None
```

--------------------------------

### Application startup logs

Source: https://vertx.io/docs/howtos/hibernate-reactive-howto

Example output showing the initialization of the PostgreSQL container and Hibernate Reactive startup sequence.

```text
[INFO] --- exec-maven-plugin:3.0.0:java (default-cli) @ hibernate-reactive-howto ---
2021-05-18 13:54:35,570 INFO [io.vertx.howtos.hr.MainVerticle.main()] io.vertx.howtos.hr.MainVerticle - 🚀 Starting a PostgreSQL container
2021-05-18 13:54:39,430 DEBUG [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Starting container: postgres:11-alpine
2021-05-18 13:54:39,431 DEBUG [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Trying to start container: postgres:11-alpine (attempt 1/1)
2021-05-18 13:54:39,432 DEBUG [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Starting container: postgres:11-alpine
2021-05-18 13:54:39,432 INFO [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Creating container for image: postgres:11-alpine
2021-05-18 13:54:40,016 INFO [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Starting container with ID: f538f59149d72ebec87382b09624240ca2faddcbc9c247a53575a537d1d7f045
2021-05-18 13:54:42,050 INFO [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Container postgres:11-alpine is starting: f538f59149d72ebec87382b09624240ca2faddcbc9c247a53575a537d1d7f045
2021-05-18 13:54:43,918 INFO [io.vertx.howtos.hr.MainVerticle.main()] 🐳 [postgres:11-alpine] - Container postgres:11-alpine started in PT4.510869S
2021-05-18 13:54:43,918 INFO [io.vertx.howtos.hr.MainVerticle.main()] io.vertx.howtos.hr.MainVerticle - 🚀 Starting Vert.x
2021-05-18 13:54:44,342 INFO [vert.x-worker-thread-0] org.hibernate.jpa.internal.util.LogHelper - HHH000204: Processing PersistenceUnitInfo [name: pg-demo]
2021-05-18 13:54:44,408 INFO [vert.x-worker-thread-0] org.hibernate.Version - HHH000412: Hibernate ORM core version 5.4.31.Final
2021-05-18 13:54:44,581 INFO [vert.x-eventloop-thread-0] io.vertx.howtos.hr.MainVerticle - ✅ HTTP server listening on port 8080
2021-05-18 13:54:44,586 INFO [vert.x-worker-thread-0] org.hibernate.annotations.common.Version - HCANN000001: Hibernate Commons Annotations {5.1.2.Final}
2021-05-18 13:54:44,775 INFO [vert.x-worker-thread-0] org.hibernate.dialect.Dialect - HHH000400: Using dialect: org.hibernate.dialect.PostgreSQL10Dialect
2021-05-18 13:54:45,006 INFO [vert.x-worker-thread-0] o.h.reactive.provider.impl.ReactiveIntegrator - HRX000001: Hibernate Reactive Preview
2021-05-18 13:54:45,338 INFO [vert.x-worker-thread-0] o.h.reactive.pool.impl.DefaultSqlClientPool - HRX000011: SQL Client URL [jdbc:postgresql://localhost:55019/postgres]
2021-05-18 13:54:45,342 WARN [vert.x-worker-thread-0] io.vertx.core.impl.VertxImpl - You're already on a Vert.x context, are you sure you want to create a new Vertx instance?
2021-05-18 13:54:45,345 INFO [vert.x-worker-thread-0] o.h.reactive.pool.impl.DefaultSqlClientPool - HRX000012: Connection pool size: 10
[Hibernate]
    drop table if exists Product cascade
2021-05-18 13:54:45,521 WARN [vert.x-eventloop-thread-0] io.vertx.sqlclient.impl.SocketConnectionBase - Backend notice: severity='NOTICE', code='00000', message='table "product" does not exist, skipping', detail='null', hint='null', position='null', internalPosition='null', internalQuery='null', where='null', file='tablecmds.c', line='1060', routine='DropErrorMsgNonExistent', schema='null', table='null', column='null', dataType='null', constraint='null'
[Hibernate]
    drop sequence if exists hibernate_sequence
2021-05-18 13:54:45,527 WARN [vert.x-eventloop-thread-0] io.vertx.sqlclient.impl.SocketConnectionBase - Backend notice: severity='NOTICE', code='00000', message='sequence "hibernate_sequence" does not exist, skipping', detail='null', hint='null', position='null', internalPosition='null', internalQuery='null', where='null', file='tablecmds.c', line='1060', routine='DropErrorMsgNonExistent', schema='null', table='null', column='null', dataType='null', constraint='null'
[Hibernate]
    drop table if exists Product cascade
2021-05-18 13:54:45,537 WARN [vert.x-eventloop-thread-0] io.vertx.sqlclient.impl.SocketConnectionBase - Backend notice: severity='NOTICE', code='00000', message='table "product" does not exist, skipping', detail='null', hint='null', position='null', internalPosition='null', internalQuery='null', where='null', file='tablecmds.c', line='1060', routine='DropErrorMsgNonExistent', schema='null', table='null', column='null', dataType='null', constraint='null'
[Hibernate]
    drop sequence if exists hibernate_sequence
```

--------------------------------

### Start HTTP Server and Join Operations

Source: https://vertx.io/docs/howtos/hibernate-reactive-howto

Starts the HTTP server and combines the server startup with the Hibernate initialization.

```java
Uni<HttpServer> startHttpServer = vertx.createHttpServer()
  .requestHandler(router)
  .listen(8080)
  .onItem().invoke(() -> logger.info("✅ HTTP server listening on port 8080"));

return Uni.combine().all().unis(startHibernate, startHttpServer).discardItems();  __**(1)**
```

--------------------------------

### Example output of kubectl get ksvc

Source: https://vertx.io/docs/howtos/knative-serving-howto

Shows the expected output when listing Knative services.

```text
NAME                        URL                                                               LATESTCREATED                     LATESTREADY                       READY   REASON
knative-vertx-asciidoctor   http://knative-vertx-asciidoctor.default.10.101.169.49.sslip.io   knative-vertx-asciidoctor-00001   knative-vertx-asciidoctor-00001   True
```

--------------------------------

### Implement an HTTP Server Verticle

Source: https://vertx.io/docs/vertx-core/java

An example of a verticle that initializes an HTTP server within the start method.

```java
class MyVerticle extends VerticleBase {

  private HttpServer server;

  @Override
  public Future<?> start() {
    server = vertx.createHttpServer().requestHandler(req -> {
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hello from Vert.x!");
    });
```

--------------------------------

### Start Frontend Verticle and HTTP Server

Source: https://vertx.io/docs/howtos/clustering-kubernetes-howto

Initializes the router and starts the HTTP server on the configured port.

```java
  @Override
  public Future<?> start() {
    Router router = Router.router(vertx);

    setupRouter(router);

    return vertx.createHttpServer()
      .requestHandler(router)
      .listen(HTTP_PORT)
      .onSuccess(server -> log.info("Server started and listening on port {}", server.actualPort()));
  }
```

--------------------------------

### Create GraphiQLHandler with default options

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/ext/web/handler/graphql/GraphiQLHandler.html

Creates a new GraphiQLHandler with default GraphiQLHandlerOptions. This is a convenient way to get started with GraphiQL.

```APIDOC
## static GraphiQLHandler create(Vertx vertx)

### Description
Create a new `GraphiQLHandler`.
The handler will be configured with default `GraphiQLHandlerOptions`.

### Method
static

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response
- `GraphiQLHandler` - The created GraphiQLHandler instance.

### Response Example
```json
{
  "example": "GraphiQLHandler instance"
}
```
```

--------------------------------

### Start Frontend Development Server

Source: https://vertx.io/docs/howtos/single-page-react-vertx-howto

Commands to navigate to the frontend directory and launch the development server.

```bash
cd src/main/frontend
npm start
```

--------------------------------

### Create TotpAuth with default options

Source: https://vertx.io/docs/apidocs/io/vertx/ext/auth/otp/totp/class-use/TotpAuth.html

Creates an instance of TotpAuth with default configuration. This is the simplest way to get started with TOTP authentication.

```APIDOC
## TotpAuth.create()

### Description
Creates an instance of TotpAuth with default configuration.

### Method
static TotpAuth

### Endpoint
N/A (SDK method)

### Parameters
None

### Response
- **TotpAuth** (TotpAuth) - A new instance of TotpAuth.
```

--------------------------------

### Create a QUIC Server

Source: https://vertx.io/docs/vertx-core/java

Initializes a basic QUIC server instance.

```java
QuicServer server = vertx.createQuicServer(options, sslOptions);
```

--------------------------------

### Create RockerTemplateEngine with Defaults

Source: https://vertx.io/docs/apidocs/io/vertx/ext/web/templ/rocker/class-use/RockerTemplateEngine.html

Creates a new instance of RockerTemplateEngine using the default configuration. This is the simplest way to get started with Rocker templating.

```APIDOC
## RockerTemplateEngine.create()

### Description
Create a template engine using defaults.

### Method
`static RockerTemplateEngine`

### Endpoint
N/A (SDK Method)

### Parameters
None

### Response
- **RockerTemplateEngine** (object) - A new instance of RockerTemplateEngine.
```

--------------------------------

### Start server listening (specific port and host)

Source: https://vertx.io/docs/apidocs/io/vertx/mqtt/class-use/MqttServer.html

Starts the MQTT server listening for incoming connections on the specified host and port. This method returns a Future that completes when the server has started listening.

```APIDOC
## listen(int port, String host)

### Description
Start the server listening for incoming connections on the port and host specified.

### Method
Future<MqttServer>

### Parameters
#### Path Parameters
- **port** (int) - The port number to listen on.
- **host** (String) - The host address to bind to.

### Response
#### Success Response (200)
- **MqttServer** (MqttServer) - A reference to the MqttServer instance after it has started listening.
```

--------------------------------

### Start MqttServer Listening

Source: https://vertx.io/docs/apidocs/io/vertx/rxjava3/mqtt/class-use/MqttServer.html

Methods to start the MQTT server listening for incoming connections on specified ports and hosts.

```APIDOC
## Start MqttServer Listening

### Description
Methods to start the MQTT server listening for incoming connections on specified ports and hosts.

### Methods

#### `Single<MqttServer> listen()`
Start the server listening for incoming connections using the specified options through the constructor.

#### `Single<MqttServer> listen(int port)`
Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.

#### `Single<MqttServer> listen(int port, String host)`
Start the server listening for incoming connections on the port and host specified.

#### `Single<MqttServer> rxListen()`
Start the server listening for incoming connections using the specified options through the constructor (RxJava3 version).

#### `Single<MqttServer> rxListen(int port)`
Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host (RxJava3 version).

#### `Single<MqttServer> rxListen(int port, String host)`
Start the server listening for incoming connections on the port and host specified (RxJava3 version).

```

--------------------------------

### Create WebSocketClient with default options

Source: https://vertx.io/docs/apidocs/io/vertx/core/http/class-use/WebSocketClient.html

Creates a WebSocket client using the default configuration. This is a convenient way to get started with WebSocket communication.

```APIDOC
## Vertx.createWebSocketClient()

### Description
Creates a WebSocket client using default options.

### Method
```
default WebSocketClient
```

### Endpoint
N/A (SDK method)

### Parameters
None
```

--------------------------------

### Run the application

Source: https://vertx.io/docs/howtos/metrics-prometheus-grafana-howto

Commands to start the application using build tools.

```bash
mvn compile exec:java
```

```bash
./gradlew run
```

```bash
gradlew run
```

--------------------------------

### Setup Callback for Credential Get (Assertion)

Source: https://vertx.io/docs/apidocs/io/vertx/ext/web/handler/WebAuthn4JHandler.html

Configures the callback route for creating login attestations. This is used when a user logs in with an existing authenticator.

```APIDOC
## setupCredentialsGetCallback

```java
WebAuthn4JHandler setupCredentialsGetCallback(Route route)
```

### Description
The callback route to create login attestations. Usually this route is ```
/webauthn/login
```

### Parameters
#### Path Parameters
- **route** (Route) - the route where credential get options are generated.

### Returns
fluent self.
```

--------------------------------

### Service Startup Logs

Source: https://vertx.io/docs/howtos/clustering-kubernetes-howto

Example output logs for frontend and backend services.

```text
2020-07-16 16:29:39,478 [vert.x-eventloop-thread-2] INFO  i.v.howtos.cluster.FrontendVerticle - Server started and listening on port 8080
```

```text
2020-07-16 16:29:40,770 [vert.x-eventloop-thread-2] INFO  i.v.howtos.cluster.BackendVerticle - Server started and listening on port 38621
```

--------------------------------

### Server Instantiation

Source: https://vertx.io/docs/apidocs/io/vertx/rxjava3/openapi/contract/class-use/Server.html

Demonstrates how to create a new instance of the Server class.

```APIDOC
## Server newInstance

### Description
Creates a new instance of the Server class.

### Method
`static Server`

### Parameters
#### Path Parameters
- `arg` (Server) - Required - The server instance to use for creating the new instance.
```

--------------------------------

### getRebalanceDelay

Source: https://vertx.io/docs/apidocs/io/vertx/spi/cluster/ignite/IgniteCacheOptions.html

Gets the delay in milliseconds before rebalancing starts automatically after a node joins or leaves the topology. This method is deprecated and users should use the baseline topology feature instead.

```APIDOC
## getRebalanceDelay

### Description
Gets delay in milliseconds upon a node joining or leaving topology (or crash) after which rebalancing should be started automatically. Rebalancing should be delayed if you plan to restart nodes after they leave topology, or if you plan to start multiple nodes at once or one after another and don't want to repartition and rebalance until all nodes are started. For better efficiency user should usually make sure that new nodes get placed on the same place of consistent hash ring as the left nodes, and that nodes are restarted before this delay expires. As an example, node IP address and port combination may be used in this case. Default value is `0` which means that repartitioning and rebalancing will start immediately upon node leaving topology. If `-1` is returned, then rebalancing will only be started manually by calling rebalance() method or from management console.

### Method
GET

### Endpoint
/rebalanceDelay

### Returns
- **long**: Rebalancing delay, `0` to start rebalancing immediately, `-1` to start rebalancing manually, or positive value to specify delay in milliseconds after which rebalancing should start automatically.
```

--------------------------------

### Create KubeResolver with default options

Source: https://vertx.io/docs/apidocs/io/vertx/serviceresolver/kube/class-use/KubeResolver.html

Creates a new instance of KubeResolver using default configuration options. This is the simplest way to get started with the Kubernetes service resolver.

```APIDOC
## KubeResolver.create()

### Description
Create a Kubernetes resolver with the default options.

### Method
static

### Endpoint
N/A

### Parameters
None

### Response
#### Success Response
- **KubeResolver** - An instance of KubeResolver.

### Response Example
```json
{
  "example": "KubeResolver instance"
}
```
```

--------------------------------

### Create NetServer with Options

Source: https://vertx.io/docs/apidocs/io/vertx/core/net/class-use/NetServerOptions.html

Demonstrates how to create a TCP/SSL server using NetServerOptions.

```APIDOC
## Vertx.createNetServer(NetServerOptions options)

### Description
Create a TCP/SSL server using the specified options.

### Method
`createNetServer`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
NetServerOptions options = new NetServerOptions()
  .setPort(8080)
  .setHost("localhost");
NetServer server = vertx.createNetServer(options);
```

### Response
#### Success Response (200)
`NetServer` instance

#### Response Example
```java
// Server is created and ready to accept connections
```
```

--------------------------------

### Start server listening (default host)

Source: https://vertx.io/docs/apidocs/io/vertx/mqtt/class-use/MqttServer.html

Starts the MQTT server listening for incoming connections on all available network interfaces using the port specified during server creation or default options. This method returns a Future that completes when the server has started listening.

```APIDOC
## listen()

### Description
Start the server listening for incoming connections using the specified options through the constructor.

### Method
Future<MqttServer>

### Response
#### Success Response (200)
- **MqttServer** (MqttServer) - A reference to the MqttServer instance after it has started listening.
```

--------------------------------

### Generate project with HTTPie

Source: https://vertx.io/docs/howtos/executable-jar-docker-howto

Downloads a starter project zip file from the Vert.x starter service using HTTPie.

```bash
http https://start.vertx.io/starter.zip artifactId==container-uber-jar jdkVersion==11 buildTool==gradle --output container-uber-jar.zip
unzip container-uber-jar.zip
```

--------------------------------

### Main Method Entry Point

Source: https://vertx.io/docs/vertx-mqtt/java

Initializes the main method for the authentication example.

```java
public static void main(String[] args) {
```

--------------------------------

### Initialize React Application

Source: https://vertx.io/docs/howtos/single-page-react-vertx-howto

Commands to create the React frontend skeleton within the project source directory.

```bash
cd src/main
npx create-react-app frontend
```

--------------------------------

### rxStart

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/rabbitmq/RabbitMQPublisher.html

Starts the RabbitMQ publisher using RxJava.

```APIDOC
## rxStart

### Description
Start the rabbitMQ publisher.

### Method
rxStart

### Returns
A Completable that completes when the publisher has started.
```

--------------------------------

### Start Watch

Source: https://vertx.io/docs/apidocs/io/vertx/ext/consul/class-use/Watch.html

Starts the Watch process.

```APIDOC
## Watch.start

### Description
Start this Watch.

### Method
`Watch<T> start()`
```

--------------------------------

### Get Delegate

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/ext/consul/ConsulClient.html

Get the delegate object.

```APIDOC
## getDelegate

### Description
Get the delegate object.

### Method
Instance Method

### Returns
- **ConsulClient** - The delegate Consul client.
```

--------------------------------

### KeyStoreOptions Configuration

Source: https://vertx.io/docs/apidocs/io/vertx/core/net/KeyStoreOptions.html

Demonstrates how to configure KeyStoreOptions to load keystore information from the filesystem or a buffer.

```APIDOC
## KeyStoreOptions Usage

### Description
Configures private key and/or certificates based on a `KeyStore`. This can be used as a key store (containing a private key and its certificate) or a trust store (containing a list of trusted certificates).

### Usage Examples

**Loading from Filesystem:**
```java
HttpServerOptions options = HttpServerOptions.httpServerOptions();
options.setKeyCertOptions(new KeyStoreOptions().setType("JKS").setPath("/mykeystore.jks").setPassword("foo"));
```

**Loading from Buffer:**
```java
Buffer store = vertx.fileSystem().readFileBlocking("/mykeystore.jks");
options.setKeyCertOptions(new KeyStoreOptions().setType("JKS").setValue(store).setPassword("foo"));
```

**Using Subclasses (JksOptions/PfxOptions):**
```java
HttpServerOptions options = HttpServerOptions.httpServerOptions();
options.setKeyCertOptions(new JksOptions().setPath("/mykeystore.jks").setPassword("foo"));
```

### Methods

- **`setType(String type)`**: Sets the type of the keystore (e.g., "JKS").
- **`setPath(String path)`**: Sets the path to the keystore file on the filesystem.
- **`setValue(Buffer value)`**: Sets the keystore content directly as a `Buffer`.
- **`setPassword(String password)`**: Sets the password for the keystore.

### Note
Specific subclasses like `JksOptions` and `PfxOptions` are available to pre-set the keystore type.
```

--------------------------------

### Getting ListServicesResponse

Source: https://vertx.io/docs/apidocs/io/vertx/grpc/reflection/v1/ServerReflectionResponse.Builder.html

Method for getting the list_services_response field.

```APIDOC
## getListServicesResponse

### Description
Returns the list_services_response field. This message is used to answer list_services requests.

### Method
public ListServiceResponse getListServicesResponse()

### Returns
The list_services_response.
```

--------------------------------

### Implement Main Method for BackendVerticle

Source: https://vertx.io/docs/howtos/single-page-react-vertx-howto

Initializes the Vert.x instance and deploys the BackendVerticle.

```java
  public static void main(String[] args) {
    Vertx vertx = Vertx.vertx(); __**(1)**
    vertx.deployVerticle(new BackendVerticle()).await(); __**(2)**
    System.out.println("Verticle started!");
  }
```

--------------------------------

### Add a route for any HTTP GET request

Source: https://vertx.io/docs/apidocs/io/vertx/rxjava3/ext/web/Router.html

Adds a route that will handle any incoming HTTP GET requests. This is a convenient shortcut for defining GET routes.

```APIDOC
## get

### Description
Add a route that matches any HTTP GET request

### Method
Route

### Returns
- Route - the route
```

--------------------------------

### GET Request Routing

Source: https://vertx.io/docs/apidocs/io/vertx/ext/web/Router.html

Adds a route that specifically matches HTTP GET requests. Supports matching any GET request or requests to a specific path.

```APIDOC
## get

### Description
Add a route that matches any HTTP GET request or a specific path.

### Method
Route

### Signature
get()
get(String path)
```

--------------------------------

### rxStart

Source: https://vertx.io/docs/apidocs/io/vertx/rxjava3/core/AbstractVerticle.html

Override to return a Completable that will complete the deployment of this verticle. When null is returned, the AbstractVerticle.start() will be called instead.

```APIDOC
## rxStart

### Description
Override to return a `Completable` that will complete the deployment of this verticle. When `null` is returned, the `AbstractVerticle.start()` will be called instead.

### Method
`Completable rxStart()`

### Returns
- `Completable` - the completable
```

--------------------------------

### Start Watch

Source: https://vertx.io/docs/apidocs/io/vertx/ext/consul/Watch.html

Starts the watch and begins monitoring for changes.

```APIDOC
## Watch.start
Watch<T> start()

### Description
Start this `Watch`

### Returns
reference to this, for fluency
```

--------------------------------

### Start Watch

Source: https://vertx.io/docs/apidocs/io/vertx/ext/consul/Watch.html

Start this Watch. This will begin monitoring for updates.

```APIDOC
## Start Watch

### Description
Start this Watch. This will begin monitoring for updates.

### Method
Watch<T> start()

### Response
#### Success Response
- **Watch<T>** - the Watch instance
```

--------------------------------

### rxListen (no args)

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/core/net/NetServer.html

Start listening on the port and host as configured in the NetServerOptions used when creating the server. The server may not be listening until some time after the call to listen has returned.

```APIDOC
## rxListen

### Description
Start listening on the port and host as configured in the `NetServerOptions` used when creating the server. The server may not be listening until some time after the call to `rxListen` has returned.

### Method
`Single<NetServer>`

### Returns
- **Single<NetServer>** - A future completed with the listen operation result.
```

--------------------------------

### Get ACL Tokens

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/ext/consul/ConsulClient.html

Get list of Acl token.

```APIDOC
## getAclTokens

### Description
Get list of Acl token.

### Method
GET

### Endpoint
/v1/acl/tokens

### Parameters
#### Query Parameters
- **dc** (String) - Optional - The datacenter to query.

### Response
#### Success Response (200)
- **aclTokens** (List<AclToken>) - A list of ACL tokens.

#### Response Example
```json
[
  {
    "AccessorID": "accessor-id-456",
    "Secret": "secret-token-789",
    "LocalSeq": 1,
    "CreateTime": "2023-10-27T10:00:00Z",
    "ModifyTime": "2023-10-27T10:00:00Z",
    "Name": "my-token",
    "Policies": [
      { "ID": "policy-id-123", "Name": "my-policy" }
    ]
  }
]
```
```

--------------------------------

### Create a basic QUIC client

Source: https://vertx.io/docs/vertx-core/java

Initializes a QUIC client using SSL options. ALPN must be configured via setApplicationLayerProtocols for successful handshakes.

```java
QuicClient client = vertx.createQuicClient(sslOptions);
```

--------------------------------

### listen

Source: https://vertx.io/docs/apidocs/io/vertx/core/net/QuicServer.html

Start listening on the port and host as configured in the QuicServerConfig used when creating the server.

```APIDOC
## listen

### Description
Start listening on the `port` and `host` as configured in the `QuicServerConfig` used when creating the server.

### Method
`Future<SocketAddress>`

### Returns
* `Future<SocketAddress>` - A future that completes with the listening socket address.
```

--------------------------------

### Generate project with HTTPie

Source: https://vertx.io/docs/howtos/executable-jar-docker-howto

Use HTTPie to download a starter project zip file from the Vert.x starter service.

```bash
http https://start.vertx.io/starter.zip artifactId==container-uber-jar jdkVersion==11 buildTool==maven --output container-uber-jar.zip
unzip container-uber-jar.zip
```

--------------------------------

### ServiceImporter start

Source: https://vertx.io/docs/apidocs/io/vertx/reactivex/core/class-use/Vertx.html

Starts the ServiceImporter with Vertx, publisher, configuration, and a future.

```APIDOC
## ServiceImporter start

### Description
Starts the importer by initializing it with the `Vertx` instance, `ServicePublisher`, `JsonObject` configuration, and a `Promise<Void>`.

### Method
`void`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
None

#### Response Example
None
```

--------------------------------

### start

Source: https://vertx.io/docs/apidocs/io/vertx/lang/groovy/ScriptVerticle.html

Starts the verticle instance. This method is called by Vert.x during deployment.

```APIDOC
## start

### Description
Starts the verticle instance. This method is invoked by the Vert.x framework when the verticle is deployed. The implementation should complete the provided `Promise` upon successful completion or failure.

### Method
`void start(Promise<Void> startPromise)`

### Parameters
* **startPromise** (Promise<Void>) - A promise that should be completed when the verticle has started successfully or failed.

### Throws
* `Exception`
```

--------------------------------

### Configure KeyStoreOptions

Source: https://vertx.io/docs/vertx-auth-common/java

Initialize a KeyStoreOptions object to load a local keystore file.

```java
KeyStoreOptions options = new KeyStoreOptions()
  .setPath("/path/to/keystore/file")
  .setType("pkcs8")
  .setPassword("keystore-password")
  .putPasswordProtection("key-alias", "alias-password");
```

--------------------------------

### ServiceImporter Start

Source: https://vertx.io/docs/apidocs/io/vertx/core/class-use/Vertx.html

Start method for ServiceImporter, which takes a Vertx instance.

```APIDOC
## ServiceImporter Start

### Description
Start method for ServiceImporter, which takes a Vertx instance.

### Method
`void start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> future)`
```

--------------------------------

### Create MqttServer with options

Source: https://vertx.io/docs/apidocs/io/vertx/mqtt/MqttServer.html

Creates an MqttServer instance with specified options.

```APIDOC
## create(Vertx vertx, MqttServerOptions options)

### Description
Returns an MQTT server instance configured with the provided options.

### Method
static MqttServer

### Parameters
* **vertx** (Vertx) - The Vert.x instance.
* **options** (MqttServerOptions) - The MQTT server options.

### Returns
MqttServer - An instance of the MQTT server.
```

--------------------------------

### KubernetesServiceImporter Start

Source: https://vertx.io/docs/apidocs/io/vertx/core/class-use/Vertx.html

Start method for KubernetesServiceImporter, which takes a Vertx instance.

```APIDOC
## KubernetesServiceImporter Start

### Description
Start method for KubernetesServiceImporter, which takes a Vertx instance.

### Method
`void start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`
```

--------------------------------

### Connect and Query MSSQL

Source: https://vertx.io/docs/vertx-mssql-client/java

Demonstrates configuring connection options, creating a connection pool, and executing a simple query.

```java
MSSQLConnectOptions connectOptions = new MSSQLConnectOptions()
  .setPort(1433)
  .setHost("the-host")
  .setDatabase("the-db")
  .setUser("user")
  .setPassword("secret");

// Pool options
PoolOptions poolOptions = new PoolOptions()
  .setMaxSize(5);

// Create the client pool
Pool client = MSSQLBuilder.pool()
  .with(poolOptions)
  .connectingTo(connectOptions)
  .build();

// A simple query
client
  .query("SELECT * FROM users WHERE id='julien'")
  .execute()
  .onComplete(ar -> {
    if (ar.succeeded()) {
      RowSet<Row> result = ar.result();
      System.out.println("Got " + result.size() + " rows ");
    } else {
      System.out.println("Failure: " + ar.cause().getMessage());
    }

    // Now close the pool
    client.close();
  });
```

--------------------------------

### start (synchronous)

Source: https://vertx.io/docs/apidocs/io/vertx/core/AbstractVerticle.html

If your verticle does a simple, synchronous start-up then override this method and put your start-up code in here.

```APIDOC
## start

### Description
If your verticle does a simple, synchronous start-up then override this method and put your start-up code in here.

### Method
public void start() throws Exception

### Throws
- Exception
```

--------------------------------

### DockerLinksServiceImporter Start

Source: https://vertx.io/docs/apidocs/io/vertx/core/class-use/Vertx.html

Start method for DockerLinksServiceImporter, which takes a Vertx instance.

```APIDOC
## DockerLinksServiceImporter Start

### Description
Start method for DockerLinksServiceImporter, which takes a Vertx instance.

### Method
`void start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`
```

--------------------------------

### ConsulServiceImporter Start

Source: https://vertx.io/docs/apidocs/io/vertx/core/class-use/Vertx.html

Start method for ConsulServiceImporter, which takes a Vertx instance.

```APIDOC
## ConsulServiceImporter Start

### Description
Start method for ConsulServiceImporter, which takes a Vertx instance.

### Method
`void start(Vertx vertx, ServicePublisher publisher, JsonObject configuration, Promise<Void> completion)`
```

--------------------------------

### Verticle Start Method with Futures

Source: https://vertx.io/docs/vertx-core/java

Demonstrates handling asynchronous startup logic within an AbstractVerticle using Vert.x 5 future-based patterns.

```java
class MyVerticle extends AbstractVerticle {
  @Override
  public void start(Promise<Void> startPromise) throws Exception {
    Future<String> future = bindService();

    // Requires to write
    future.onComplete(ar -> {
      if (ar.succeeded()) {
        startPromise.complete();
      } else {
        startPromise.fail(ar.cause());
      }
    });

    // Or
    future
      .<Void>mapEmpty()
      .onComplete(startPromise);
  }
}
```

--------------------------------

### start

Source: https://vertx.io/docs/apidocs/io/vertx/camel/CamelBridge.html

Starts the CamelBridge asynchronously. This method should be called after the bridge has been created.

```APIDOC
## start

### Description
Starts the bridge. The bridge is started asynchronously.

### Method
Future<Void>

### Returns
* **Future<Void>** - A future notified when the bridge has started.
```

--------------------------------

### HTTP GET Request

Source: https://vertx.io/docs/apidocs/io/vertx/rxjava3/ext/web/client/WebClient.html

Methods to create an HTTP GET request.

```APIDOC
## HTTP GET Request

### Description
Methods to create an HTTP GET request.

### Instance Methods

`HttpRequest<Buffer> get(int port, String host, UriTemplate requestURI)`
Create an HTTP GET request to send to the server at the specified host and port.

`HttpRequest<Buffer> get(int port, String host, String requestURI)`
Create an HTTP GET request to send to the server at the specified host and port.

`HttpRequest<Buffer> get(UriTemplate requestURI)`
Create an HTTP GET request to send to the server at the default host and port.

`HttpRequest<Buffer> get(String requestURI)`
Create an HTTP GET request to send to the server at the default host and port.

`HttpRequest<Buffer> get(String host, UriTemplate requestURI)`
Create an HTTP GET request to send to the server at the specified host and default port.

`HttpRequest<Buffer> get(String host, String requestURI)`
Create an HTTP GET request to send to the server at the specified host and default port.

`HttpRequest<Buffer> getAbs(UriTemplate absoluteURI)`
Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response

`HttpRequest<Buffer> getAbs(String absoluteURI)`
Create an HTTP GET request to send to the server using an absolute URI, specifying a response handler to receive the response
```

--------------------------------

### Perform simple GET and HEAD requests

Source: https://vertx.io/docs/vertx-web-client/java

Demonstrates how to initialize a WebClient and execute basic HTTP requests without a body.

```java
WebClient client = WebClient.create(vertx);

// Send a GET request
client
  .get(8080, "myserver.mycompany.com", "/some-uri")
  .send()
  .onSuccess(response -> System.out
    .println("Received response with status code" + response.statusCode()))
  .onFailure(err ->
    System.out.println("Something went wrong " + err.getMessage()));

// Send a HEAD request
client
  .head(8080, "myserver.mycompany.com", "/some-uri")
  .send()
  .onSuccess(response -> System.out
    .println("Received response with status code" + response.statusCode()))
  .onFailure(err ->
    System.out.println("Something went wrong " + err.getMessage()));
```

--------------------------------

### Getting ListServicesResponse OrBuilder

Source: https://vertx.io/docs/apidocs/io/vertx/grpc/reflection/v1/ServerReflectionResponse.Builder.html

Method for getting an OrBuilder for the list_services_response field.

```APIDOC
## getListServicesResponseOrBuilder

### Description
Returns an OrBuilder for the list_services_response field.

### Method
public ListServiceResponseOrBuilder getListServicesResponseOrBuilder()

### Returns
A ListServiceResponseOrBuilder.
```

--------------------------------

### Deploying a Verticle with an HTTP Client

Source: https://vertx.io/docs/vertx-core/java

Demonstrates creating an HTTP client and deploying a verticle with multiple instances.

```java
HttpClientAgent client = vertx.createHttpClient(config);
vertx.deployVerticle(() -> new AbstractVerticle() {
  @Override
  public void start() throws Exception {
    // Use the client
  }
}, new DeploymentOptions().setInstances(4));
```

--------------------------------

### Implement the TimeServer Usage

Source: https://vertx.io/docs/guides/advanced-vertx-guide

Demonstrates how to instantiate and start the time server with a custom request handler.

```java
Vertx vertx = Vertx.vertx();

// Create the time server
TimeServer server = TimeServer.create(vertx);
server.requestHandler(time -> {
  time.complete(System.currentTimeMillis());
});

// Start the server
server.listen(8037, "0.0.0.0")
    .onSuccess(v -> System.out.println("Server started"))
    .onFailure(err -> err.printStackTrace());
```

--------------------------------

### Getting ListServicesResponse Builder

Source: https://vertx.io/docs/apidocs/io/vertx/grpc/reflection/v1/ServerReflectionResponse.Builder.html

Method for getting a builder for the list_services_response field.

```APIDOC
## getListServicesResponseBuilder

### Description
Returns a builder for the list_services_response field.

### Method
public ListServiceResponse.Builder getListServicesResponseBuilder()

### Returns
A ListServiceResponse.Builder.
```

--------------------------------

### Getting AllExtensionNumbersResponse OrBuilder

Source: https://vertx.io/docs/apidocs/io/vertx/grpc/reflection/v1/ServerReflectionResponse.Builder.html

Method for getting an OrBuilder for the all_extension_numbers_response field.

```APIDOC
## getAllExtensionNumbersResponseOrBuilder

### Description
Returns an OrBuilder for the all_extension_numbers_response field.

### Method
public ExtensionNumberResponseOrBuilder getAllExtensionNumbersResponseOrBuilder()

### Returns
An ExtensionNumberResponseOrBuilder.
```

--------------------------------

### Creating NetClient Instances

Source: https://vertx.io/docs/apidocs/io/vertx/rxjava3/core/net/class-use/NetClient.html

Demonstrates various ways to create a NetClient instance using Vert.x.

```APIDOC
## Vertx.createNetClient()

### Description
Creates a TCP/SSL client using default options.

### Method
`createNetClient`

### Parameters
None

## Vertx.createNetClient(NetClientOptions options)

### Description
Creates a TCP/SSL client using the specified options.

### Method
`createNetClient`

### Parameters
#### Query Parameters
- **options** (NetClientOptions) - Required - The options to configure the NetClient.

## Vertx.createNetClient(TcpClientConfig config)

### Description
Creates a TCP/SSL client using the specified config.

### Method
`createNetClient`

### Parameters
#### Query Parameters
- **config** (TcpClientConfig) - Required - The configuration to set up the NetClient.

## Vertx.createNetClient(TcpClientConfig config, ClientSSLOptions sslOptions)

### Description
Creates a TCP/SSL client using the specified config and the specified SSL options.

### Method
`createNetClient`

### Parameters
#### Query Parameters
- **config** (TcpClientConfig) - Required - The configuration to set up the NetClient.
- **sslOptions** (ClientSSLOptions) - Required - The SSL options to apply to the NetClient.
```
Tokens:
Raw