vertx / io.vertx.reactivex.core.metrics / Measured

Measured

interface Measured

NOTE: This class has been automatically generated from the io.vertx.core.metrics.Measured non RX-ified interface using Vert.x codegen.

Functions

getDelegate

abstract fun getDelegate(): Measured

isMetricsEnabled

abstract fun isMetricsEnabled(): Boolean

Whether the metrics are enabled for this measured object

newInstance

open static fun newInstance(arg: Measured): Measured

Inheritors

DatagramSocket

open class DatagramSocket : ReadStream<DatagramPacket>, Measured

A datagram socket can be used to send io.vertx.reactivex.core.datagram.DatagramPacket's to remote datagram servers and receive io.vertx.reactivex.core.datagram.DatagramPackets .

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.

You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.

Please consult the documentation for more information on datagram sockets.

NOTE: This class has been automatically generated from the io.vertx.core.datagram.DatagramSocket non RX-ified interface using Vert.x codegen.

EventBus

open class EventBus : Measured

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.

An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.

Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.

Please refer to the documentation for more information on the event bus.

NOTE: This class has been automatically generated from the io.vertx.core.eventbus.EventBus non RX-ified interface using Vert.x codegen.

HttpClient

open class HttpClient : Measured

An asynchronous HTTP client.

It allows you to make requests to HTTP servers, and a single client can make requests to any server.

It also allows you to open WebSockets to servers.

The client can also pool HTTP connections.

For pooling to occur, keep-alive must be true on the io.vertx.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.

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.

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.

To enable pipe-lining, it must be enabled on the io.vertx.core.http.HttpClientOptions (default is false).

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.

The client is designed to be reused between requests.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpClient non RX-ified interface using Vert.x codegen.

HttpServer

open class HttpServer : Measured

An HTTP and WebSockets server.

You receive HTTP requests by providing a io.vertx.reactivex.core.http.HttpServer#requestHandler. As requests arrive on the server the handler will be called with the requests.

You receive WebSockets by providing a io.vertx.reactivex.core.http.HttpServer#websocketHandler. As WebSocket connections arrive on the server, the WebSocket is passed to the handler.

NOTE: This class has been automatically generated from the io.vertx.core.http.HttpServer non RX-ified interface using Vert.x codegen.

NetClient

open class NetClient : Measured

A TCP client.

Multiple connections to different servers can be made using the same instance.

This client supports a configurable number of connection attempts and a configurable delay between attempts.

NOTE: This class has been automatically generated from the io.vertx.core.net.NetClient non RX-ified interface using Vert.x codegen.

NetServer

open class NetServer : Measured

Represents a TCP server NOTE: This class has been automatically generated from the io.vertx.core.net.NetServer non RX-ified interface using Vert.x codegen.

Vertx

open class Vertx : Measured

The entry point into the Vert.x Core API.

You use an instance of this class for functionality including:

  • Creating TCP clients and servers
  • Creating HTTP clients and servers
  • Creating DNS clients
  • Creating Datagram sockets
  • Setting and cancelling periodic and one-shot timers
  • Getting a reference to the event bus API
  • Getting a reference to the file system API
  • Getting a reference to the shared data API
  • Deploying and undeploying verticles

Most functionality in Vert.x core is fairly low level.

To create an instance of this class you can use the static factory methods: io.vertx.reactivex.core.Vertx#vertx, io.vertx.reactivex.core.Vertx#vertx and io.vertx.reactivex.core.Vertx#clusteredVertx.

Please see the user manual for more detailed usage information.

NOTE: This class has been automatically generated from the io.vertx.core.Vertx non RX-ified interface using Vert.x codegen.

WorkerExecutor

open class WorkerExecutor : Measured

An executor for executing blocking code in Vert.x .

It provides the same executeBlocking operation than io.vertx.reactivex.core.Context and io.vertx.reactivex.core.Vertx but on a separate worker pool.

NOTE: This class has been automatically generated from the io.vertx.core.WorkerExecutor non RX-ified interface using Vert.x codegen.