Classes, interfaces and traits
AccessToken¶
AccessToken extension to the User interface
« More »
Acknowledgement¶
Structure passed to acknowledgement handler called when a <code>ACK</code> or <code>NACK</code> frame is received. The handler
receives an instance of @see \io\vertx\jphp\ext\stomp\Acknowledgement with the subscription @see \io\vertx\jphp\ext\stomp\Frame and the impacted messages. The
list of messages depends on the type of acknowledgment used by the subscription.
<p/>
Subscriptions using the <code>client</code> mode receives all messages that were waiting for acknowledgment that were
sent before the acknowledged messages. The list also contains the acknowledged message. This is a cumulative
acknowledgement. Subscriptions using the <code>client-individual</code> mode receives a singleton list containing only
the acknowledged message.
« More »
AclToken¶
Holds properties of Acl token
« More »
AddressResolverOptions¶
Configuration options for Vert.x hostname resolver. The resolver uses the local <i>hosts</i> file and performs
DNS <i>A</i> and <i>AAAA</i> queries.
« More »
AdminUtils¶
Provides a wrapper around important methods in Kafka's AdminUtils, namely
« More »
AggregateOptions¶
Options used to configure aggregate operations.
« More »
AmqpBridge¶
Vert.x AMQP Bridge. Facilitates sending and receiving AMQP 1.0 messages.
« More »
AmqpBridgeOptions¶
Options for configuring the AmqpBridge.
« More »
Argument¶
Defines a command line argument. Unlike options, argument don't have names and are identified using an index. The
first index is 0 (because we are in the computer world).
« More »
Async¶
An asynchronous exit point for a test.<p/>
« More »
AsyncFile¶
Represents a file on the file-system which can be read from, or written to asynchronously.
<p>
This class also implements @see \io\vertx\jphp\core\streams\ReadStream and
« More »
AsyncSQLClient¶
Represents an asynchronous SQL client
« More »
AuthHandler¶
Base interface for auth handlers.
<p>
An auth handler allows your application to provide authentication/authorization support.
<p>
Auth handler requires a @see \io\vertx\jphp\ext\web\handler\SessionHandler to be on the routing chain before it.
« More »
AuthOptions¶
A common base object for authentication options.<p>
« More »
AuthProvider¶
User-facing interface for authenticating users.
« More »
AzureADAuth¶
Simplified factory to create an for Azure AD.
« More »
BaseBridgeEvent¶
Represents an event that occurs on the event bus bridge.
<p>
Please consult the documentation for a full explanation.
« More »
BasicAuthHandler¶
An auth handler that provides HTTP Basic Authentication support.
« More »
BasicProperties¶
Like {@link com.rabbitmq.client.BasicProperties}
« More »
BlockingQueryOptions¶
Options used to perform blocking query that used to wait for a potential change using long polling.
« More »
BodyCodec¶
A codec for encoding and decoding HTTP bodies.
« More »
BodyHandler¶
A handler which gathers the entire request body and sets it on the .
<p>
It also handles HTTP file uploads and can be used to limit body sizes.
« More »
BoxAuth¶
Simplified factory to create an for box.com.
« More »
BridgeEvent¶
Represents an event that occurs on the event bus bridge.
<p>
Please consult the documentation for a full explanation.
« More »
BridgeOptions¶
Options for configuring the event bus bridge.
« More »
BridgeOptions¶
Specify the event bus bridge options.
« More »
BridgeOptions¶
Specify the event bus bridge options.
« More »
Buffer¶
Most data is shuffled around inside Vert.x using buffers.
<p>
A buffer is a sequence of zero or more bytes that can read from or written to and which expands automatically as
necessary to accommodate any bytes written to it. You can perhaps think of a buffer as smart byte array.
<p>
Please consult the documentation for more information on buffers.
« More »
BulkOperation¶
Contains all data needed for one operation of a bulk write operation.
« More »
BulkWriteOptions¶
Options for configuring bulk write operations.
« More »
CassandraClient¶
Eclipse Vert.x Cassandra client.
« More »
CassandraClientOptions¶
Eclipse Vert.x Cassandra client options.
« More »
CassandraRowStream¶
A for consumption.
« More »
ChainAuth¶
Chain several auth providers as if they were one. This is useful for cases where one want to authenticate across
several providers, for example, database and fallback to passwd file.
« More »
ChainAuthHandler¶
An auth handler that chains to a sequence of handlers.
« More »
CheckList¶
Holds result of checks query
« More »
CheckOptions¶
Options used to register checks in Consul.
« More »
CheckQueryOptions¶
Options used to requesting list of checks
« More »
CircuitBreaker¶
An implementation of the circuit breaker pattern for Vert.x
« More »
CircuitBreakerOptions¶
Circuit breaker configuration options. All time are given in milliseconds.
« More »
CLI¶
Interface defining a command-line interface (in other words a command such as 'run', 'ls'.
..).
This interface is polyglot to ease reuse such as in Vert.x Shell.
<p/>
A command line interface has a name, and defines a set of options and arguments. Options are key-value pair such
as <code>-foo=bar</code> or <code>-flag</code>. The supported formats depend on the used parser. Arguments are unlike
options raw values. Options are defined using
« More »
ClientOptionsBase¶
Base class for Client options
« More »
CliToken¶
A parsed token in the command line interface.
« More »
CloudFoundryAuth¶
Simplified factory to create an for CloudFoundry UAA.
« More »
ClusteredSessionStore¶
A session store which stores sessions in a distributed map so they are available across the cluster.
« More »
Command¶
A Vert.x Shell command, it can be created from any language using the @see \io\vertx\jphp\ext\shell\command\CommandBuilder::command or from a
Java class using @see \io\vertx\jphp\ext\shell\command\Command::create
« More »
CommandBuilder¶
A build for Vert.x Shell command.
« More »
CommandLine¶
The parser transforms a CLI (a model) into an @see \io\vertx\jphp\core\cli\CommandLine. This @see \io\vertx\jphp\core\cli\CommandLine
has stored the argument and option values. Only instance of parser should create
objects of this type.
« More »
CommandProcess¶
The command process provides interaction with the process of the command provided by Vert.x Shell.
« More »
CommandRegistry¶
A registry that contains the commands known by a shell.<p/>
It is a mutable command resolver.
« More »
CommandResolver¶
A resolver for commands, so the shell can discover commands.
« More »
Completion¶
A completion object that emits completion notifications either <i>succeeded</i> or <i>failed</i>.
« More »
CompositeFuture¶
The composite future wraps a list of @see \io\vertx\jphp\core\Future futures, it is useful when several futures
needs to be coordinated.
The handlers set for the coordinated futures are overridden by the handler of the composite future.
« More »
ConfigChange¶
A structure representing a configuration change.
« More »
ConfigRetriever¶
Defines a configuration retriever that read configuration from
and tracks changes periodically.
« More »
ConfigRetrieverOptions¶
Options to configure the <code>ConfigRetriever</code>.
« More »
ConfigStoreOptions¶
Data object representing the configuration of a configuration store. This object describes the configuration of a
chunk of configuration that you retrieve. It specifies its type (type of configuration store), the format of the
retrieved configuration chunk, and you can also configures the store if it needs configuration to
retrieve the configuration chunk.
« More »
ConsulClient¶
A Vert.x service used to interact with Consul.
« More »
ConsulClientOptions¶
Options used to create Consul client.
« More »
ContainerDeserializer¶
Interface that define methods for deserialization of array and objects
« More »
Context¶
The execution context of a {@link io.vertx.core.Handler} execution.
<p>
When Vert.x provides an event to a handler or calls the start or stop methods of a \io\vertx\jphp\core\io.vertx.core.Verticle,
the execution is associated with a <code>Context</code>.
<p>
Usually a context is an *event-loop context* and is tied to a specific event loop thread. So executions for that
context always occur on that exact same event loop thread.
<p>
In the case of worker verticles and running inline blocking code a worker context will be associated with the execution
which will use a thread from the worker thread pool.
<p>
When a handler is set by a thread associated with a specific context, the Vert.x will guarantee that when that handler
is executed, that execution will be associated with the same context.
<p>
If a handler is set by a thread not associated with a context (i.e. a non Vert.x thread). Then a new context will
be created for that handler.
<p>
In other words, a context is propagated.
<p>
This means that when a verticle is deployed, any handlers it sets will be associated with the same context - the context
of the verticle.
<p>
This means (in the case of a standard verticle) that the verticle code will always be executed with the exact same
thread, so you don't have to worry about multi-threaded acccess to the verticle state and you can code your application
as single threaded.
<p>
This class also allows arbitrary data to be @see \io\vertx\jphp\core\Context::put and @see \io\vertx\jphp\core\Context::get on the context so it can be shared easily
amongst different handlers of, for example, a verticle instance.
<p>
This class also provides @see \io\vertx\jphp\core\Context::runOnContext which allows an action to be executed asynchronously using the same context.
« More »
Cookie¶
Represents an HTTP Cookie.
<p>
All cookies must have a name and a value and can optionally have other fields set such as path, domain, etc.
<p>
(Derived from io.netty.handler.codec.http.Cookie)
« More »
CookieHandler¶
A handler which decodes cookies from the request, makes them available in the
and writes them back in the response.
« More »
Coordinate¶
Holds network coordinates of node
« More »
CoordinateList¶
Holds result of network coordinates query
« More »
CopyOptions¶
Describes the copy (and move) options.
« More »
CorsHandler¶
A handler which implements server side http://www.w3.org/TR/cors/[CORS] support for Vert.x-Web.
« More »
Counter¶
An asynchronous counter that can be used to across the cluster to maintain a consistent count.
<p>
« More »
CSRFHandler¶
This handler adds a CSRF token to requests which mutate state. In order change the state a (XSRF-TOKEN) cookie is set
with a unique token, that is expected to be sent back in a (X-XSRF-TOKEN) header.
The behavior is to check the request body header and cookie for validity.
This Handler requires session support, thus should be added somewhere below Session and Body handlers.
« More »
CustomValidator¶
This interface is used to add custom <b>synchronous</b> functions inside validation process. You can add it in
« More »
DatagramPacket¶
A received datagram packet (UDP) which contains the data and information about the sender of the data itself.
« More »
DatagramSocket¶
A datagram socket can be used to send @see \io\vertx\jphp\core\datagram\DatagramPacket's to remote datagram servers
and receive @see \io\vertx\jphp\core\datagram\DatagramPackets .
<p>
Usually you use a datagram socket to send UDP over the wire. UDP is connection-less which means you are not connected
to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer
when sending data.
<p>
You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.
<p>
Please consult the documentation for more information on datagram sockets.
« More »
DatagramSocketOptions¶
Options used to configure a datagram socket.
« More »
DataObjectTCK¶
todo:
- Buffer support
« More »
DataObjectWithOnlyJsonObjectConstructor¶
« More »
DcCoordinates¶
Holds coordinates of servers in datacenter
« More »
DeliveryContext¶
Encapsulates a message being delivered by Vert.x as well as providing control over the message delivery.
<p/>
Used with event bus interceptors.
« More »
DeliveryOptions¶
Delivery options are used to configure message delivery.
<p>
Delivery options allow to configure delivery timeout and message codec name, and to provide any headers
that you wish to send with the message.
« More »
DeploymentOptions¶
Options for configuring a verticle deployment.
<p>
« More »
Destination¶
Represents a STOMP destination.
Depending on the implementation, the message delivery is different. Queue are sending message to only one
subscribers, while topics are broadcasting the message to all subscribers.
<p/>
Implementations <strong>must</strong> be thread-safe.
« More »
DestinationFactory¶
Interface implemented to customize the destination creation.
« More »
DigestAuthHandler¶
An auth handler that provides HTTP Basic Authentication support.
« More »
DnsClient¶
Provides a way to asynchronously lookup information from DNS servers.
<p>
Please consult the documentation for more information on DNS clients.
« More »
DnsClientOptions¶
Configuration options for Vert.x DNS client.
« More »
DropboxAuth¶
Simplified factory to create an for Dropbox.
« More »
DropwizardMetricsOptions¶
Vert.x Dropwizard metrics configuration.
« More »
Envelope¶
Like {@link com.rabbitmq.client.Envelope}.
« More »
ErrorConverter¶
Converts a @see \io\vertx\jphp\ext\web\client\predicate\ResponsePredicateResult to a <code>Throwable</code> describing the error.
« More »
ErrorHandler¶
A pretty error handler for rendering error pages.
« More »
Event¶
Holds properties of Consul event
« More »
EventBus¶
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.
<p>
An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.
<p>
Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.
<p>
Please refer to the documentation for more information on the event bus.
« More »
EventBusCollector¶
The event bus collector listen to events on the Vert.x event bus and translate them
into reports.
« More »
EventBusOptions¶
Options to configure the event bus.
« More »
EventBusService¶
for event bus services (service proxies).
Consumers receive a service proxy to use the service.
« More »
EventList¶
Holds result of events query
« More »
EventListOptions¶
Holds options for events list request
« More »
EventOptions¶
Options used to trigger a new user event.
« More »
FacebookAuth¶
Simplified factory to create an for Facebook.
« More »
Failure¶
A failure provides the details of a failure that happened during the execution of a test case.<p/>
The failure can be:
<ul>
<li>an assertion failure: an assertion failed</li>
<li>an error failure: an expected error occured</li>
</ul>
« More »
FaviconHandler¶
A handler that serves favicons.
<p>
If no file system path is specified it will attempt to serve a resource called `favicon.ico` from the classpath.
« More »
FileProps¶
Represents properties of a file on the file system.
<p>
« More »
FileSystem¶
Contains a broad set of operations for manipulating files on the file system.
<p>
A (potential) blocking and non blocking version of each operation is provided.
<p>
The non blocking versions take a handler which is called when the operation completes or an error occurs.
<p>
The blocking versions are named <code>xxxBlocking</code> and return the results, or throw exceptions directly.
In many cases, depending on the operating system and file system some of the potentially blocking operations
can return quickly, which is why we provide them, but it's highly recommended that you test how long they take to
return in your particular application before using them on an event loop.
<p>
Please consult the documentation for more information on file system support.
« More »
FileSystemOptions¶
Vert.x file system base configuration, this class can be extended by provider implementations to configure
those specific implementations.
« More »
FileSystemProps¶
Represents properties of the file system.
« More »
FileUpload¶
Represents a file-upload from an HTTP multipart form submission.
<p>
« More »
FindOptions¶
Options used to configure find operations.
« More »
FoursquareAuth¶
Simplified factory to create an for Foursquare.
« More »
Frame¶
Represents a STOMP frame. STOMP frames are structured as follows. It starts by a <code>command</code>, followed by a
set of headers. Then the frame may have a body and is finished by a <code>0</code> byte. This class represents this
structure and provide access to the different parts.
<p/>
This class is <strong>NOT</strong> thread-safe.
« More »
Frames¶
Utility methods to build common @see \io\vertx\jphp\ext\stomp\Frames. It defines a non-STOMP frame (<code>PING</code>) that is used for
heartbeats. When such frame is written on the wire it is just the <code>0</code> byte.
<p/>
This class is thread-safe.
« More »
FreeMarkerTemplateEngine¶
A template engine that uses the FreeMarker library.
« More »
Future¶
Represents the result of an action that may, or may not, have occurred yet.
<p>
« More »
GithubAuth¶
Simplified factory to create an for Github.
« More »
GoogleAuth¶
Simplified factory to create an @see \io\vertx\jphp\ext\auth\oauth2\OAuth2Auth for Google.
« More »
HandlebarsTemplateEngine¶
A template engine that uses the Handlebars library.
« More »
HashingAlgorithm¶
Hashing Algorithm. A common interface to interact with any system provided algorithms.
« More »
HashingStrategy¶
Hashing Strategy manager.
This class will load system provided hashing strategies and algorithms.
« More »
HashStrategy¶
Determines how the hashing is computed in the implementation You can implement this to provide a different hashing
strategy to the default.
« More »
HealthCheckHandler¶
A Vert.x Web handler on which you register health check procedure. It computes the outcome status (`UP` or `DOWN`)
. When the handler process a HTTP request, it computes the global outcome and build a HTTP response as follows:
<p>
<ul>
<li>204 - status is `UP` but no procedures installed (no payload)</li>
<li>200 - status is `UP`, the payload contains the result of the installed procedures</li>
<li>503 - status is `DOWN`, the payload contains the result of the installed procedures</li>
<li>500 - status is `DOWN`, the payload contains the result of the installed procedures, one of the
procedure has failed</li>
</ul>
« More »
HerokuAuth¶
Simplified factory to create an for Heroku.
« More »
HtdigestAuth¶
An extension of AuthProvider which is using .htdigest file as store
« More »
HtpasswdAuth¶
An extension of AuthProvider which is using htpasswd file as store
« More »
HtpasswdAuthOptions¶
Options configuring htpasswd authentication.
« More »
Http2Settings¶
HTTP2 settings, the settings is initialized with the default HTTP/2 values.<p>
The settings expose the parameters defined by the HTTP/2 specification, as well as extra settings for
protocol extensions.
« More »
HttpClient¶
An asynchronous HTTP client.
<p>
It allows you to make requests to HTTP servers, and a single client can make requests to any server.
<p>
It also allows you to open WebSockets to servers.
<p>
The client can also pool HTTP connections.
<p>
For pooling to occur, keep-alive must be true on the @see \io\vertx\jphp\core\http\HttpClientOptions (default is true).
In this case connections will be pooled and re-used if there are pending HTTP requests waiting to get a connection,
otherwise they will be closed.
<p>
This gives the benefits of keep alive when the client is loaded but means we don't keep connections hanging around
unnecessarily when there would be no benefits anyway.
<p>
The client also supports pipe-lining of requests. Pipe-lining means another request is sent on the same connection
before the response from the preceding one has returned. Pipe-lining is not appropriate for all requests.
<p>
To enable pipe-lining, it must be enabled on the @see \io\vertx\jphp\core\http\HttpClientOptions (default is false).
<p>
When pipe-lining is enabled the connection will be automatically closed when all in-flight responses have returned
and there are no outstanding pending requests to write.
<p>
The client is designed to be reused between requests.
« More »
HttpClientOptions¶
Options describing how an @see \io\vertx\jphp\core\http\HttpClient will make connections.
« More »
HttpClientRequest¶
Represents a client-side HTTP request.
<p>
Instances are created by an @see \io\vertx\jphp\core\http\HttpClient instance, via one of the methods corresponding to the
specific HTTP methods, or the generic request methods. On creation the request will not have been written to the
wire.
<p>
Once a request has been obtained, headers can be set on it, and data can be written to its body if required. Once
you are ready to send the request, one of the @see \io\vertx\jphp\core\http\HttpClientRequest::end methods should be called.
<p>
Nothing is actually sent until the request has been internally assigned an HTTP connection.
<p>
The @see \io\vertx\jphp\core\http\HttpClient instance will return an instance of this class immediately, even if there are no HTTP
connections available in the pool. Any requests sent before a connection is assigned will be queued
internally and actually sent when an HTTP connection becomes available from the pool.
<p>
The headers of the request are queued for writing either when the @see \io\vertx\jphp\core\http\HttpClientRequest::end method is called, or, when the first
part of the body is written, whichever occurs first.
<p>
This class supports both chunked and non-chunked HTTP.
<p>
It implements @see \io\vertx\jphp\core\streams\WriteStream so it can be used with
« More »
HttpClientResponse¶
Represents a client-side HTTP response.
<p>
Vert.x provides you with one of these via the handler that was provided when creating the @see \io\vertx\jphp\core\http\HttpClientRequest
or that was set on the @see \io\vertx\jphp\core\http\HttpClientRequest instance.
<p>
It implements @see \io\vertx\jphp\core\streams\ReadStream so it can be used with
« More »
HttpConnection¶
Represents an HTTP connection.
<p/>
HTTP/1.x connection provides an limited implementation, the following methods are implemented:
<ul>
<li>@see \io\vertx\jphp\core\http\HttpConnection::close</li>
<li>@see \io\vertx\jphp\core\http\HttpConnection::closeHandler</li>
<li>@see \io\vertx\jphp\core\http\HttpConnection::exceptionHandler</li>
</ul>
« More »
HttpEndpoint¶
for HTTP endpoint (REST api).
Consumers receive a HTTP client configured with the host and port of the endpoint.
« More »
HttpLocation¶
Represents the location of a HTTP endpoint. This object (its json representation) will be used as "location" in a
service record.
« More »
HTTPOperationRequestValidationHandler¶
Base interface for HTTP request validation with API specification
« More »
HTTPRequestValidationHandler¶
An interface for add HTTP Request validation. This class can validate parameters inside query, path, headers an
body (watch below)
<br/>
You can assign multiple body type at the same time(for example a JSON schema together with a XML schema). This
interface support:
<ul>
<li>application/x-www-form-urlencoded</li>
<li>multipart/form-data</li>
<li>application/xml</li>
<li>application/json</li>
</ul>
Also you can add a form parameter for validation without care about content type of your request. For form
parameters this interface support both "multipart/form-data" and "application/x-www-form-urlencoded"
<br/>
This interface allow extra parameters in the request, so it doesn't care if in a request there's a parameter
without a specified validation rule
<br/>
If a parameter is flagged as an array, it will be validated also if the size of array is 1 element
« More »
HttpResponse¶
An HTTP response.
<p>
The usual HTTP response attributes are available:
<ul>
<li>@see \io\vertx\jphp\ext\web\client\HttpResponse::statusCode the HTTP status code</li>
<li>@see \io\vertx\jphp\ext\web\client\HttpResponse::statusMessage the HTTP status message</li>
<li>@see \io\vertx\jphp\ext\web\client\HttpResponse::headers the HTTP headers</li>
<li>@see \io\vertx\jphp\ext\web\client\HttpResponse::version the HTTP version</li>
</ul>
<p>
The body of the response is returned by @see \io\vertx\jphp\ext\web\client\HttpResponse::body decoded as the format specified by the @see \io\vertx\jphp\ext\web\codec\BodyCodec that
built the response.
<p>
Keep in mind that using this <code>HttpResponse</code> impose to fully buffer the response body and should be used for payload
that can fit in memory.
« More »
HttpServer¶
An HTTP and WebSockets server.
<p>
You receive HTTP requests by providing a @see \io\vertx\jphp\core\http\HttpServer::requestHandler. As requests arrive on the server the handler
will be called with the requests.
<p>
You receive WebSockets by providing a @see \io\vertx\jphp\core\http\HttpServer::websocketHandler. As WebSocket connections arrive on the server, the
WebSocket is passed to the handler.
« More »
HttpServerFileUpload¶
Represents an file upload from an HTML FORM.
« More »
HttpServerOptions¶
Represents options used by an @see \io\vertx\jphp\core\http\HttpServer instance
« More »
HttpServerRequest¶
Represents a server-side HTTP request.
<p>
Instances are created for each request and passed to the user via a handler.
<p>
Each instance of this class is associated with a corresponding @see \io\vertx\jphp\core\http\HttpServerResponse instance via
« More »
HttpServerResponse¶
Represents a server-side HTTP response.
<p>
An instance of this is created and associated to every instance of
« More »
HttpTermOptions¶
The web term configuration options.
« More »
HystrixMetricHandler¶
A Vert.x web handler to expose the circuit breaker to the Hystrix dasbboard. The handler listens to the circuit
breaker notifications sent on the event bus.
« More »
IndexOptions¶
Options used to configure index.
« More »
InstagramAuth¶
Simplified factory to create an for Instagram.
« More »
JadeTemplateEngine¶
A template engine that uses Jade.
« More »
JDBCAuth¶
Factory interface for creating @see \io\vertx\jphp\ext\auth\AuthProvider instances that use the Vert.x JDBC client.
By default the hashing strategy is SHA-512. If you're already running in production this is backwards
compatible, however for new deployments or security upgrades it is recommended to use the PBKDF2 strategy
as it is the current OWASP recommendation for password storage.
« More »
JDBCAuthOptions¶
Options configuring JDBC authentication.
« More »
JDBCClient¶
An asynchronous client interface for interacting with a JDBC compliant database
« More »
JDBCHashStrategy¶
Determines how the hashing is computed in the implementation
You can implement this to provide a different hashing strategy to the default.
« More »
JdkSSLEngineOptions¶
Configures a @see \io\vertx\jphp\core\net\TCPSSLOptions to use the JDK ssl engine implementation.
« More »
JksOptions¶
Key or trust store options configuring private key and/or certificates based on Java Keystore files.
<p>
When used as a key store, it should point to a store containing a private key and its certificate.
When used as a trust store, it should point to a store containing a list of trusted certificates.
<p>
The store can either be loaded by Vert.x from the filesystem:
<p>
<pre>
HttpServerOptions options = HttpServerOptions.httpServerOptions();
options.setKeyStore(new JKSOptions().setPath("/mykeystore.jks").setPassword("foo"));
</pre>
Or directly provided as a buffer:
<p>
<pre>
Buffer store = vertx.fileSystem().readFileSync("/mykeystore.jks");
options.setKeyStore(new JKSOptions().setValue(store).setPassword("foo"));
</pre>
« More »
Job¶
A job executed in a @see \io\vertx\jphp\ext\shell\system\JobController, grouping one or several process.<p/>
The job life cycle can be controlled with the @see \io\vertx\jphp\ext\shell\system\Job::run, @see \io\vertx\jphp\ext\shell\system\Job::resume and @see \io\vertx\jphp\ext\shell\system\Job::suspend and @see \io\vertx\jphp\ext\shell\system\Job::interrupt
methods.
« More »
JobController¶
The job controller.<p/>
« More »
JsonEvent¶
A JSON event emited by the @see \io\vertx\jphp\core\parsetools\JsonParser.
« More »
JsonParser¶
A parser class which allows to incrementally parse json elements and emit json parse events instead of parsing a json
element fully. This parser is convenient for parsing large json structures.
<p/>
The parser also parses concatenated json streams or line delimited json streams.
<p/>
The parser can also parse entire object or array when it is convenient, for instance a very large array
of small objects can be parsed efficiently by handling array <i>start</i>/<i>end</i> and <i>object</i>
events.
<p/>
Whenever the parser fails to parse or process the stream, the @see \io\vertx\jphp\core\parsetools\JsonParser::exceptionHandler is called with
the cause of the failure and the current handling stops. After such event, the parser should not handle data
anymore.
« More »
JWTAuth¶
Factory interface for creating JWT based @see \io\vertx\jphp\ext\auth\AuthProvider instances.
« More »
JWTAuthHandler¶
An auth handler that provides JWT Authentication support.
« More »
JWTAuthOptions¶
Options describing how an JWT Auth should behave.
« More »
JWTKeyStoreOptions¶
Options describing how an JWT KeyStore should behave.
« More »
JWTOptions¶
Options related to creation of new tokens.
If any expiresInMinutes, audience, subject, issuer are not provided, there is no default.
The jwt generated won't include those properties in the payload.
Generated JWTs will include an iat claim by default unless noTimestamp is specified.
« More »
KafkaConsumer¶
Vert.x Kafka consumer.
<p>
You receive Kafka records by providing a @see \io\vertx\jphp\kafka\client\consumer\KafkaConsumer::handler. As messages arrive the handler
will be called with the records.
<p>
The @see \io\vertx\jphp\kafka\client\consumer\KafkaConsumer::pause and @see \io\vertx\jphp\kafka\client\consumer\KafkaConsumer::resume provides global control over reading the records from the consumer.
<p>
The @see \io\vertx\jphp\kafka\client\consumer\KafkaConsumer::pause and @see \io\vertx\jphp\kafka\client\consumer\KafkaConsumer::resume provides finer grained control over reading records
for specific Topic/Partition, these are Kafka's specific operations.
« More »
KafkaConsumerRecord¶
Vert.x Kafka consumer record
« More »
KafkaConsumerRecords¶
Vert.x Kafka consumer records
« More »
KafkaProducer¶
Vert.x Kafka producer.
<p>
The provides global control over writing a record.
« More »
KafkaProducerRecord¶
Vert.x Kafka producer record.
« More »
KeycloakAuth¶
Simplified factory to create an for Keycloak.
« More »
KeycloakHelper¶
Helper class for processing Keycloak principal.
« More »
KeycloakRBAC¶
Implementation of the Keycloak RBAC handler.
« More »
KeyStoreOptions¶
Options describing how an JWT KeyStore should behave.
« More »
KeyValue¶
Represents key/value pair stored in Consul
« More »
KeyValueList¶
Holds result of key/value pairs query
« More »
KeyValueOptions¶
Options used to put key/value pair to Consul.
« More »
LinkedInAuth¶
Simplified factory to create an for LinkedIn.
« More »
LiveAuth¶
Simplified factory to create an for live.com Services.
« More »
LocalMap¶
Local maps can be used to share data safely in a single Vert.x instance.
<p>
By default the map allows immutable keys and values.
Custom keys and values should implement \io\vertx\jphp\core\shareddata\io.vertx.core.shareddata.Shareable interface. The map returns their copies.
<p>
This ensures there is no shared access to mutable state from different threads (e.g. different event loops) in the
Vert.x instance, and means you don't have to protect access to that state using synchronization or locks.
<p>
Since the version 3.4, this class extends the interface. However some methods are only accessible in Java.
« More »
LocalSessionStore¶
A session store which is only available on a single node.
<p>
Can be used when sticky sessions are being used.
« More »
Lock¶
An asynchronous exclusive lock which can be obtained from any node in the cluster.
<p>
When the lock is obtained, no-one else in the cluster can obtain the lock with the same name until the lock
is released.
« More »
LoggerHandler¶
A handler which logs request information to the Vert.x logger.
« More »
MailAttachment¶
Represent a mail attachment that can be used in a MailMessage.
« More »
MailchimpAuth¶
Simplified factory to create an for Mailchimp.
« More »
MailClient¶
SMTP mail client for Vert.x
<p>
A simple asynchronous API for sending mails from Vert.x applications
« More »
MailConfig¶
represents the configuration of a mail service with mail server hostname,
port, security options, login options and login/password
« More »
MailMessage¶
represent a mail message that can be sent via the MailClient
« More »
MailResult¶
Represent the result of the sendMail operation
« More »
MaintenanceOptions¶
Options used to placing a given service into "maintenance mode".
During maintenance mode, the service will be marked as unavailable
and will not be present in DNS or API queries. Maintenance mode is persistent
and will be automatically restored on agent restart.
« More »
Message¶
Represents a message that is received from the event bus in a handler.
<p>
Messages have a @see \io\vertx\jphp\core\eventbus\Message::body, which can be null, and also @see \io\vertx\jphp\core\eventbus\Message::headers, which can be empty.
<p>
If the message was sent specifying a reply handler, it can be replied to using @see \io\vertx\jphp\core\eventbus\Message::reply.
<p>
If you want to notify the sender that processing failed, then @see \io\vertx\jphp\core\eventbus\Message::fail can be called.
« More »
MessageConsumer¶
An event bus consumer object representing a stream of message to an @see \io\vertx\jphp\core\eventbus\EventBus address that can
be read from.
<p>
The @see \io\vertx\jphp\core\eventbus\EventBus::consumer or @see \io\vertx\jphp\core\eventbus\EventBus::localConsumer
creates a new consumer, the returned consumer is not yet registered against the event bus. Registration
is effective after the @see \io\vertx\jphp\core\eventbus\MessageConsumer::handler method is invoked.<p>
The consumer is unregistered from the event bus using the @see \io\vertx\jphp\core\eventbus\MessageConsumer::unregister method or by calling the
« More »
MessageProducer¶
Represents a stream of message that can be written to.
<p>
« More »
MessageSource¶
Service type for data producer. Providers are publishing data to a specific event bus address.
« More »
MetricsOptions¶
Vert.x metrics base configuration, this class can be extended by provider implementations to configure
those specific implementations.
« More »
MetricsService¶
The metrics service mainly allows to return a snapshot of measured objects.
« More »
MetricsService¶
The metrics service mainly allows to return a snapshot of measured objects.<br/>
This service is derived and adapted from <code>MetricsService</code> in the <i>vertx-dropwizard-metrics</i> module.
« More »
MicrometerMetricsOptions¶
Vert.x micrometer configuration.
<p>
It is required to set either <code>influxDbOptions</code>, <code>prometheusOptions</code> or <code>jmxMetricsOptions</code>
(or, programmatically, <code>micrometerRegistry</code>) in order to actually report metrics.
« More »
MicroProfileRBAC¶
Implementation of the Microprofile MP-JWT 1.1 RBAC based on the access token groups key.
« More »
MongoAuth¶
An extension of AuthProvider which is using as store
« More »
MongoAuthOptions¶
Options configuring Mongo authentication.
« More »
MongoClient¶
A Vert.x service used to interact with MongoDB server instances.
<p>
Some of the operations might change <i>_id</i> field of passed document.
« More »
MongoClientBulkWriteResult¶
Result propagated from mongodb driver bulk write result.
« More »
MongoClientDeleteResult¶
Result propagated from mongodb driver delete result.
« More »
MongoClientUpdateResult¶
Result propagated from mongodb driver update result.
« More »
MqttAuth¶
MQTT authentication information
« More »
MqttClientOptions¶
Represents options used by the MQTT client.
« More »
MqttConnAckMessage¶
Represents an MQTT CONNACK message
« More »
MqttEndpoint¶
Represents an MQTT endpoint for point-to-point communication with the remote MQTT client
« More »
MqttMessage¶
Represent the interface for each MQTT message
« More »
MqttPublishMessage¶
Represents an MQTT PUBLISH message
« More »
MqttServer¶
An MQTT server
<p>
You can accept incoming MQTT connection requests providing a @see \io\vertx\jphp\mqtt\MqttServer::endpointHandler. As the
requests arrive, the handler will be called with an instance of @see \io\vertx\jphp\mqtt\MqttEndpoint in order to manage the
communication with the remote MQTT client.
</p>
« More »
MqttServerOptions¶
Represents options used by the MQTT server
« More »
MqttSubAckMessage¶
Represents an MQTT SUBACK message
« More »
MqttSubscribeMessage¶
Represents an MQTT SUBSCRIBE message
« More »
MqttTopicSubscription¶
Represents a subscription to a topic
« More »
MqttUnsubscribeMessage¶
Represents an MQTT UNSUBSCRIBE message
« More »
MqttWill¶
Will information from the remote MQTT client
« More »
MultiMap¶
This class represents a MultiMap of String keys to a List of String values.
<p>
It's useful in Vert.x to represent things in Vert.x like HTTP headers and HTTP parameters which allow
multiple values for keys.
« More »
MVELTemplateEngine¶
A template engine that uses the Handlebars library.
« More »
MxRecord¶
Represent a Mail-Exchange-Record (MX) which was resolved for a domain.
« More »
MySQLClient¶
Represents an asynchronous MySQL client
« More »
NetClient¶
A TCP client.
<p>
Multiple connections to different servers can be made using the same instance.
<p>
This client supports a configurable number of connection attempts and a configurable
delay between attempts.
« More »
NetClientOptions¶
Options for configuring a @see \io\vertx\jphp\core\net\NetClient.
« More »
NetServerOptions¶
Options for configuring a @see \io\vertx\jphp\core\net\NetServer.
« More »
NetSocket¶
Represents a socket-like interface to a TCP connection on either the
client or the server side.
<p>
Instances of this class are created on the client side by an @see \io\vertx\jphp\core\net\NetClient
when a connection to a server is made, or on the server side by a @see \io\vertx\jphp\core\net\NetServer
when a server accepts a connection.
<p>
It implements both and so it can be used with
« More »
Node¶
Information about a Kafka cluster node
« More »
NodeList¶
Holds result of nodes query
« More »
NodeQueryOptions¶
Options used to requesting list of nodes
« More »
OAuth2Auth¶
Factory interface for creating OAuth2 based @see \io\vertx\jphp\ext\auth\AuthProvider instances.
« More »
OAuth2AuthHandler¶
An auth handler that provides OAuth2 Authentication support. This handler is suitable for AuthCode flows.
« More »
OAuth2ClientOptions¶
Options describing how an OAuth2 will make connections.
« More »
OAuth2RBAC¶
Functional interface that allows users to implement custom RBAC verifiers for OAuth2/OpenId Connect.
Users are to implement the <code>isAuthorized</code> method to verify authorities. For provides that do not
export the permissions/roles in the token, this interface allows you to communicate with 3rd party services
such as graph APIs to collect the required data.
The contract is that once an authority is checked for a given user, it's value is cached during the execution
of the request. If a user is stored to a persistent storage, or the token is introspected, the cache is cleared
and a new call will be handled to the implementation.
« More »
OAuth2Response¶
A response from a fetch request.
This class represents a secure response from a Oauth2 fetch call.
A fetch is a simplified HTTP response from a protected resource.
« More »
OffsetAndTimestamp¶
Represent information related to a Offset with timestamp information
« More »
OpenAPI3RouterFactory¶
Interface for OpenAPI3RouterFactory. <br/>
To add an handler, use @see \io\vertx\jphp\ext\web\api\contract\openapi3\OpenAPI3RouterFactory::addHandlerByOperationId<br/>
Usage example:
<pre>
<code>OpenAPI3RouterFactory.create(vertx, "src/resources/spec.yaml", asyncResult -> {
if (!asyncResult.succeeded()) {
// IO failure or spec invalid</code> else {
OpenAPI3RouterFactory routerFactory = asyncResult.result();
routerFactory.addHandlerByOperationId("operation_id", routingContext -> {
// Do something
}, routingContext -> {
// Do something with failure handler
});
Router router = routerFactory.getRouter();
}
});
}
</pre>
<br/>
Handlers are loaded in this order:<br/>
<ol>
<li>Body handler (Customizable with </li>
<li>Custom global handlers configurable with </li>
<li>Global security handlers defined in upper spec level</li>
<li>Operation specific security handlers</li>
<li>Generated validation handler</li>
<li>User handlers or "Not implemented" handler</li>
</ol>
« More »
OpenIDConnectAuth¶
Simplified factory to create an @see \io\vertx\jphp\ext\auth\oauth2\OAuth2Auth for OpenID Connect.
« More »
OpenOptions¶
Describes how an @see \io\vertx\jphp\core\file\AsyncFile should be opened.
« More »
OpenSSLEngineOptions¶
Configures a @see \io\vertx\jphp\core\net\TCPSSLOptions to use OpenSsl.
« More »
Option¶
Models command line options. Options are values passed to a command line interface using -x or --x. Supported
syntaxes depend on the parser.
<p/>
Short name is generally used with a single dash, while long name requires a double-dash.
« More »
ParameterTypeValidator¶
Interface for declaration of method for validate a specific parameter type.<br/>
If you want to implement your own type validator, you need only to implement
« More »
ParameterValidationRule¶
This function is an inner wrapper for ParameterTypeValidator inside ValidationHandler parameter maps. <b>Don't
instantiate this class</b>, if you want to add custom ParameterTypeValidator to a parameter use functions in
« More »
PartitionInfo¶
Information about a specific Kafka topic partition
« More »
PebbleTemplateEngine¶
A template engine that uses the Pebble library.
« More »
PemKeyCertOptions¶
Key store options configuring a list of private key and its certificate based on
<i>Privacy-enhanced Electronic Email</i> (PEM) files.
<p>
A key file must contain a <b>non encrypted</b> private key in <b>PKCS8</b> format wrapped in a PEM
block, for example:
<p>
<pre>
-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDV6zPk5WqLwS0a
...
K5xBhtm1AhdnZjx5KfW3BecE
-----END PRIVATE KEY-----
</pre><p>
Or contain a <b>non encrypted</b> private key in <b>PKCS1</b> format wrapped in a PEM
block, for example:
<p>
<pre>
-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEAlO4gbHeFb/fmbUF/tOJfNPJumJUEqgzAzx8MBXv9Acyw9IRa
...
zJ14Yd+t2fsLYVs2H0gxaA4DW6neCzgY3eKpSU0EBHUCFSXp/1+/
-----END RSA PRIVATE KEY-----
</pre><p>
A certificate file must contain an X.509 certificate wrapped in a PEM block, for example:
<p>
<pre>
-----BEGIN CERTIFICATE-----
MIIDezCCAmOgAwIBAgIEZOI/3TANBgkqhkiG9w0BAQsFADBuMRAwDgYDVQQGEwdV
...
+tmLSvYS39O2nqIzzAUfztkYnUlZmB0l/mKkVqbGJA==
-----END CERTIFICATE-----
</pre>
Keys and certificates can either be loaded by Vert.x from the filesystem:
<p>
<pre>
HttpServerOptions options = new HttpServerOptions();
options.setPemKeyCertOptions(new PemKeyCertOptions().setKeyPath("/mykey.pem").setCertPath("/mycert.pem"));
</pre>
Or directly provided as a buffer:<p>
<pre>
Buffer key = vertx.fileSystem().readFileSync("/mykey.pem");
Buffer cert = vertx.fileSystem().readFileSync("/mycert.pem");
options.setPemKeyCertOptions(new PemKeyCertOptions().setKeyValue(key).setCertValue(cert));
</pre>
Several key/certificate pairs can be used:
<p>
<pre>
HttpServerOptions options = new HttpServerOptions();
options.setPemKeyCertOptions(new PemKeyCertOptions()
.addKeyPath("/mykey1.pem").addCertPath("/mycert1.pem")
.addKeyPath("/mykey2.pem").addCertPath("/mycert2.pem"));
</pre>
« More »
PemTrustOptions¶
Certificate Authority options configuring certificates based on
<i>Privacy-enhanced Electronic Email</i> (PEM) files. The options is configured with a list of
validating certificates.
<p>
Validating certificates must contain X.509 certificates wrapped in a PEM block:<p>
<pre>
-----BEGIN CERTIFICATE-----
MIIDezCCAmOgAwIBAgIEVmLkwTANBgkqhkiG9w0BAQsFADBuMRAwDgYDVQQGEwdV
...
z5+DuODBJUQst141Jmgq8bS543IU/5apcKQeGNxEyQ==
-----END CERTIFICATE-----
</pre>
The certificates can either be loaded by Vert.x from the filesystem:
<p>
<pre>
HttpServerOptions options = new HttpServerOptions();
options.setPemTrustOptions(new PemTrustOptions().addCertPath("/cert.pem"));
</pre>
Or directly provided as a buffer:
<p>
<pre>
Buffer cert = vertx.fileSystem().readFileSync("/cert.pem");
HttpServerOptions options = new HttpServerOptions();
options.setPemTrustOptions(new PemTrustOptions().addCertValue(cert));
</pre>
« More »
PermittedOptions¶
Represents a match to allow for inbound and outbound traffic.
« More »
PermittedOptions¶
Specify a match to allow for inbound and outbound traffic using the
« More »
PfxOptions¶
Key or trust store options configuring private key and/or certificates based on PKCS#12 files.
<p>
When used as a key store, it should point to a store containing a private key and its certificate.
When used as a trust store, it should point to a store containing a list of accepted certificates.
<p>
The store can either be loaded by Vert.x from the filesystem:
<p>
<pre>
HttpServerOptions options = new HttpServerOptions();
options.setPfxKeyCertOptions(new PfxOptions().setPath("/mykeystore.p12").setPassword("foo"));
</pre>
Or directly provided as a buffer:<p>
<pre>
Buffer store = vertx.fileSystem().readFileSync("/mykeystore.p12");
options.setPfxKeyCertOptions(new PfxOptions().setValue(store).setPassword("foo"));
</pre>
« More »
PostgreSQLClient¶
Represents an PostgreSQL client
« More »
PreparedQueryDefinition¶
Defines a prepared query.
« More »
PreparedQueryExecuteOptions¶
Options used to execute prepared query
« More »
PreparedQueryExecuteResponse¶
The results of executing prepared query
« More »
Process¶
A process managed by the shell.
« More »
PrometheusScrapingHandler¶
A Vert.x Web @see \io\vertx\jphp\ext\web\Route handler for Prometheus metrics scraping.
« More »
ProxyOptions¶
Proxy options for a net client or a net client.
« More »
Pty¶
A pseudo terminal used for controlling a @see \io\vertx\jphp\ext\shell\term\Tty. This interface acts as a pseudo
terminal master, @see \io\vertx\jphp\ext\shell\term\Pty::slave returns the assocated slave pseudo terminal.
« More »
PubSecKeyOptions¶
Options describing how a Cryptographic Key.
« More »
Pump¶
Pumps data from a @see \io\vertx\jphp\core\streams\ReadStream to a @see \io\vertx\jphp\core\streams\WriteStream and performs flow control where necessary to
prevent the write stream buffer from getting overfull.
<p>
Instances of this class read items from a @see \io\vertx\jphp\core\streams\ReadStream and write them to a @see \io\vertx\jphp\core\streams\WriteStream. If data
can be read faster than it can be written this could result in the write queue of the @see \io\vertx\jphp\core\streams\WriteStream growing
without bound, eventually causing it to exhaust all available RAM.
<p>
To prevent this, after each write, instances of this class check whether the write queue of the @see \io\vertx\jphp\core\streams\WriteStream is full, and if so, the @see \io\vertx\jphp\core\streams\ReadStream is paused, and a <code>drainHandler</code> is set on the
« More »
QueueOptions¶
Aimed to specify queue consumer settings when calling @see \io\vertx\jphp\rabbitmq\RabbitMQClient::basicConsumer
« More »
RabbitMQConsumer¶
A stream of messages from a rabbitmq queue.
« More »
RabbitMQMessage¶
Represent a message received message received in a rabbitmq-queue.
« More »
RabbitMQOptions¶
RabbitMQ client options, most
« More »
ReadStream¶
Represents a stream of items that can be read from.
<p>
Any class that implements this interface can be used by a @see \io\vertx\jphp\core\streams\Pump to pump data from it
to a @see \io\vertx\jphp\core\streams\WriteStream.
<p>
<h3>Streaming mode</h3>
The stream is either in <i>flowing</i> or <i>fetch</i> mode.
<ul>
<i>Initially the stream is in <i>flowing</i> mode.</i>
<li>When the stream is in <i>flowing</i> mode, elements are delivered to the <code>handler</code>.</li>
<li>When the stream is in <i>fetch</i> mode, only the number of requested elements will be delivered to the <code>handler</code>.</li>
</ul>
The mode can be changed with the @see \io\vertx\jphp\core\streams\ReadStream::pause, @see \io\vertx\jphp\core\streams\ReadStream::resume and @see \io\vertx\jphp\core\streams\ReadStream::fetch methods:
<ul>
<li>Calling @see \io\vertx\jphp\core\streams\ReadStream::resume sets the <i>flowing</i> mode</li>
<li>Calling @see \io\vertx\jphp\core\streams\ReadStream::pause sets the <i>fetch</i> mode and resets the demand to <code>0</code></li>
<li>Calling @see \io\vertx\jphp\core\streams\ReadStream::fetch requests a specific amount of elements and adds it to the actual demand</li>
</ul>
« More »
Record¶
Describes a `service`. The record is the only piece of information shared between consumer and provider. It should
contains enough metadata to let consumer find the service they want.
« More »
RecordParser¶
A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed
size records.
<p>
Instances of this class take as input @see \io\vertx\jphp\core\buffer\Buffer instances containing raw bytes,
and output records.
<p>
For example, if I had a simple ASCII text protocol delimited by '\n' and the input was the following:
<p>
<pre>
buffer1:HELLO\nHOW ARE Y
buffer2:OU?\nI AM
buffer3: DOING OK
buffer4:\n
</pre>
Then the output would be:<p>
<pre>
buffer1:HELLO
buffer2:HOW ARE YOU?
buffer3:I AM DOING OK
</pre>
Instances of this class can be changed between delimited mode and fixed size record mode on the fly as
individual records are read, this allows you to parse protocols where, for example, the first 5 records might
all be fixed size (of potentially different sizes), followed by some delimited records, followed by more fixed
size records.
<p>
Instances of this class can't currently be used for protocols where the text is encoded with something other than
a 1-1 byte-char mapping.
<p>
Please see the documentation for more information.
« More »
RedirectAuthHandler¶
An auth handler that's used to handle auth by redirecting user to a custom login page.
« More »
RedisDataSource¶
Service type for Redis data source.
« More »
RedisOptions¶
This object controls the connection setting to the Redis Server. There is no need to specify most of the settings
since it has built the following sensible defaults:
<p>
* `encoding`: `UTF-8`
* `host`: `localhost`
* `port`: 6379
* `tcpKeepAlive`: true
* `tcpNoDelay`: true
* `binary`: false
<p>
However there are two extra properties that have no defaults since they are optional:
<p>
* `auth`
* `select`
<p>
The usage of this two extra properties is to setup required authentication and optionally the selection of the active
database at connection time. If you define this extra properties on every connection to Redis server this client
will perform the authentication handshake and database selection, however if you don't do this and call @see \io\vertx\jphp\redis\RedisClient::auth
yourself in case of connection failure the client will not be able to perform the correct authentication handshake.
« More »
RedisSentinel¶
Interface for sentinel commands
« More »
ReportingOptions¶
Reporting options:
<ul>
<li>the <code>reporters</code> is an array of reporter configurations</li>
</ul>
« More »
ReportOptions¶
Configures a reporter consisting in a name <code>to</code>, an address <code>at</code> and an optional <code>format</code>.
« More »
RequestOptions¶
Options describing how an @see \io\vertx\jphp\core\http\HttpClient will make connect to make a request.
« More »
RequestParameter¶
Request parameter holder
« More »
RequestParameters¶
Container for request parameters
« More »
ResponseContentTypeHandler¶
A handler which sets the response content type automatically according to the best <code>Accept</code> header match.
The header is set only if:
<ul>
<li>no object is stored in the routing context under the name @see \io\vertx\jphp\ext\web\handler\ResponseContentTypeHandler</li>
<li>a match is found</li>
<li>the header is not present already</li>
<li>content length header is absent or set to something different than zero</li>
</ul>
« More »
ResponsePredicate¶
A predicate on .
<p>
By default, a Vert.x Web Client request ends with an error only if something wrong happens at the network level.
In other words, a <code>404 Not Found</code> response, or a response with the wrong content type, are <em>NOT</em> considered as failures.
<p>
« More »
ResponsePredicateResult¶
Represents the outcome of a @see \io\vertx\jphp\ext\web\client\predicate\ResponsePredicate applied to an .
« More »
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.
« More »
ResultSet¶
Represents the results of a SQL query.
<p>
It contains a list for the column names of the results, and a list of <code>JsonArray</code> - one for each row of the
results.
« More »
ResultSet¶
It is like {@link com.datastax.driver.core.ResultSet}, but adapted for Vert.x.
« More »
RockerTemplateEngine¶
A template engine that uses the Rocker library.
« More »
Route¶
A route is a holder for a set of criteria which determine whether an HTTP request or failure should be routed
to a handler.
« More »
Router¶
A router receives request from an @see \io\vertx\jphp\core\http\HttpServer and routes it to the first matching
« More »
RouterFactory¶
Main interface for Design Driven Router factory
Author: Francesco Guardiani @slinkydeveloper
« More »
RoutingContext¶
Represents the context for the handling of a request in Vert.x-Web.
<p>
A new instance is created for each HTTP request that is received in the
of the router.
<p>
The same instance is passed to any matching request or failure handlers during the routing of the request or
failure.
<p>
The context provides access to the and
and allows you to maintain arbitrary data that lives for the lifetime of the context. Contexts are discarded once they
have been routed to the handler for the request.
<p>
The context also provides access to the @see \io\vertx\jphp\ext\web\Session, cookies and body for the request, given the correct handlers
in the application.
« More »
SalesforceAuth¶
Simplified factory to create an for Salesforce.
« More »
Script¶
Container for a script and its sha1 hash.
« More »
SecretOptions¶
Options describing a secret.
« More »
SelfSignedCertificate¶
A self-signed certificate helper for testing and development purposes.
<p>
While it helps for testing and development, it should never ever be used in production settings.
« More »
ServerFrame¶
Structure passed to server handler when receiving a frame. It provides a reference on the received @see \io\vertx\jphp\ext\stomp\Frame
but also on the @see \io\vertx\jphp\ext\stomp\StompServerConnection.
« More »
ServerWebSocket¶
Represents a server side WebSocket.
<p>
Instances of this class are passed into a @see \io\vertx\jphp\core\http\HttpServer::websocketHandler or provided
when a WebSocket handshake is manually @see \io\vertx\jphp\core\http\HttpServerRequest::upgradeed.
« More »
Service¶
Holds properties of service and node that its containing
« More »
ServiceDiscovery¶
Service Discovery main entry point.
<p>
The service discovery is an infrastructure that let you publish and find `services`. A `service` is a discoverable
functionality. It can be qualified by its type, metadata, and location. So a `service` can be a database, a
service proxy, a HTTP endpoint. It does not have to be a vert.x entity, but can be anything. Each service is
described by a @see \io\vertx\jphp\servicediscovery\Record.
<p>
The service discovery implements the interactions defined in the service-oriented computing. And to some extend,
also provides the dynamic service-oriented computing interaction. So, application can react to arrival and
departure of services.
<p>
A service provider can:
<p>
* publish a service record
* un-publish a published record
* update the status of a published service (down, out of service...)
<p>
A service consumer can:
<p>
* lookup for services
* bind to a selected service (it gets a @see \io\vertx\jphp\servicediscovery\ServiceReference) and use it
* release the service once the consumer is done with it
* listen for arrival, departure and modification of services.
<p>
Consumer would 1) lookup for service record matching their need, 2) retrieve the @see \io\vertx\jphp\servicediscovery\ServiceReference that give access
to the service, 3) get a service object to access the service, 4) release the service object once done.
<p>
A state above, the central piece of information shared by the providers and consumers are @see \io\vertx\jphp\servicediscovery\Record.
<p>
Providers and consumers must create their own @see \io\vertx\jphp\servicediscovery\ServiceDiscovery instance. These instances are collaborating
in background (distributed structure) to keep the set of services in sync.
« More »
ServiceDiscoveryOptions¶
Options to configure the service discovery.
« More »
ServiceEntry¶
Holds properties of service, node and related checks
« More »
ServiceEntryList¶
Holds list of services, nodes and related checks
« More »
ServiceExporter¶
The service exporter allows integrate other discovery technologies with the Vert.x service discovery. It maps
entries from another technology to a and maps to a publication in this other
technology. The exporter is one side of a service discovery bridge.
« More »
ServiceImporter¶
The service importer allows integrate other discovery technologies with the Vert.x service discovery. It maps
entries from another technology to a and maps to a publication in this other
technology. The importer is one side of a service discovery bridge.
« More »
ServiceList¶
Holds result of services query
« More »
ServiceOptions¶
Options used to register service.
« More »
ServicePublisher¶
The publisher is used by the importer to publish or unpublish records.
« More »
ServiceQueryOptions¶
Options used to requesting list of services
« More »
ServiceReference¶
Once a consumer has chosen a service, it builds a @see \io\vertx\jphp\servicediscovery\ServiceReference managing the binding with the chosen
service provider.
<p>
The reference lets the consumer:
* access the service (via a proxy or a client) with the @see \io\vertx\jphp\servicediscovery\ServiceReference::get method
* release the reference - so the binding between the consumer and the provider is removed
« More »
Session¶
Holds properties of Consul sessions
« More »
Session¶
Represents a browser session.
<p>
Sessions persist between HTTP requests for a single browser session. They are deleted when the browser is closed, or
they time-out. Session cookies are used to maintain sessions using a secure UUID.
<p>
Sessions can be used to maintain data for a browser session, e.g. a shopping basket.
<p>
The context must have first been routed to a @see \io\vertx\jphp\ext\web\handler\SessionHandler
for sessions to be available.
« More »
SessionHandler¶
A handler that maintains a @see \io\vertx\jphp\ext\web\Session for each browser
session.
<p>
It looks up the session for each request based on a session cookie which
contains a session ID. It stores the session when the response is ended in
the session store.
<p>
The session is available on the routing context with
.
<p>
The session handler requires a @see \io\vertx\jphp\ext\web\handler\CookieHandler to be on the routing
chain before it.
« More »
SessionList¶
Holds result of sessions query
« More »
SessionOptions¶
Options used to create session.
« More »
SessionStore¶
A session store is used to store sessions for an Vert.x-Web web app
« More »
SharedData¶
Shared data allows you to share data safely between different parts of your application in a safe way.
<p>
Shared data provides:
<ul>
<li>synchronous shared maps (local)</li>
<li>asynchronous maps (local or cluster-wide)</li>
<li>asynchronous locks (local or cluster-wide)</li>
<li>asynchronous counters (local or cluster-wide)</li>
</ul>
<p>
<p>
<strong>WARNING</strong>: In clustered mode, asynchronous maps/locks/counters rely on distributed data structures provided by the cluster manager.
Beware that the latency relative to asynchronous maps/locks/counters operations can be much higher in clustered than in local mode.
</p>
Please see the documentation for more information.
« More »
Shell¶
An interactive session between a consumer and a shell.
« More »
ShellServer¶
The shell server.<p/>
A shell server is associated with a collection of : the @see \io\vertx\jphp\ext\shell\ShellServer::registerTermServer
method registers a term server. Term servers life cycle are managed by this server.<p/>
When a receives an incoming connection, a instance is created and
associated with this connection.<p/>
The @see \io\vertx\jphp\ext\shell\ShellServer::createShell method can be used to create instance for testing purposes.
« More »
ShellServerOptions¶
The configurations options for the shell server.
« More »
ShellService¶
The shell service, provides a remotely accessible shell available via Telnet or SSH according to the
« More »
ShellServiceOptions¶
The configurations options for the shell service, the shell connectors can be configured
with , and .
« More »
ShiroAuth¶
Factory interface for creating Apache Shiro based @see \io\vertx\jphp\ext\auth\AuthProvider instances.
« More »
ShiroAuthOptions¶
Shiro auth configuration options, see Vert.x Auth Shiro component and/or Apache Shiro project.
« More »
ShopifyAuth¶
Simplified factory to create an for Shopify.
« More »
SocketAddress¶
The address of a socket, an inet socket address or a domain socket address.
<p/>
Use @see \io\vertx\jphp\core\net\SocketAddress::inetSocketAddress to create an inet socket address and @see \io\vertx\jphp\core\net\SocketAddress::domainSocketAddress
to create a domain socket address
« More »
SockJSHandler¶
A handler that allows you to handle SockJS connections from clients.
<p>
We currently support version 0.3.3 of the SockJS protocol, which can be found in
<a href="https://github.com/sockjs/sockjs-protocol/tree/v0.3.3">this tag:</a>
« More »
SockJSHandlerOptions¶
Options for configuring a SockJS handler
« More »
SockJSSocket¶
You interact with SockJS clients through instances of SockJS socket.
<p>
The API is very similar to @see \io\vertx\jphp\core\http\WebSocket.
It implements both and
so it can be used with
« More »
SoundcloudAuth¶
Simplified factory to create an for SoundCloud.
« More »
SQLClient¶
A common asynchronous client interface for interacting with SQL compliant database
« More »
SQLConnection¶
Represents a connection to a SQL database
« More »
SQLOperations¶
Represents a SQL query interface to a database
« More »
SQLOptions¶
Represents the options one can use to customize the unwrapped connection/statement/resultset types
« More »
SQLRowStream¶
A ReadStream of Rows from the underlying RDBMS. This class follows the ReadStream semantics and will automatically
close the underlying resources if all returned rows are returned. For cases where the results are ignored before the
full processing of the returned rows is complete the close method **MUST** be called in order to release underlying
resources.
The interface is minimal in order to support all SQL clients not just JDBC.
« More »
SrvRecord¶
Represent a Service-Record (SRV) which was resolved for a domain.
« More »
SSHTermOptions¶
The SSH term configuration options.
« More »
StaticHandler¶
A handler for serving static resources from the file system or classpath.
« More »
Status¶
Represents the outcome of a health check procedure. Each procedure produces a @see \io\vertx\jphp\ext\healthchecks\Status indicating either OK
or KO. Optionally, it can also provide additional data.
« More »
StompClient¶
Defines a STOMP client.
« More »
StompClientConnection¶
Once a connection to the STOMP server has been made, client receives a @see \io\vertx\jphp\ext\stomp\StompClientConnection, that let
send and receive STOMP frames.
« More »
StompClientOptions¶
Options used to configure a STOMP client. As a STOMP client wraps a Net client, you can also configure the
underlying NET client.
« More »
StompServer¶
Defines a STOMP server. STOMP servers delegates to a @see \io\vertx\jphp\ext\stomp\StompServerHandler that let customize the behavior of
the server. By default, it uses a handler compliant with the STOMP specification, but let you change anything.
« More »
StompServerConnection¶
Class representing a connection between a STOMP client a the server. It keeps a references on the client socket,
so let write to this socket.
« More »
StompServerHandler¶
STOMP server handler implements the behavior of the STOMP server when a specific event occurs. For instance, if
let customize the behavior when specific STOMP frames arrives or when a connection is closed. This class has been
designed to let you customize the server behavior. The default implementation is compliant with the STOMP
specification. In this default implementation, not acknowledge frames are dropped.
« More »
StompServerOptions¶
STOMP Server options. You can also configure the Net Server used by the STOMP server from these options.
« More »
StreamBase¶
Base interface for a stream.
« More »
StreamPriority¶
This class represents HTTP/2 stream priority defined in RFC 7540 clause 5.3
« More »
StripeAuth¶
Simplified factory to create an for Stripe.
« More »
TCPSSLOptions¶
Base class. TCP and SSL related options
« More »
TelnetTermOptions¶
Telnet terminal options configuration, extends @see \io\vertx\jphp\core\net\NetServerOptions.
« More »
TemplateEngine¶
A template engine uses a specific template and the data in a routing context to render a resource into a buffer.
<p>
Concrete implementations exist for several well-known template engines.
« More »
TemplateEngine¶
A template template uses a specific template and the data in a routing context to render a resource into a buffer.
<p>
Concrete implementations exist for several well-known template engines.
« More »
TemplateHandler¶
A handler which renders responses using a template engine and where the template name is selected from the URI
path.
« More »
TermServer¶
A server for terminal based applications.
« More »
TestCase¶
A test case object can be used to create a single test.
« More »
TestCaseReport¶
Report the execution of a test case.
« More »
TestCompletion¶
This object provides callback-ability for the end of a test suite, the completion <i>succeeds</i>
when all tests pass otherwise it fails.
« More »
TestContext¶
The test context is used for performing test assertions and manage the completion of the test. This context
is provided by <i>vertx-unit</i> as argument of the test case.
« More »
TestOptions¶
Test execution options:
<ul>
<li>the <code>timeout</code> in milliseconds, the default value is 2 minutes </li>
<li>the <code>useEventLoop</code></li> configures the event loop usage
<ul>
<li><code>true</code> always runs with an event loop</li>
<li><code>false</code> never runs with an event loop</li>
<li><code>null</code> uses an event loop if there is one (provided by @see \io\vertx\jphp\core\Vertx::currentContext)
otherwise run without</li>
</ul>
</li>
<li>the <code>reporters</code> is an array of reporter configurations</li>
</ul>
« More »
TestSuite¶
A named suite of test cases that are executed altogether. The suite suite is created with
the @see \io\vertx\jphp\ext\unit\TestSuite::create and the returned suite contains initially no tests.<p/>
The suite can declare a callback before the suite with @see \io\vertx\jphp\ext\unit\TestSuite::before or after
the suite with @see \io\vertx\jphp\ext\unit\TestSuite::after.<p/>
The suite can declare a callback before each test with @see \io\vertx\jphp\ext\unit\TestSuite::beforeEach or after
each test with @see \io\vertx\jphp\ext\unit\TestSuite::afterEach.<p/>
Each test case of the suite is declared by calling the @see \io\vertx\jphp\ext\unit\TestSuite::test method.
« More »
TestSuiteReport¶
The test suite reports is basically a stream of events reporting the test suite execution.
« More »
ThymeleafTemplateEngine¶
A template engine that uses the Thymeleaf library.
« More »
TimeoutHandler¶
Handler that will timeout requests if the response has not been written after a certain time.
Timeout requests will be ended with an HTTP status code `503`.
« More »
TimeoutStream¶
A timeout stream is triggered by a timer, the {@link io.vertx.core.Handler} will be call when the timer is fired,
it can be once or several times depending on the nature of the timer related to this stream. The
will be called after the timer handler has been called.
<p>
Pausing the timer inhibits the timer shots until the stream is resumed. Setting a null handler callback cancels
the timer.
« More »
TopicPartition¶
Represent information related to a partition for a topic
« More »
Tty¶
Provide interactions with the Shell TTY.
« More »
TxnError¶
Holds information describing which operations failed if the transaction was rolled back.
« More »
TxnKVOperation¶
Holds operation to apply to the key/value store inside a transaction
« More »
TxnRequest¶
Holds list of operations in transaction
« More »
TxnResponse¶
Holds results of transaction
« More »
UpdateOptions¶
Options for configuring updates.
« More »
UpdateResult¶
Represents the result of an update/insert/delete operation on the database.
<p>
The number of rows updated is available with @see \io\vertx\jphp\ext\sql\UpdateResult and any generated
keys are available with @see \io\vertx\jphp\ext\sql\UpdateResult.
« More »
User¶
Represents an authenticates User and contains operations to authorise the user.
<p>
Please consult the documentation for a detailed explanation.
« More »
UserSessionHandler¶
This handler should be used if you want to store the User object in the Session so it's available between
different requests, without you having re-authenticate each time.
It requires that the session handler is already present on previous matching routes.
It requires an Auth provider so, if the user is deserialized from a clustered session it knows which Auth provider
to associate the session with.
« More »
ValidationHandler¶
Base interface for validation.
For basic HTTP Request Validator, use @see \io\vertx\jphp\ext\web\api\validation\HTTPRequestValidationHandler
« More »
Vertx¶
The entry point into the Vert.x Core API.
<p>
You use an instance of this class for functionality including:
<ul>
<li>Creating TCP clients and servers</li>
<li>Creating HTTP clients and servers</li>
<li>Creating DNS clients</li>
<li>Creating Datagram sockets</li>
<li>Setting and cancelling periodic and one-shot timers</li>
<li>Getting a reference to the event bus API</li>
<li>Getting a reference to the file system API</li>
<li>Getting a reference to the shared data API</li>
<li>Deploying and undeploying verticles</li>
</ul>
<p>
Most functionality in Vert.x core is fairly low level.
<p>
To create an instance of this class you can use the static factory methods: @see \io\vertx\jphp\core\Vertx::vertx,
« More »
VertxContextPRNG¶
A secure non blocking random number generator isolated to the current context. The PRNG is bound to the vert.x
context and setup to close when the context shuts down.
<p>
When applicable, use of VertxContextPRNG rather than create new PRNG objects is helpful to keep the system entropy
usage to the minimum avoiding potential blocking across the application.
<p>
The use of VertxContextPRNG is particularly appropriate when multiple handlers use random numbers.
« More »
VertxInfluxDbOptions¶
Vert.x InfluxDb micrometer configuration.
« More »
VertxJmxMetricsOptions¶
Options for Prometheus metrics backend.
« More »
VertxOptions¶
Instances of this class are used to configure @see \io\vertx\jphp\core\Vertx instances.
« More »
VertxPrometheusOptions¶
Options for Prometheus metrics backend.
« More »
VirtualHostHandler¶
Handler that will filter requests based on the request Host name.
« More »
Watch¶
Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks)
which is monitored for updates. When an update is detected, an <code>Handler</code> with <code>AsyncResult</code> is invoked.
As an example, you could watch the status of health checks and notify when a check is critical.
« More »
WebClient¶
An asynchronous HTTP / HTTP/2 client called <code>WebClient</code>.
<p>
The web client makes easy to do HTTP request/response interactions with a web server, and provides advanced
features like:
<ul>
<li>Json body encoding / decoding</li>
<li>request/response pumping</li>
<li>error handling</li>
</ul>
<p>
The web client does not deprecate the , it is actually based on it and therefore inherits
its configuration and great features like pooling. The <code>HttpClient</code> should be used when fine grained control over the HTTP
requests/response is necessary.
« More »
WebClientOptions¶
Options describing how an @see \io\vertx\jphp\core\http\HttpClient will make connections.
« More »
WebSocket¶
Represents a client-side WebSocket.
« More »
WebSocketBase¶
Base WebSocket implementation.
<p>
It implements both and so it can be used with
« More »
WebSocketFrame¶
A WebSocket frame that represents either text or binary data.
<p>
A WebSocket message is composed of one or more WebSocket frames.
<p>
If there is a just a single frame in the message then a single text or binary frame should be created with final = true.
<p>
If there are more than one frames in the message, then the first frame should be a text or binary frame with
final = false, followed by one or more continuation frames. The last continuation frame should have final = true.
« More »
WorkerExecutor¶
An executor for executing blocking code in Vert.x .<p>
It provides the same <code>executeBlocking</code> operation than @see \io\vertx\jphp\core\Context and
« More »
WriteStream¶
Represents a stream of data that can be written to.
<p>
Any class that implements this interface can be used by a @see \io\vertx\jphp\core\streams\Pump to pump data from a <code>ReadStream</code>
to it.
« More »