io.vertx.rxjava.core.http

## Class HttpConnection

- java.lang.Object
- - io.vertx.rxjava.core.http.HttpConnection

-     public class HttpConnection
      extends Object

  Represents an HTTP connection.

  HTTP/1.x connection provides an limited implementation, the following methods are implemented:
  - `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)`
  - `closeHandler(io.vertx.core.Handler<java.lang.Void>)`
  - `exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)`

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<HttpConnection>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `HttpConnection(HttpConnection delegate)`
    `HttpConnection(Object delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` Close the connection and all the currently active streams.
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the connection and all the currently active streams.
    `HttpConnection` | `closeHandler(Handler<Void> handler)` Set a close handler.
    `boolean` | `equals(Object o)`
    `HttpConnection` | `exceptionHandler(Handler<Throwable> handler)` Set an handler called when a connection error happens
    `HttpConnection` | `getDelegate()`
    `int` | `getWindowSize()`
    `HttpConnection` | `goAway(long errorCode)` Like `goAway(long)` with a last stream id `-1` which means to disallow any new stream creation.
    `HttpConnection` | `goAway(long errorCode, int lastStreamId)` Like `goAway(long)` with no buffer.
    `HttpConnection` | `goAway(long errorCode, int lastStreamId, Buffer debugData)` Send a go away frame to the remote endpoint of the connection.
    `HttpConnection` | `goAwayHandler(Handler<GoAway> handler)` Set an handler called when a frame is received.
    `int` | `hashCode()`
    `String` | `indicatedServerName()` Returns the SNI server name presented during the SSL handshake by the client.
    `boolean` | `isSsl()`
    `SocketAddress` | `localAddress()`
    `static HttpConnection` | `newInstance(HttpConnection arg)`
    `HttpConnection` | `ping(Buffer data)` Send a frame to the remote endpoint.
    `HttpConnection` | `ping(Buffer data, Handler<AsyncResult<Buffer>> pongHandler)` Send a frame to the remote endpoint.
    `HttpConnection` | `pingHandler(Handler<Buffer> handler)` Set an handler notified when a frame is received from the remote endpoint.
    `SocketAddress` | `remoteAddress()`
    `Http2Settings` | `remoteSettings()`
    `HttpConnection` | `remoteSettingsHandler(Handler<Http2Settings> handler)` Set an handler that is called when remote endpoint `Http2Settings` are updated.
    `Single<Void>` | `rxClose()` Close the connection and all the currently active streams.
    `Single<Buffer>` | `rxPing(Buffer data)` Send a frame to the remote endpoint.
    `Single<Void>` | `rxShutdown()` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed.
    `Single<Void>` | `rxShutdown(long timeout)` Like `shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
    `Single<Void>` | `rxUpdateSettings(Http2Settings settings)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `Http2Settings` | `settings()`
    `HttpConnection` | `setWindowSize(int windowSize)` Update the current connection wide window size to a new size.
    `void` | `shutdown()` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed.
    `void` | `shutdown(Handler<AsyncResult<Void>> handler)` Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed.
    `void` | `shutdown(long timeout)` Like `shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
    `void` | `shutdown(long timeout, Handler<AsyncResult<Void>> handler)` Like `shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
    `HttpConnection` | `shutdownHandler(Handler<Void> handler)` Set an handler called when a frame has been sent or received and all connections are closed.
    `SSLSession` | `sslSession()`
    `String` | `toString()`
    `HttpConnection` | `updateSettings(Http2Settings settings)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.
    `HttpConnection` | `updateSettings(Http2Settings settings, Handler<AsyncResult<Void>> completionHandler)` Send to the remote endpoint an update of this endpoint settings The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<HttpConnection> __TYPE_ARG

  - ### Constructor Detail

    - #### HttpConnection

          public HttpConnection(HttpConnection delegate)

    - #### HttpConnection

          public HttpConnection(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public HttpConnection getDelegate()

    - #### getWindowSize

          public int getWindowSize()

      Returns:
        the current connection window size or `-1` for HTTP/1.x

    - #### setWindowSize

          public HttpConnection setWindowSize(int windowSize)

      Update the current connection wide window size to a new size.

      Increasing this value, gives better performance when several data streams are multiplexed

      This is not implemented for HTTP/1.x.
      Parameters:
        `windowSize` - the new window size
      Returns:
        a reference to this, so the API can be used fluently

    - #### goAway

          public HttpConnection goAway(long errorCode)

      Like `goAway(long)` with a last stream id `-1` which means to disallow any new stream creation.
      Parameters:
        `errorCode` -
      Returns:

    - #### goAway

          public HttpConnection goAway(long errorCode,
                                       int lastStreamId)

      Like `goAway(long)` with no buffer.
      Parameters:
        `errorCode` -
        `lastStreamId` -
      Returns:

    - #### goAway

          public HttpConnection goAway(long errorCode,
                                       int lastStreamId,
                                       Buffer debugData)

      Send a go away frame to the remote endpoint of the connection.

      - a frame is sent to the to the remote endpoint with the `errorCode` and `debugData`
      - any stream created after the stream identified by `lastStreamId` will be closed
      - for an is different than `0` when all the remaining streams are closed this connection will be closed automatically

      This is not implemented for HTTP/1.x.
      Parameters:
        `errorCode` - the error code
        `lastStreamId` - the last stream id
        `debugData` - additional debug data sent to the remote endpoint
      Returns:
        a reference to this, so the API can be used fluently

    - #### goAwayHandler

          public HttpConnection goAwayHandler(Handler<GoAway> handler)

      Set an handler called when a frame is received.

      This is not implemented for HTTP/1.x.
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### shutdownHandler

          public HttpConnection shutdownHandler(Handler<Void> handler)

      Set an handler called when a frame has been sent or received and all connections are closed.

      This is not implemented for HTTP/1.x.
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### shutdown

          public void shutdown(Handler<AsyncResult<Void>> handler)

      Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed. Client connection are immediately removed from the pool.
      - HTTP/2 connections will send a go away frame immediately to signal the other side the connection will close
      - HTTP/1.x client connection supports this feature
      - HTTP/1.x server connections do not support this feature
      Parameters:
        `handler` - the handler called when shutdown has completed

    - #### shutdown

          public void shutdown()

      Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed. Client connection are immediately removed from the pool.
      - HTTP/2 connections will send a go away frame immediately to signal the other side the connection will close
      - HTTP/1.x client connection supports this feature
      - HTTP/1.x server connections do not support this feature

    - #### rxShutdown

          public Single<Void> rxShutdown()

      Initiate a graceful connection shutdown, the connection is taken out of service and closed when all current requests are processed, otherwise after 30 seconds the connection will be closed. Client connection are immediately removed from the pool.
      - HTTP/2 connections will send a go away frame immediately to signal the other side the connection will close
      - HTTP/1.x client connection supports this feature
      - HTTP/1.x server connections do not support this feature
      Returns:

    - #### shutdown

          public void shutdown(long timeout,
                               Handler<AsyncResult<Void>> handler)

      Like `shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
      Parameters:
        `timeout` -
        `handler` -

    - #### shutdown

          public void shutdown(long timeout)

      Like `shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
      Parameters:
        `timeout` -

    - #### rxShutdown

          public Single<Void> rxShutdown(long timeout)

      Like `shutdown(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but with a specific `timeout` in milliseconds.
      Parameters:
        `timeout` -
      Returns:

    - #### closeHandler

          public HttpConnection closeHandler(Handler<Void> handler)

      Set a close handler. The handler will get notified when the connection is closed.
      Parameters:
        `handler` - the handler to be notified
      Returns:
        a reference to this, so the API can be used fluently

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Close the connection and all the currently active streams.

      An HTTP/2 connection will send a frame before.
      Parameters:
        `handler` - the handler to be completed when the connection is closed

    - #### close

          public void close()

      Close the connection and all the currently active streams.

      An HTTP/2 connection will send a frame before.

    - #### rxClose

          public Single<Void> rxClose()

      Close the connection and all the currently active streams.

      An HTTP/2 connection will send a frame before.
      Returns:

    - #### settings

          public Http2Settings settings()

      Returns:
        the latest server settings acknowledged by the remote endpoint - this is not implemented for HTTP/1.x

    - #### updateSettings

          public HttpConnection updateSettings(Http2Settings settings,
                                               Handler<AsyncResult<Void>> completionHandler)

      Send to the remote endpoint an update of this endpoint settings

      The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.

      This is not implemented for HTTP/1.x.
      Parameters:
        `settings` - the new settings
        `completionHandler` - the handler notified when the settings have been acknowledged by the remote endpoint
      Returns:
        a reference to this, so the API can be used fluently

    - #### updateSettings

          public HttpConnection updateSettings(Http2Settings settings)

      Send to the remote endpoint an update of this endpoint settings

      The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.

      This is not implemented for HTTP/1.x.
      Parameters:
        `settings` - the new settings
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxUpdateSettings

          public Single<Void> rxUpdateSettings(Http2Settings settings)

      Send to the remote endpoint an update of this endpoint settings

      The `completionHandler` will be notified when the remote endpoint has acknowledged the settings.

      This is not implemented for HTTP/1.x.
      Parameters:
        `settings` - the new settings
      Returns:
        a reference to this, so the API can be used fluently

    - #### remoteSettings

          public Http2Settings remoteSettings()

      Returns:
        the current remote endpoint settings for this connection - this is not implemented for HTTP/1.x

    - #### remoteSettingsHandler

          public HttpConnection remoteSettingsHandler(Handler<Http2Settings> handler)

      Set an handler that is called when remote endpoint `Http2Settings` are updated.

      This is not implemented for HTTP/1.x.
      Parameters:
        `handler` - the handler for remote endpoint settings
      Returns:
        a reference to this, so the API can be used fluently

    - #### ping

          public HttpConnection ping(Buffer data,
                                     Handler<AsyncResult<Buffer>> pongHandler)

      Send a frame to the remote endpoint.

      This is not implemented for HTTP/1.x.
      Parameters:
        `data` - the 8 bytes data of the frame
        `pongHandler` - an async result handler notified with pong reply or the failure
      Returns:
        a reference to this, so the API can be used fluently

    - #### ping

          public HttpConnection ping(Buffer data)

      Send a frame to the remote endpoint.

      This is not implemented for HTTP/1.x.
      Parameters:
        `data` - the 8 bytes data of the frame
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxPing

          public Single<Buffer> rxPing(Buffer data)

      Send a frame to the remote endpoint.

      This is not implemented for HTTP/1.x.
      Parameters:
        `data` - the 8 bytes data of the frame
      Returns:
        a reference to this, so the API can be used fluently

    - #### pingHandler

          public HttpConnection pingHandler(Handler<Buffer> handler)

      Set an handler notified when a frame is received from the remote endpoint.

      This is not implemented for HTTP/1.x.
      Parameters:
        `handler` - the handler to be called when a is received
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          public HttpConnection exceptionHandler(Handler<Throwable> handler)

      Set an handler called when a connection error happens
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### remoteAddress

          public SocketAddress remoteAddress()

      Returns:
        the remote address for this connection, possibly `null` (e.g a server bound on a domain socket). If `useProxyProtocol` is set to `true`, the address returned will be of the actual connecting client.

    - #### localAddress

          public SocketAddress localAddress()

      Returns:
        the local address for this connection, possibly `null` (e.g a server bound on a domain socket) If `useProxyProtocol` is set to `true`, the address returned will be of the proxy.

    - #### isSsl

          public boolean isSsl()

      Returns:
        true if this `HttpConnection` is encrypted via SSL/TLS.

    - #### indicatedServerName

          public String indicatedServerName()

      Returns the SNI server name presented during the SSL handshake by the client.
      Returns:
        the indicated server name

    - #### sslSession

          public SSLSession sslSession()

      Returns:
        SSLSession associated with the underlying socket. Returns null if connection is not SSL.

    - #### newInstance

          public static HttpConnection newInstance(HttpConnection arg)

Copyright © 2021 Eclipse. All rights reserved.