All Classes and Interfaces
Class
Description
Structure passed to acknowledgement handler called when a
ACK or NACK frame is received.Simplified factory to create an for Amazon Cognito.
AMQP Client entry point.
Once connected to the broker or router, you get a connection.
Represents an AMQP message.
Builder to create a new
AmqpMessage.Interface used to consume AMQP message as a stream of message.
AMQP Sender interface used to send messages.
Allows to perform a logical 'and' between several authorizations
An authentication handler that provides API Key support.
Simplified factory to create an for Apple.
This interface is used to create able to parse serialized array structures.
An asynchronous exit point for a test.
Represents a file on the file-system which can be read from, or written to asynchronously.
A lock on a region of an
AsyncFile.An asynchronous map.
An attribute is a simple matcher for policies.
Base interface for auth handlers.
User-facing interface for authenticating users.
Interface representing any kind of authorization such as:
Role based authorization
Permission based authorization
Logical authorization (AND, OR, NOT)
Time based authorization (ie: allow access the last 5 days of the month, from 8am till 10am, etc.)
The AuthorizationContext contains properties that can be used to match
authorizations.
Base interface for authorization handlers that provide authorization support.
The role of an AuthorizationProvider is to return a set of Authorization.
Represents a cache map of authorizations per provider.
Simplified factory to create an for Azure AD.
Represents an event that occurs on the event bus bridge.
An auth handler that provides HTTP Basic Authentication support.
In this interface you can find all available
BodyProcessorFactory to use in
ValidationHandlerBuilder.Handles the HTTP proxy body.
A codec for encoding and decoding HTTP bodies.
A handler which gathers the entire request body and sets it on the .
This interface is used to build body processors.
A synchronous function that transforms an HTTP body entity.
Range of transformers ready to be used.
Simplified factory to create an for box.com.
Represents an event that occurs on the gRPC event bus bridge.
Represents an event that occurs on the event bus bridge.
Represents an event that occurs on the event bus bridge.
An asynchronous cache aware HTTP / HTTP/2 client called
CachingWebClient.Eclipse Vert.x Cassandra client.
A for consumption.
Chain several authentication providers as if they were one.
An auth handler that chains to a sequence of handlers.
An implementation of the circuit breaker pattern for Vert.x
Builder for
SqlClient instances.Represents a client-side WebSocket.
Simplified factory to create an for CloudFoundry UAA.
A session store which stores sessions in a distributed map so they are available across the cluster.
A completion object that emits completion notifications either succeeded or failed.
Defines a configuration retriever that read configuration from
and tracks changes periodically.
A Vert.x service used to interact with Consul.
The content analyser is responsible to check if a request or response has the correct format i.e. is syntactically
correct, and to transform the content-buffer into a representation that can be validated against a schema.
A SessionStore that uses a Cookie to store the session data.
A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
An asynchronous counter that can be used to across the cluster to maintain a consistent count.
Used to represent persistent storage of credentials, this gives you a way to abstract
how you want to store them (in memory, database, other).
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.
This handler adds a CSRF token to requests which mutate state.
A cursor that reads progressively rows from the database, it is useful for reading very large result sets.
Contains static metadata about the backend database server
A datagram socket can be used to send
DatagramPacket's to remote datagram servers
and receive DatagramPackets .Entry point for building DB2 clients.
A connection to DB2 server.
Encapsulates a message being delivered by Vert.x as well as providing control over the message delivery.
Represents a STOMP destination.
Interface implemented to customize the destination creation.
An auth handler that provides HTTP Basic Authentication support.
Provides a way to asynchronously lookup information from DNS servers.
Simplified factory to create an for Dropbox.
A resolver for endpoints.
A pretty error handler for rendering error pages.
A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application,
or different applications and services to communicate with each in a loosely coupled way.
The event bus collector listen to events on the Vert.x event bus and translate them
into reports.
for event bus services (service proxies).
Holds a with a contextual object.
Simplified factory to create an for Facebook.
A failure provides the details of a failure that happened during the execution of a test case.
A failure policy for the
CircuitBreaker.A handler that serves favicons.
Contains a broad set of operations for manipulating files on the file system.
Represents a file-upload from an HTTP multipart form submission.
A form data part of a
MultipartForm.Handler that handles login from a form on a custom login page.
Simplified factory to create an for Foursquare.
Utility methods to build common
Frames.A template engine that uses the FreeMarker library.
Simplified factory to create an for Gitee.
Simplified factory to create an for Github.
Simplified factory to create an for GitLab.com.
Simplified factory to create an
OAuth2Auth for Google.A handler for GraphiQL resources.
A builder for
GraphiQLHandler instances.A
Route handler for GraphQL requests.A builder for
GraphQLHandler instances.A handler for the GraphQL over WebSocket Protocol.
A builder for
GraphQLWSHandler instances.A gRPC client for Vert.x
A builder for
GrpcClient.A request to a gRPC server.
A response from a gRPC server.
gRPC EventBus bridge for Vert.x.
A builder for gRPC EventBus Bridge
A gRPC server based on Vert.x HTTP server.
A template engine that uses the Handlebars library.
Hashing Algorithm.
Hashing Strategy manager.
A Vert.x Web handler on which you register health check procedure.
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen.Simplified factory to create an for Heroku.
An extension of AuthProvider which uses the one time passwords based on counter to perform authentication.
HTTP Strict Transport Security (HSTS) RFC6797.
An extension of AuthProvider which is using .htdigest file as store
An extension of AuthProvider which is using htpasswd file as store
The API to interacts with an HTTP server.
An asynchronous HTTP client.
A builder for
HttpClient.Represents an HTTP client connection.
Represents a client-side HTTP request.
Represents a client-side HTTP response.
Represents an HTTP connection.
for HTTP endpoint (REST api).
Contains a bunch of useful HTTP headers stuff:
methods for creating instances
often used Header names
method to create optimized
CharSequence which can be used as header name and value
Handles the HTTP reverse proxy logic between the user agent and the origin.
A client-side HTTP request.
The state of the HTTP request head:
Method / URI
Headers
An HTTP response.
Common expectations for HTTP responses.
The state of the HTTP response head:
Status code / Message
Headers
An HTTP and WebSockets server.
A builder for
HttpServer.Represents an file upload from an HTML FORM.
Represents a server-side HTTP request.
Represents a server-side HTTP response.
Simplified factory to create an for IBM Cloud.
An implementation of that relies on the Infinispan Java Client.
Base input trust interface for handlers that verify the trust of the request.
Simplified factory to create an for Instagram.
JDBCPool is the interface that allows using the Sql Client API with plain JDBC.
A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json
element fully.
Implementation of RFC6901 Json Pointers.
The JsonPointerIterator is used by the read/write algorithms of the
Every method takes the currentValue as parameter, representing the actual value held by the query algorithm.
Implementations of this interface should be stateless, so they can be reused
You can implement this interface to query the structure you want using json pointers
JsonPointer to read/write the querying data structure Every method takes the currentValue as parameter, representing the actual value held by the query algorithm.
Implementations of this interface should be stateless, so they can be reused
You can implement this interface to query the structure you want using json pointers
A Json-Schema holder.
Factory interface for creating JWT based
AuthenticationProvider instances.An auth handler that provides JWT Authentication support.
Implementation of the JWT authorization provider.
Vert.x Kafka Admin client implementation
Vert.x Kafka consumer.
Vert.x Kafka consumer record
Vert.x Kafka consumer records
Vert.x Kafka producer record header.
Vert.x Kafka producer.
Vert.x Kafka producer record.
Simplified factory to create an for Keycloak.
Implementation of the Keycloak Authorization Provider.
A parsed language header.
Factory interface for creating a LDAP
AuthenticationProvider.Simplified factory to create an for LinkedIn.
Simplified factory to create an for live.com Services.
Local maps can be used to share data safely in a single Vert.x instance.
A session store which is only available on a single node.
An asynchronous exclusive lock which can be obtained from any node in the cluster.
Implement to format the output of the
LoggerHandlerA handler which logs request information to the Vert.x logger.
Represent a mail attachment that can be used in a MailMessage.
Simplified factory to create an for Mailchimp.
SMTP mail client for Vert.x
A builder for
MailClient.Instrument data fetchers so that
Maybe results are automatically converted to CompletionStage.
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen.This interface represents the most important attributes of an OpenAPI Operation.
A MediaTypeRegistration is used to register mediatypes to the openapi mediatype registry.
The MediaTypeRegistry contains all supported MediaTypes and Validators for the mediatypes.
Represents a message that is received from the event bus in a handler.
A GraphQL over WebSocket Protocol message.
An event bus consumer object representing a stream of message to an
EventBus address that can
be read from.Represents a stream of message that can be written to.
Service type for data producer.
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen.The metrics service mainly allows to return a snapshot of measured objects.
The metrics service mainly allows to return a snapshot of measured objects.
This service is derived and adapted from
This service is derived and adapted from
MetricsService in the vertx-dropwizard-metrics module.Implementation of the Microprofile MP-JWT 1.1 RBAC based on the access token groups key.
A Vert.x service used to interact with MongoDB server instances.
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen.Represents an MQTT AUTH message
An MQTT client
Represents an MQTT CONNACK message
Represents an MQTT DISCONNECT message
Represents an MQTT endpoint for point-to-point communication with the remote MQTT client
Represent the interface for each MQTT message
Represents an MQTT PUBACK message
Represents an MQTT PUBCOMP message
Represents an MQTT PUBLISH message
Represents an MQTT PUBREC message
Represents an MQTT PUBREL message
An MQTT server
Represents an MQTT SUBACK message
Represents an MQTT SUBSCRIBE message
Represents a subscription to a topic
Represents an MQTT UNSUBSCRIBE message
Entry point for building MSSQL clients.
A connection to Microsoft SQL Server.
A multipart form.
A handler which selectively executes another handler if a precondition is met.
A template engine that uses the Handlebars library.
Entry point for building MySQL clients.
An interface to define MySQL specific constants or behaviors.
An interface which represents a connection to MySQL server.
A TCP client.
Represents a TCP server
Represents a socket-like interface to a TCP connection on either the
client or the server side.
Allows to perform a logical 'not' of the specified authorization
Factory interface for creating OAuth2 based
AuthenticationProvider instances.An auth handler that provides OAuth2 Authentication support.
An asynchronous OAuth2/OIDC aware HTTP / HTTP/2 client called
WebClientOAuth2.Represents an OAuth Flow Object (the configuration).
Represents an OAuth Flows Object.
This interface is used to create able to parse serialized object structures.
Simplified factory to create an
OAuth2Auth for OpenID Connect.This interface represents the most important attributes of an OpenAPI Operation.
Entry point for building Oracle clients.
An interface to define Oracle specific constants or behaviors.
A connection to Oracle Database.
Allows to perform a logical 'or' between several authorizations
A provider that creates the request to the origin server based on
ProxyContext.An auth handler that provides One Time Password (Multi-Factor) Authentication support.
Otp key generator.
This interface represents the most important attributes of an OpenAPI Parameter.
This interface is used to build parameter processors supported on every .
In this interface you can find all available
ParameterProcessorFactory to use in
ValidationHandlerBuilder.A container with the request's headers that are meaningful enough to be parsed
Contains:
Accept -> MIME header, parameters and sortable
Accept-Charset -> Parameters and sortable
Accept-Encoding -> Parameters and sortable
Accept-Language -> Parameters and sortable
Content-Type -> MIME header and parameters
In this interface you can find all available
ArrayParserFactory, ObjectParserFactory & TupleParserFactoryThis interface represents the most important attributes of an OpenAPI Parameter.
A template engine that uses the Pebble library.
Represents a permission Note that the permission can optionally be assigned
to a specific resource
Entry point for building PostgreSQL clients.
A channel to Postgres that tracks the subscription to a given Postgres channel using the
LISTEN/UNLISTEN commands.A connection to Postgres.
A class for managing subscriptions using
LISTEN/UNLISTEN to Postgres channels.Pipe data from a
ReadStream to a WriteStream and performs flow control where necessary to
prevent the write stream buffer from getting overfull.Base platform interface for handlers that provide functionality to the application platform.
A connection pool which reuses a number of SQL connections.
A query for a prepared statement allowing parameterized execution of the query, this query will use
a prepared statement.
A prepared statement, the statement is pre-compiled and it's more efficient to execute the statement for multiple times.
An interface for creating handlers to expose Prometheus metrics via an HTTP endpoint.
A Vert.x Web
Route handler for Prometheus metrics scraping.Factory interface for creating property file based
AuthenticationProvider instances.Factory interface for creating property file based
AuthenticationProvider instances.The kind of the property, this can be used to fetch some specific property of the
execution result.Base interface for handlers that perform protocol upgrades.
A controller for proxy interception.
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen.A
HttpProxy interceptor.>Builder class for a customizable interceptor capable of transforming HTTP request/response head attributes
(headers, path, query params) as well as transforming the HTTP body.</p
Handles the interoperability of the request between the user agent and the origin.
Handles the interoperability of the response between the origin and the user agent.
A template engine that uses Pug.
A query.
A Quic client.
A Quic connection between a client and a server, providing support for handling or creating Quic
streamsRepresents a Quic endpoints, whose primary function is to bind a UDP socket on a given or random port.
A Quic server.
A Quic stream.
NOTE: This class has been automatically generated from the
original non RX-ified interface using Vert.x codegen.A stream of messages from a rabbitmq queue.
Represent a message received message received in a rabbitmq-queue.
A reliable publisher that
Queues up messages internally until it can successfully call basicPublish.
Represents a stream of items that can be read from.
A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed
size records.
An auth handler that's used to handle auth by redirecting user to a custom login page.
A simple Redis client.
Auto generated Redis API client wrapper.
Utilities for Redis cluster.
A simple Redis client.
Service type for Redis data source.
A SessionStore that uses a Redis to store the sessions and associated data.
JsonObject
$ref resolver.This interface represents the most important attributes of an OpenAPI Operation.
Request parameter holder
Container for request parameters
Request predicate
Result of a
RequestPredicateThe
RequestValidator requires the parameters in a specific format to be able to
parse and validate them.A handler which sets the response content type automatically according to the best
Accept header match.Handler which adds a header `x-response-time` in the response of matching requests containing the time taken
in ms to process the request.
It is like
AsyncResultSet, but adapted for Vert.x.A policy for retry execution.
A template engine that uses the Rocker library.
Represents a role.
A route is a holder for a set of criteria which determine whether an HTTP request or failure should be routed
to a handler.
A router receives request from an
HttpServer and routes it to the first matching
Route that it contains.Interface to build a Vert.x Web from an OpenAPI 3 contract.
Represents the context for the handling of a request in Vert.x-Web.
A single row of the
execution result rowset.Describe a database row.
An iterator for processing rows.
Map a to an arbitrary
T object.The execution result of the row set of a query provided as
RowSet|
.A row oriented stream.
Simplified factory to create an for Salesforce.
A repository is a holder of dereferenced schemas, it can be used to create validator instances for a specific schema.
Scope is a mechanism in OAuth 2.0 to limit an application's access to a user's account.
An authentication handler factory.
A handler that logs security audit events.
Base security policy interface for handlers that provide HTTP security related headers.
A Security requirement is an object that contains the names of the security schemes that apply to the operation.
Represents a Security Scheme Object.
This interface represents the most important attributes of an OpenAPI Server.
A physical server of an endpoint.
Structure passed to server handler when receiving a frame.
Request interaction with an endpoint, mostly callbacks to gather statistics.
Represents a server side WebSocket.
A server WebSocket handshake, allows to control acceptance or rejection of a WebSocket.
A contract for registering gRPC service method handlers, without requiring
a specific transport.
Service Discovery main entry point.
The service exporter allows integrate other discovery technologies with the Vert.x service discovery.
The service importer allows integrate other discovery technologies with the Vert.x service discovery.
A contract for issuing gRPC client requests by service method, without requiring
a specific transport or server address.
The publisher is used by the importer to publish or unpublish records.
Once a consumer has chosen a service, it builds a
ServiceReference managing the binding with the chosen
service provider.Represents a browser session.
A handler that maintains a
Session for each browser
session.A session store is used to store sessions for an Vert.x-Web web app
Shared data allows you to share data safely between different parts of your application in a safe way.
Simplified factory to create an for Shopify.
A user customizable authentication handler.
Instrument data fetchers so that
Single results are automatically converted to CompletionStage.A handler that allows you to handle SockJS connections from clients.
You interact with SockJS clients through instances of SockJS socket.
Simplified factory to create an for SoundCloud.
Factory interface for creating
AuthenticationProvider instances that use the Vert.x SQL client.Factory interface for creating instances that use the Vert.x SQL client.
Defines common SQL client operations with a database server.
A connection to the database server.
Tag if a parameter is of type OUT or INOUT.
An interface that represents the execution result of an operation on the database server.
An SQL template.
Utility to create users/roles/permissions.
A handler for serving static resources from the file system or classpath.
Defines a STOMP client.
Once a connection to the STOMP server has been made, client receives a
StompClientConnection, that let
send and receive STOMP frames.Defines a STOMP server.
Class representing a connection between a STOMP client a the server.
STOMP server handler implements the behavior of the STOMP server when a specific event occurs.
Base interface for a stream.
Represents a channel interface modelling a duplex flow controlled byte oriented stream.
Simplified factory to create an for Stripe.
This interface is used to build complex parameter processors supported only in cookie & query.
TCP EventBus bridge for Vert.x
A template template uses a specific template and the data in a routing context to render a resource into a buffer.
A handler which renders responses using a template engine and where the template name is selected from the URI
path.
A test case object can be used to create a single test.
Report the execution of a test case.
This object provides callback-ability for the end of a test suite, the completion succeeds
when all tests pass otherwise it fails.
The test context is used for performing test assertions and manage the completion of the test.
The result of a test.
A named suite of test cases that are executed altogether.
The test suite reports is basically a stream of events reporting the test suite execution.
A template engine that uses the Thymeleaf library.
Handler that will timeout requests if the response has not been written after a certain time.
An extension of AuthProvider which uses the one time passwords based on time to perform authentication.
A transaction.
A general purpose tuple.
Map an arbitrary
T object to a .This interface is used to create able to parse serialized object structures.
Simplified factory to create an for Twitter.
A URI template that follows the rfc6570 level 4.
Represents an authenticates User and contains operations to authorise the user.
A web user is extended user coupled to the context and is used to perform verifications
and actions on behalf of the user.
Builder for a .
A validator, validates some input object using a well known schema.
Auto generated Valkey API client wrapper.
Holds a set of name/value pairs where each value can be a
String or a List or a Map<String, String>.A secure non blocking random number generator isolated to the current context.
Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks)
which is monitored for updates.
Factory interface for creating WebAuthN based
AuthenticationProvider instances.An auth handler that provides FIDO2 WebAuthN Relay Party support.
An asynchronous HTTP / HTTP/2 client called
WebClient.An asynchronous sessions aware HTTP / HTTP/2 client called
WebClientSession.Utility API to verify which environment is the web application running.
Common WebSocket implementation.
Base WebSocket implementation.
An asynchronous WebSocket client.
Represents a wildcard permission (ie: 'manage:order:*' '*:orders', '*', etc.)
Represents a stream of data that can be written to.
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
Simplified factory to create an for Zoho.