Package io.vertx.core.http

## Class HttpServerOptions

- java.lang.Object
- - io.vertx.core.net.NetworkOptions
  - - io.vertx.core.net.TCPSSLOptions
    - - io.vertx.core.net.NetServerOptions
      - - io.vertx.core.http.HttpServerOptions

- Direct Known Subclasses:
    `HttpTermOptions`

      public class HttpServerOptions
      extends NetServerOptions

  Represents options used by an `HttpServer` instance
  Author:
    Tim Fox

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static boolean` | `DEFAULT_ACCEPT_UNMASKED_FRAMES` | Default WebSocket Masked bit is true as depicted by RFC = `false`
    `static List<HttpVersion>` | `DEFAULT_ALPN_VERSIONS` | Default Application-Layer Protocol Negotiation versions = [HTTP/2,HTTP/1.1]
    `static int` | `DEFAULT_COMPRESSION_CONTENT_SIZE_THRESHOLD` | Default content size threshold for compression = 0 (Netty default)
    `static int` | `DEFAULT_COMPRESSION_LEVEL` | Default gzip/deflate compression level = 6 (Netty legacy)
    `static boolean` | `DEFAULT_COMPRESSION_SUPPORTED` | Default value of whether compression is supported = `false`
    `static int` | `DEFAULT_DECODER_INITIAL_BUFFER_SIZE` | Default initial buffer size for HttpObjectDecoder = 128 bytes
    `static boolean` | `DEFAULT_DECOMPRESSION_SUPPORTED` | Default value of whether decompression is supported = `false`
    `static boolean` | `DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY` | Default value of whether 100-Continue should be handled automatically = `false`
    `static boolean` | `DEFAULT_HTTP2_CLEAR_TEXT_ENABLED` | Default H2C is enabled = `true`
    `static int` | `DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE` | The default HTTP/2 connection window size = -1
    `static int` | `DEFAULT_HTTP2_RST_FLOOD_MAX_RST_FRAME_PER_WINDOW` | HTTP/2 RST floods DDOS protection, max number of RST frame per time window allowed = 200.
    `static int` | `DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION` | HTTP/2 RST floods DDOS protection, time window duration = 30.
    `static TimeUnit` | `DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION_TIME_UNIT` | HTTP/2 RST floods DDOS protection, time window duration unit = `TimeUnit.SECONDS`.
    `static long` | `DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS` | The default initial settings max concurrent stream for an HTTP/2 server = 100
    `static int` | `DEFAULT_MAX_CHUNK_SIZE` | Default max HTTP chunk size = 8192
    `static int` | `DEFAULT_MAX_FORM_ATTRIBUTE_SIZE` | Default max size of a form attribute = 8192
    `static int` | `DEFAULT_MAX_FORM_BUFFERED_SIZE` | Default max number buffered bytes when decoding a form = 1024
    `static int` | `DEFAULT_MAX_FORM_FIELDS` | Default max number of form fields = 256
    `static int` | `DEFAULT_MAX_HEADER_SIZE` | Default max length of all headers = 8192
    `static int` | `DEFAULT_MAX_INITIAL_LINE_LENGTH` | Default max length of the initial line (e.g.
    `static int` | `DEFAULT_MAX_WEBSOCKET_FRAME_SIZE` | Default max WebSocket frame size = 65536
    `static int` | `DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE` | Default max WebSocket message size (could be assembled from multiple frames) is 4 full frames worth of data
    `static boolean` | `DEFAULT_PER_FRAME_WEBSOCKET_COMPRESSION_SUPPORTED` | Default support for WebSockets per-frame deflate compression extension = `true`
    `static boolean` | `DEFAULT_PER_MESSAGE_WEBSOCKET_COMPRESSION_SUPPORTED` | Default support for WebSockets per-message deflate compression extension = `true`
    `static int` | `DEFAULT_PORT` | Default port the server will listen on = 80
    `static boolean` | `DEFAULT_REGISTER_WEBSOCKET_WRITE_HANDLERS` | Whether write-handlers for server websockets should be registered by default = false.
    `static TracingPolicy` | `DEFAULT_TRACING_POLICY` | Default tracing control = `TracingPolicy.ALWAYS`
    `static boolean` | `DEFAULT_WEBSOCKET_ALLOW_SERVER_NO_CONTEXT` | Default allowance of the `server_no_context_takeover` WebSocket parameter deflate compression extension = `false`
    `static int` | `DEFAULT_WEBSOCKET_CLOSING_TIMEOUT` | Default WebSocket closing timeout = 10 second)
    `static int` | `DEFAULT_WEBSOCKET_COMPRESSION_LEVEL` | Default WebSocket deflate compression level = 6
    `static boolean` | `DEFAULT_WEBSOCKET_PREFERRED_CLIENT_NO_CONTEXT` | Default allowance of the `client_no_context_takeover` WebSocket parameter deflate compression extension = `false`

    - ### Fields inherited from class io.vertx.core.net.NetServerOptions

      `DEFAULT_ACCEPT_BACKLOG, DEFAULT_HOST, DEFAULT_PROXY_PROTOCOL_TIMEOUT, DEFAULT_PROXY_PROTOCOL_TIMEOUT_TIME_UNIT, DEFAULT_REGISTER_WRITE_HANDLER, DEFAULT_USE_PROXY_PROTOCOL`

    - ### Fields inherited from class io.vertx.core.net.TCPSSLOptions

      `DEFAULT_IDLE_TIMEOUT, DEFAULT_IDLE_TIMEOUT_TIME_UNIT, DEFAULT_READ_IDLE_TIMEOUT, DEFAULT_SO_LINGER, DEFAULT_SSL, DEFAULT_SSL_ENGINE, DEFAULT_TCP_CORK, DEFAULT_TCP_FAST_OPEN, DEFAULT_TCP_KEEP_ALIVE, DEFAULT_TCP_NO_DELAY, DEFAULT_TCP_QUICKACK, DEFAULT_TCP_USER_TIMEOUT, DEFAULT_WRITE_IDLE_TIMEOUT`

    - ### Fields inherited from class io.vertx.core.net.NetworkOptions

      `DEFAULT_LOG_ACTIVITY_FORMAT, DEFAULT_LOG_ENABLED, DEFAULT_RECEIVE_BUFFER_SIZE, DEFAULT_REUSE_ADDRESS, DEFAULT_REUSE_PORT, DEFAULT_SEND_BUFFER_SIZE, DEFAULT_TRAFFIC_CLASS`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `HttpServerOptions()` | Default constructor
    `HttpServerOptions​(HttpServerOptions other)` | Copy constructor
    `HttpServerOptions​(JsonObject json)` | Create an options from JSON

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `HttpServerOptions` | `addCompressor​(CompressionOptions compressor)` | Add a compressor.
    `HttpServerOptions` | `addCrlPath​(String crlPath)` | Add a CRL path
    `HttpServerOptions` | `addCrlValue​(Buffer crlValue)` | Add a CRL value
    `HttpServerOptions` | `addEnabledCipherSuite​(String suite)` | Add an enabled cipher suite, appended to the ordered suites.
    `HttpServerOptions` | `addEnabledSecureTransportProtocol​(String protocol)` | Add an enabled SSL/TLS protocols, appended to the ordered protocols.
    `HttpServerOptions` | `addWebSocketSubProtocol​(String subProtocol)` | Add a WebSocket sub-protocol to the list supported by the server.
    `HttpServerOptions` | `copy()` | Copy these options.
    `List<HttpVersion>` | `getAlpnVersions()` |
    `int` | `getCompressionContentSizeThreshold()` |
    `int` | `getCompressionLevel()` |
    `List<CompressionOptions>` | `getCompressors()` |
    `int` | `getDecoderInitialBufferSize()` |
    `int` | `getHttp2ConnectionWindowSize()` |
    `int` | `getHttp2RstFloodMaxRstFramePerWindow()` |
    `int` | `getHttp2RstFloodWindowDuration()` |
    `TimeUnit` | `getHttp2RstFloodWindowDurationTimeUnit()` |
    `Http2Settings` | `getInitialSettings()` |
    `int` | `getMaxChunkSize()` |
    `int` | `getMaxFormAttributeSize()` |
    `int` | `getMaxFormBufferedBytes()` |
    `int` | `getMaxFormFields()` |
    `int` | `getMaxHeaderSize()` |
    `int` | `getMaxInitialLineLength()` |
    `int` | `getMaxWebSocketFrameSize()` |
    `int` | `getMaxWebSocketMessageSize()` |
    `boolean` | `getPerFrameWebSocketCompressionSupported()` | Get whether WebSocket the per-frame deflate compression extension is supported.
    `boolean` | `getPerMessageWebSocketCompressionSupported()` | Get whether WebSocket per-message deflate compression extension is supported.
    `TracingPolicy` | `getTracingPolicy()` |
    `boolean` | `getWebSocketAllowServerNoContext()` |
    `int` | `getWebSocketClosingTimeout()` |
    `int` | `getWebSocketCompressionLevel()` |
    `boolean` | `getWebSocketPreferredClientNoContext()` |
    `List<String>` | `getWebSocketSubProtocols()` |
    `boolean` | `isAcceptUnmaskedFrames()` |
    `boolean` | `isCompressionSupported()` |
    `boolean` | `isDecompressionSupported()` |
    `boolean` | `isFileRegionEnabled()` |
    `boolean` | `isHandle100ContinueAutomatically()` |
    `boolean` | `isHttp2ClearTextEnabled()` |
    `boolean` | `isRegisterWebSocketWriteHandlers()` |
    `boolean` | `isRegisterWriteHandler()` |
    `HttpServerOptions` | `removeEnabledCipherSuite​(String suite)` | Removes an enabled cipher suite from the ordered suites.
    `HttpServerOptions` | `removeEnabledSecureTransportProtocol​(String protocol)` | Removes an enabled SSL/TLS protocol from the ordered protocols.
    `HttpServerOptions` | `setAcceptBacklog​(int acceptBacklog)` | Set the accept back log
    `HttpServerOptions` | `setAcceptUnmaskedFrames​(boolean acceptUnmaskedFrames)` | Set `true` when the server accepts unmasked frame.
    `HttpServerOptions` | `setActivityLogDataFormat​(ByteBufFormat activityLogDataFormat)` | Set the value of Netty's logging handler's data format: Netty's pipeline is configured for logging on Netty's logger.
    `HttpServerOptions` | `setAlpnVersions​(List<HttpVersion> alpnVersions)` | Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiatiation.
    `HttpServerOptions` | `setClientAuth​(ClientAuth clientAuth)` | Set whether client auth is required
    `HttpServerOptions` | `setCompressionContentSizeThreshold​(int compressionContentSizeThreshold)` | Set the compression content size threshold if compression is enabled.
    `HttpServerOptions` | `setCompressionLevel​(int compressionLevel)` | This method allows to set the compression level to be used in http1.x/2 response bodies when compression support is turned on (@see setCompressionSupported) and the client advertises to support `deflate/gzip` compression in the `Accept-Encoding` header default value is : 6 (Netty legacy) The compression level determines how much the data is compressed on a scale from 1 to 9, where '9' is trying to achieve the maximum compression ratio while '1' instead is giving priority to speed instead of compression ratio using some algorithm optimizations and skipping pedantic loops that usually gives just little improvements While one can think that best value is always the maximum compression ratio, there's a trade-off to consider: the most compressed level requires the most computational work to compress/decompress data, e.g.
    `HttpServerOptions` | `setCompressionSupported​(boolean compressionSupported)` | Set whether the server should support gzip/deflate compression (serving compressed responses to clients advertising support for them with Accept-Encoding header)
    `HttpServerOptions` | `setCompressors​(List<CompressionOptions> compressors)` | Set the list of compressor to use instead of using the default gzip/deflate `setCompressionLevel(int)` configuration.
    `HttpServerOptions` | `setDecoderInitialBufferSize​(int decoderInitialBufferSize)` | Set the initial buffer size for the HTTP decoder
    `HttpServerOptions` | `setDecompressionSupported​(boolean decompressionSupported)` | Set whether the server supports decompression
    `HttpServerOptions` | `setEnabledSecureTransportProtocols​(Set<String> enabledSecureTransportProtocols)` | Sets the list of enabled SSL/TLS protocols.
    `HttpServerOptions` | `setHandle100ContinueAutomatically​(boolean handle100ContinueAutomatically)` | Set whether 100 Continue should be handled automatically
    `HttpServerOptions` | `setHost​(String host)` | Set the host
    `HttpServerOptions` | `setHttp2ClearTextEnabled​(boolean http2ClearTextEnabled)` | Set whether HTTP/2 over clear text is enabled or disabled, default is enabled.
    `HttpServerOptions` | `setHttp2ConnectionWindowSize​(int http2ConnectionWindowSize)` | Set the default HTTP/2 connection window size.
    `HttpServerOptions` | `setHttp2RstFloodMaxRstFramePerWindow​(int http2RstFloodMaxRstFramePerWindow)` | Set the max number of RST frame allowed per time window, this is used to prevent HTTP/2 RST frame flood DDOS attacks.
    `HttpServerOptions` | `setHttp2RstFloodWindowDuration​(int http2RstFloodWindowDuration)` | Set the duration of the time window when checking the max number of RST frames, this is used to prevent HTTP/2 RST frame flood DDOS attacks.
    `HttpServerOptions` | `setHttp2RstFloodWindowDurationTimeUnit​(TimeUnit http2RstFloodWindowDurationTimeUnit)` | Set the time unit of the duration of the time window when checking the max number of RST frames, this is used to prevent HTTP/2 RST frame flood DDOS attacks.
    `HttpServerOptions` | `setIdleTimeout​(int idleTimeout)` | Set the idle timeout, default time unit is seconds.
    `HttpServerOptions` | `setIdleTimeoutUnit​(TimeUnit idleTimeoutUnit)` | Set the idle timeout unit.
    `HttpServerOptions` | `setInitialSettings​(Http2Settings settings)` | Set the HTTP/2 connection settings immediatly sent by the server when a client connects.
    `HttpServerOptions` | `setKeyCertOptions​(KeyCertOptions options)` | Set the key/cert options.
    `HttpServerOptions` | `setLogActivity​(boolean logEnabled)` | Set to true to enabled network activity logging: Netty's pipeline is configured for logging on Netty's logger.
    `HttpServerOptions` | `setMaxChunkSize​(int maxChunkSize)` | Set the maximum HTTP chunk size that `HttpServerRequest.handler(Handler)` will receive
    `HttpServerOptions` | `setMaxFormAttributeSize​(int maxSize)` | Set the maximum size of a form attribute.
    `HttpServerOptions` | `setMaxFormBufferedBytes​(int maxFormBufferedBytes)` | Set the maximum number of bytes a server can buffer when decoding a form.
    `HttpServerOptions` | `setMaxFormFields​(int maxFormFields)` | Set the maximum number of fields of a form.
    `HttpServerOptions` | `setMaxHeaderSize​(int maxHeaderSize)` | Set the maximum length of all headers for HTTP/1.x .
    `HttpServerOptions` | `setMaxInitialLineLength​(int maxInitialLineLength)` | Set the maximum length of the initial line for HTTP/1.x (e.g.
    `HttpServerOptions` | `setMaxWebSocketFrameSize​(int maxWebSocketFrameSize)` | Set the maximum WebSocket frames size
    `HttpServerOptions` | `setMaxWebSocketMessageSize​(int maxWebSocketMessageSize)` | Set the maximum WebSocket message size
    `HttpServerOptions` | `setPerFrameWebSocketCompressionSupported​(boolean supported)` | Enable or disable support for the WebSocket per-frame deflate compression extension.
    `HttpServerOptions` | `setPerMessageWebSocketCompressionSupported​(boolean supported)` | Enable or disable support for WebSocket per-message deflate compression extension.
    `HttpServerOptions` | `setPort​(int port)` | Set the port
    `HttpServerOptions` | `setProxyProtocolTimeout​(long proxyProtocolTimeout)` | Set the Proxy protocol timeout, default time unit is seconds.
    `HttpServerOptions` | `setProxyProtocolTimeoutUnit​(TimeUnit proxyProtocolTimeoutUnit)` | Set the Proxy protocol timeout unit.
    `HttpServerOptions` | `setReadIdleTimeout​(int idleTimeout)` | Set the read idle timeout, default time unit is seconds.
    `HttpServerOptions` | `setReceiveBufferSize​(int receiveBufferSize)` | Set the TCP receive buffer size
    `HttpServerOptions` | `setRegisterWebSocketWriteHandlers​(boolean registerWebSocketWriteHandlers)` | Whether write-handlers for server websockets should be registered on the `EventBus`.
    `HttpServerOptions` | `setRegisterWriteHandler​(boolean registerWriteHandler)` | Has no effect on HTTP server options.
    `HttpServerOptions` | `setReuseAddress​(boolean reuseAddress)` | Set the value of reuse address
    `HttpServerOptions` | `setReusePort​(boolean reusePort)` | Set the value of reuse port.
    `HttpServerOptions` | `setSendBufferSize​(int sendBufferSize)` | Set the TCP send buffer size
    `HttpServerOptions` | `setSni​(boolean sni)` | Set whether the server supports Server Name Indiciation
    `HttpServerOptions` | `setSoLinger​(int soLinger)` | Set whether SO_linger keep alive is enabled
    `HttpServerOptions` | `setSsl​(boolean ssl)` | Set whether SSL/TLS is enabled
    `HttpServerOptions` | `setSslEngineOptions​(SSLEngineOptions sslEngineOptions)` | Set to use SSL engine implementation to use.
    `HttpServerOptions` | `setSslHandshakeTimeout​(long sslHandshakeTimeout)` | Set the SSL handshake timeout, default time unit is seconds.
    `HttpServerOptions` | `setSslHandshakeTimeoutUnit​(TimeUnit sslHandshakeTimeoutUnit)` | Set the SSL handshake timeout unit.
    `HttpServerOptions` | `setTcpCork​(boolean tcpCork)` | Enable the `TCP_CORK` option - only with linux native transport.
    `HttpServerOptions` | `setTcpFastOpen​(boolean tcpFastOpen)` | Enable the `TCP_FASTOPEN` option - only with linux native transport.
    `HttpServerOptions` | `setTcpKeepAlive​(boolean tcpKeepAlive)` | Set whether TCP keep alive is enabled
    `HttpServerOptions` | `setTcpNoDelay​(boolean tcpNoDelay)` | Set whether TCP no delay is enabled
    `HttpServerOptions` | `setTcpQuickAck​(boolean tcpQuickAck)` | Enable the `TCP_QUICKACK` option - only with linux native transport.
    `HttpServerOptions` | `setTracingPolicy​(TracingPolicy tracingPolicy)` | Set the tracing policy for the server behavior when Vert.x has tracing enabled.
    `HttpServerOptions` | `setTrafficClass​(int trafficClass)` | Set the value of traffic class
    `HttpServerOptions` | `setTrafficShapingOptions​(TrafficShapingOptions trafficShapingOptions)` | Set traffic shaping options.
    `HttpServerOptions` | `setTrustOptions​(TrustOptions options)` | Set the trust options.
    `HttpServerOptions` | `setUseAlpn​(boolean useAlpn)` | Set the ALPN usage.
    `HttpServerOptions` | `setUseProxyProtocol​(boolean useProxyProtocol)` | Set whether the server uses the HA Proxy protocol
    `HttpServerOptions` | `setWebSocketAllowServerNoContext​(boolean accept)` | Set whether the WebSocket server will accept the `server_no_context_takeover` parameter of the per-message deflate compression extension offered by the client.
    `HttpServerOptions` | `setWebSocketClosingTimeout​(int webSocketClosingTimeout)` | Set the amount of time a server WebSocket will wait until it closes the TCP connection after sending a close frame.
    `HttpServerOptions` | `setWebSocketCompressionLevel​(int compressionLevel)` | Set the WebSocket compression level.
    `HttpServerOptions` | `setWebSocketPreferredClientNoContext​(boolean accept)` | Set whether the WebSocket server will accept the `client_no_context_takeover` parameter of the per-message deflate compression extension offered by the client.
    `HttpServerOptions` | `setWebSocketSubProtocols​(List<String> subProtocols)` | Set the WebSocket list of sub-protocol supported by the server.
    `HttpServerOptions` | `setWriteIdleTimeout​(int idleTimeout)` | Set the write idle timeout, default time unit is seconds.
    `JsonObject` | `toJson()` | Convert to JSON

    - ### Methods inherited from class io.vertx.core.net.NetServerOptions

      `getAcceptBacklog, getClientAuth, getHost, getOrCreateSSLOptions, getPort, getProxyProtocolTimeout, getProxyProtocolTimeoutUnit, getSslOptions, getTrafficShapingOptions, isSni, isUseProxyProtocol`

    - ### Methods inherited from class io.vertx.core.net.TCPSSLOptions

      `getCrlPaths, getCrlValues, getEnabledCipherSuites, getEnabledSecureTransportProtocols, getIdleTimeout, getIdleTimeoutUnit, getKeyCertOptions, getReadIdleTimeout, getSoLinger, getSslEngineOptions, getSslHandshakeTimeout, getSslHandshakeTimeoutUnit, getTcpUserTimeout, getTrustOptions, getWriteIdleTimeout, isSsl, isTcpCork, isTcpFastOpen, isTcpKeepAlive, isTcpNoDelay, isTcpQuickAck, isUseAlpn, setTcpUserTimeout`

    - ### Methods inherited from class io.vertx.core.net.NetworkOptions

      `getActivityLogDataFormat, getLogActivity, getReceiveBufferSize, getSendBufferSize, getTrafficClass, isReuseAddress, isReusePort`

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### DEFAULT_PORT

          public static final int DEFAULT_PORT

      Default port the server will listen on = 80
      See Also:
        Constant Field Values

    - #### DEFAULT_COMPRESSION_SUPPORTED

          public static final boolean DEFAULT_COMPRESSION_SUPPORTED

      Default value of whether compression is supported = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_COMPRESSION_LEVEL

          public static final int DEFAULT_COMPRESSION_LEVEL

      Default gzip/deflate compression level = 6 (Netty legacy)
      See Also:
        Constant Field Values

    - #### DEFAULT_COMPRESSION_CONTENT_SIZE_THRESHOLD

          public static final int DEFAULT_COMPRESSION_CONTENT_SIZE_THRESHOLD

      Default content size threshold for compression = 0 (Netty default)
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

          public static final int DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

      Default max WebSocket frame size = 65536
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE

          public static final int DEFAULT_MAX_WEBSOCKET_MESSAGE_SIZE

      Default max WebSocket message size (could be assembled from multiple frames) is 4 full frames worth of data
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_CHUNK_SIZE

          public static final int DEFAULT_MAX_CHUNK_SIZE

      Default max HTTP chunk size = 8192
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_INITIAL_LINE_LENGTH

          public static final int DEFAULT_MAX_INITIAL_LINE_LENGTH

      Default max length of the initial line (e.g. `"GET / HTTP/1.0"`) = 4096
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_HEADER_SIZE

          public static final int DEFAULT_MAX_HEADER_SIZE

      Default max length of all headers = 8192
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_FORM_ATTRIBUTE_SIZE

          public static final int DEFAULT_MAX_FORM_ATTRIBUTE_SIZE

      Default max size of a form attribute = 8192
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_FORM_FIELDS

          public static final int DEFAULT_MAX_FORM_FIELDS

      Default max number of form fields = 256
      See Also:
        Constant Field Values

    - #### DEFAULT_MAX_FORM_BUFFERED_SIZE

          public static final int DEFAULT_MAX_FORM_BUFFERED_SIZE

      Default max number buffered bytes when decoding a form = 1024
      See Also:
        Constant Field Values

    - #### DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY

          public static final boolean DEFAULT_HANDLE_100_CONTINE_AUTOMATICALLY

      Default value of whether 100-Continue should be handled automatically = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_ALPN_VERSIONS

          public static final List<HttpVersion> DEFAULT_ALPN_VERSIONS

      Default Application-Layer Protocol Negotiation versions = [HTTP/2,HTTP/1.1]

    - #### DEFAULT_HTTP2_CLEAR_TEXT_ENABLED

          public static final boolean DEFAULT_HTTP2_CLEAR_TEXT_ENABLED

      Default H2C is enabled = `true`
      See Also:
        Constant Field Values

    - #### DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS

          public static final long DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS

      The default initial settings max concurrent stream for an HTTP/2 server = 100
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

          public static final int DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

      The default HTTP/2 connection window size = -1
      See Also:
        Constant Field Values

    - #### DEFAULT_DECOMPRESSION_SUPPORTED

          public static final boolean DEFAULT_DECOMPRESSION_SUPPORTED

      Default value of whether decompression is supported = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_ACCEPT_UNMASKED_FRAMES

          public static final boolean DEFAULT_ACCEPT_UNMASKED_FRAMES

      Default WebSocket Masked bit is true as depicted by RFC = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_DECODER_INITIAL_BUFFER_SIZE

          public static final int DEFAULT_DECODER_INITIAL_BUFFER_SIZE

      Default initial buffer size for HttpObjectDecoder = 128 bytes
      See Also:
        Constant Field Values

    - #### DEFAULT_PER_FRAME_WEBSOCKET_COMPRESSION_SUPPORTED

          public static final boolean DEFAULT_PER_FRAME_WEBSOCKET_COMPRESSION_SUPPORTED

      Default support for WebSockets per-frame deflate compression extension = `true`
      See Also:
        Constant Field Values

    - #### DEFAULT_PER_MESSAGE_WEBSOCKET_COMPRESSION_SUPPORTED

          public static final boolean DEFAULT_PER_MESSAGE_WEBSOCKET_COMPRESSION_SUPPORTED

      Default support for WebSockets per-message deflate compression extension = `true`
      See Also:
        Constant Field Values

    - #### DEFAULT_WEBSOCKET_COMPRESSION_LEVEL

          public static final int DEFAULT_WEBSOCKET_COMPRESSION_LEVEL

      Default WebSocket deflate compression level = 6
      See Also:
        Constant Field Values

    - #### DEFAULT_WEBSOCKET_ALLOW_SERVER_NO_CONTEXT

          public static final boolean DEFAULT_WEBSOCKET_ALLOW_SERVER_NO_CONTEXT

      Default allowance of the `server_no_context_takeover` WebSocket parameter deflate compression extension = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_WEBSOCKET_PREFERRED_CLIENT_NO_CONTEXT

          public static final boolean DEFAULT_WEBSOCKET_PREFERRED_CLIENT_NO_CONTEXT

      Default allowance of the `client_no_context_takeover` WebSocket parameter deflate compression extension = `false`
      See Also:
        Constant Field Values

    - #### DEFAULT_WEBSOCKET_CLOSING_TIMEOUT

          public static final int DEFAULT_WEBSOCKET_CLOSING_TIMEOUT

      Default WebSocket closing timeout = 10 second)
      See Also:
        Constant Field Values

    - #### DEFAULT_TRACING_POLICY

          public static final TracingPolicy DEFAULT_TRACING_POLICY

      Default tracing control = `TracingPolicy.ALWAYS`

    - #### DEFAULT_REGISTER_WEBSOCKET_WRITE_HANDLERS

          public static final boolean DEFAULT_REGISTER_WEBSOCKET_WRITE_HANDLERS

      Whether write-handlers for server websockets should be registered by default = false.
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_RST_FLOOD_MAX_RST_FRAME_PER_WINDOW

          public static final int DEFAULT_HTTP2_RST_FLOOD_MAX_RST_FRAME_PER_WINDOW

      HTTP/2 RST floods DDOS protection, max number of RST frame per time window allowed = 200.
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION

          public static final int DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION

      HTTP/2 RST floods DDOS protection, time window duration = 30.
      See Also:
        Constant Field Values

    - #### DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION_TIME_UNIT

          public static final TimeUnit DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION_TIME_UNIT

      HTTP/2 RST floods DDOS protection, time window duration unit = `TimeUnit.SECONDS`.

  - ### Constructor Detail

    - #### HttpServerOptions

          public HttpServerOptions()

      Default constructor

    - #### HttpServerOptions

          public HttpServerOptions​(HttpServerOptions other)

      Copy constructor
      Parameters:
        `other` - the options to copy

    - #### HttpServerOptions

          public HttpServerOptions​(JsonObject json)

      Create an options from JSON
      Parameters:
        `json` - the JSON

  - ### Method Detail

    - #### toJson

          public JsonObject toJson()

      Convert to JSON
      Overrides:
        `toJson` in class `NetServerOptions`
      Returns:
        the JSON

    - #### copy

          public HttpServerOptions copy()

      Copy these options.
      Overrides:
        `copy` in class `NetServerOptions`
      Returns:
        a copy of this

    - #### setSendBufferSize

          public HttpServerOptions setSendBufferSize​(int sendBufferSize)

      Description copied from class: `NetworkOptions`
      Set the TCP send buffer size
      Overrides:
        `setSendBufferSize` in class `NetServerOptions`
      Parameters:
        `sendBufferSize` - the buffers size, in bytes
      Returns:
        a reference to this, so the API can be used fluently

    - #### setReceiveBufferSize

          public HttpServerOptions setReceiveBufferSize​(int receiveBufferSize)

      Description copied from class: `NetworkOptions`
      Set the TCP receive buffer size
      Overrides:
        `setReceiveBufferSize` in class `NetServerOptions`
      Parameters:
        `receiveBufferSize` - the buffers size, in bytes
      Returns:
        a reference to this, so the API can be used fluently

    - #### setReuseAddress

          public HttpServerOptions setReuseAddress​(boolean reuseAddress)

      Description copied from class: `NetworkOptions`
      Set the value of reuse address
      Overrides:
        `setReuseAddress` in class `NetServerOptions`
      Parameters:
        `reuseAddress` - the value of reuse address
      Returns:
        a reference to this, so the API can be used fluently

    - #### setReusePort

          public HttpServerOptions setReusePort​(boolean reusePort)

      Description copied from class: `NetworkOptions`
      Set the value of reuse port.

      This is only supported by native transports.
      Overrides:
        `setReusePort` in class `NetServerOptions`
      Parameters:
        `reusePort` - the value of reuse port
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrafficClass

          public HttpServerOptions setTrafficClass​(int trafficClass)

      Description copied from class: `NetworkOptions`
      Set the value of traffic class
      Overrides:
        `setTrafficClass` in class `NetServerOptions`
      Parameters:
        `trafficClass` - the value of traffic class
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTcpNoDelay

          public HttpServerOptions setTcpNoDelay​(boolean tcpNoDelay)

      Description copied from class: `TCPSSLOptions`
      Set whether TCP no delay is enabled
      Overrides:
        `setTcpNoDelay` in class `NetServerOptions`
      Parameters:
        `tcpNoDelay` - true if TCP no delay is enabled (Nagle disabled)
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTcpKeepAlive

          public HttpServerOptions setTcpKeepAlive​(boolean tcpKeepAlive)

      Description copied from class: `TCPSSLOptions`
      Set whether TCP keep alive is enabled
      Overrides:
        `setTcpKeepAlive` in class `NetServerOptions`
      Parameters:
        `tcpKeepAlive` - true if TCP keep alive is enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSoLinger

          public HttpServerOptions setSoLinger​(int soLinger)

      Description copied from class: `TCPSSLOptions`
      Set whether SO_linger keep alive is enabled
      Overrides:
        `setSoLinger` in class `NetServerOptions`
      Parameters:
        `soLinger` - true if SO_linger is enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setIdleTimeout

          public HttpServerOptions setIdleTimeout​(int idleTimeout)

      Description copied from class: `TCPSSLOptions`
      Set the idle timeout, default time unit is seconds. Zero means don't timeout. This determines if a connection will timeout and be closed if no data is received nor sent within the timeout. If you want change default time unit, use `TCPSSLOptions.setIdleTimeoutUnit(TimeUnit)`
      Overrides:
        `setIdleTimeout` in class `NetServerOptions`
      Parameters:
        `idleTimeout` - the timeout
      Returns:
        a reference to this, so the API can be used fluently

    - #### setReadIdleTimeout

          public HttpServerOptions setReadIdleTimeout​(int idleTimeout)

      Description copied from class: `TCPSSLOptions`
      Set the read idle timeout, default time unit is seconds. Zero means don't timeout. This determines if a connection will timeout and be closed if no data is received within the timeout. If you want change default time unit, use `TCPSSLOptions.setIdleTimeoutUnit(TimeUnit)`
      Overrides:
        `setReadIdleTimeout` in class `NetServerOptions`
      Parameters:
        `idleTimeout` - the read timeout
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWriteIdleTimeout

          public HttpServerOptions setWriteIdleTimeout​(int idleTimeout)

      Description copied from class: `TCPSSLOptions`
      Set the write idle timeout, default time unit is seconds. Zero means don't timeout. This determines if a connection will timeout and be closed if no data is sent within the timeout. If you want change default time unit, use `TCPSSLOptions.setIdleTimeoutUnit(TimeUnit)`
      Overrides:
        `setWriteIdleTimeout` in class `NetServerOptions`
      Parameters:
        `idleTimeout` - the write timeout
      Returns:
        a reference to this, so the API can be used fluently

    - #### setIdleTimeoutUnit

          public HttpServerOptions setIdleTimeoutUnit​(TimeUnit idleTimeoutUnit)

      Description copied from class: `TCPSSLOptions`
      Set the idle timeout unit. If not specified, default is seconds.
      Overrides:
        `setIdleTimeoutUnit` in class `NetServerOptions`
      Parameters:
        `idleTimeoutUnit` - specify time unit.
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSsl

          public HttpServerOptions setSsl​(boolean ssl)

      Description copied from class: `TCPSSLOptions`
      Set whether SSL/TLS is enabled
      Overrides:
        `setSsl` in class `NetServerOptions`
      Parameters:
        `ssl` - true if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### setUseAlpn

          public HttpServerOptions setUseAlpn​(boolean useAlpn)

      Description copied from class: `TCPSSLOptions`
      Set the ALPN usage.
      Overrides:
        `setUseAlpn` in class `NetServerOptions`
      Parameters:
        `useAlpn` - true when Application-Layer Protocol Negotiation should be used

    - #### setKeyCertOptions

          public HttpServerOptions setKeyCertOptions​(KeyCertOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the key/cert options.
      Overrides:
        `setKeyCertOptions` in class `NetServerOptions`
      Parameters:
        `options` - the key store options
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrustOptions

          public HttpServerOptions setTrustOptions​(TrustOptions options)

      Description copied from class: `TCPSSLOptions`
      Set the trust options.
      Overrides:
        `setTrustOptions` in class `NetServerOptions`
      Parameters:
        `options` - the trust options
      Returns:
        a reference to this, so the API can be used fluently

    - #### addEnabledCipherSuite

          public HttpServerOptions addEnabledCipherSuite​(String suite)

      Description copied from class: `TCPSSLOptions`
      Add an enabled cipher suite, appended to the ordered suites.
      Overrides:
        `addEnabledCipherSuite` in class `NetServerOptions`
      Parameters:
        `suite` - the suite
      Returns:
        a reference to this, so the API can be used fluently
      See Also:
        `TCPSSLOptions.getEnabledCipherSuites()`

    - #### removeEnabledCipherSuite

          public HttpServerOptions removeEnabledCipherSuite​(String suite)

      Description copied from class: `TCPSSLOptions`
      Removes an enabled cipher suite from the ordered suites.
      Overrides:
        `removeEnabledCipherSuite` in class `NetServerOptions`
      Parameters:
        `suite` - the suite
      Returns:
        a reference to this, so the API can be used fluently

    - #### addEnabledSecureTransportProtocol

          public HttpServerOptions addEnabledSecureTransportProtocol​(String protocol)

      Description copied from class: `TCPSSLOptions`
      Add an enabled SSL/TLS protocols, appended to the ordered protocols.
      Overrides:
        `addEnabledSecureTransportProtocol` in class `NetServerOptions`
      Parameters:
        `protocol` - the SSL/TLS protocol to enable
      Returns:
        a reference to this, so the API can be used fluently

    - #### removeEnabledSecureTransportProtocol

          public HttpServerOptions removeEnabledSecureTransportProtocol​(String protocol)

      Description copied from class: `TCPSSLOptions`
      Removes an enabled SSL/TLS protocol from the ordered protocols.
      Overrides:
        `removeEnabledSecureTransportProtocol` in class `NetServerOptions`
      Parameters:
        `protocol` - the SSL/TLS protocol to disable
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTcpFastOpen

          public HttpServerOptions setTcpFastOpen​(boolean tcpFastOpen)

      Description copied from class: `TCPSSLOptions`
      Enable the `TCP_FASTOPEN` option - only with linux native transport.
      Overrides:
        `setTcpFastOpen` in class `NetServerOptions`
      Parameters:
        `tcpFastOpen` - the fast open value

    - #### setTcpCork

          public HttpServerOptions setTcpCork​(boolean tcpCork)

      Description copied from class: `TCPSSLOptions`
      Enable the `TCP_CORK` option - only with linux native transport.
      Overrides:
        `setTcpCork` in class `NetServerOptions`
      Parameters:
        `tcpCork` - the cork value

    - #### setTcpQuickAck

          public HttpServerOptions setTcpQuickAck​(boolean tcpQuickAck)

      Description copied from class: `TCPSSLOptions`
      Enable the `TCP_QUICKACK` option - only with linux native transport.
      Overrides:
        `setTcpQuickAck` in class `NetServerOptions`
      Parameters:
        `tcpQuickAck` - the quick ack value

    - #### addCrlPath

          public HttpServerOptions addCrlPath​(String crlPath)
                                       throws NullPointerException

      Description copied from class: `TCPSSLOptions`
      Add a CRL path
      Overrides:
        `addCrlPath` in class `NetServerOptions`
      Parameters:
        `crlPath` - the path
      Returns:
        a reference to this, so the API can be used fluently
      Throws:
        `NullPointerException`

    - #### addCrlValue

          public HttpServerOptions addCrlValue​(Buffer crlValue)
                                        throws NullPointerException

      Description copied from class: `TCPSSLOptions`
      Add a CRL value
      Overrides:
        `addCrlValue` in class `NetServerOptions`
      Parameters:
        `crlValue` - the value
      Returns:
        a reference to this, so the API can be used fluently
      Throws:
        `NullPointerException`

    - #### setAcceptBacklog

          public HttpServerOptions setAcceptBacklog​(int acceptBacklog)

      Description copied from class: `NetServerOptions`
      Set the accept back log
      Overrides:
        `setAcceptBacklog` in class `NetServerOptions`
      Parameters:
        `acceptBacklog` - accept backlog
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPort

          public HttpServerOptions setPort​(int port)

      Description copied from class: `NetServerOptions`
      Set the port
      Overrides:
        `setPort` in class `NetServerOptions`
      Parameters:
        `port` - the port
      Returns:
        a reference to this, so the API can be used fluently

    - #### setHost

          public HttpServerOptions setHost​(String host)

      Description copied from class: `NetServerOptions`
      Set the host
      Overrides:
        `setHost` in class `NetServerOptions`
      Parameters:
        `host` - the host
      Returns:
        a reference to this, so the API can be used fluently

    - #### setClientAuth

          public HttpServerOptions setClientAuth​(ClientAuth clientAuth)

      Description copied from class: `NetServerOptions`
      Set whether client auth is required
      Overrides:
        `setClientAuth` in class `NetServerOptions`
      Parameters:
        `clientAuth` - One of "NONE, REQUEST, REQUIRED". If it's set to "REQUIRED" then server will require the SSL cert to be presented otherwise it won't accept the request. If it's set to "REQUEST" then it won't mandate the certificate to be presented, basically make it optional.
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSslEngineOptions

          public HttpServerOptions setSslEngineOptions​(SSLEngineOptions sslEngineOptions)

      Description copied from class: `TCPSSLOptions`
      Set to use SSL engine implementation to use.
      Overrides:
        `setSslEngineOptions` in class `NetServerOptions`
      Parameters:
        `sslEngineOptions` - the ssl engine to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### setEnabledSecureTransportProtocols

          public HttpServerOptions setEnabledSecureTransportProtocols​(Set<String> enabledSecureTransportProtocols)

      Description copied from class: `TCPSSLOptions`
      Sets the list of enabled SSL/TLS protocols.
      Overrides:
        `setEnabledSecureTransportProtocols` in class `NetServerOptions`
      Parameters:
        `enabledSecureTransportProtocols` - the SSL/TLS protocols to enable
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSslHandshakeTimeout

          public HttpServerOptions setSslHandshakeTimeout​(long sslHandshakeTimeout)

      Description copied from class: `TCPSSLOptions`
      Set the SSL handshake timeout, default time unit is seconds.
      Overrides:
        `setSslHandshakeTimeout` in class `NetServerOptions`
      Parameters:
        `sslHandshakeTimeout` - the SSL handshake timeout to set, in milliseconds
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSslHandshakeTimeoutUnit

          public HttpServerOptions setSslHandshakeTimeoutUnit​(TimeUnit sslHandshakeTimeoutUnit)

      Description copied from class: `TCPSSLOptions`
      Set the SSL handshake timeout unit. If not specified, default is seconds.
      Overrides:
        `setSslHandshakeTimeoutUnit` in class `NetServerOptions`
      Parameters:
        `sslHandshakeTimeoutUnit` - specify time unit.
      Returns:
        a reference to this, so the API can be used fluently

    - #### isCompressionSupported

          public boolean isCompressionSupported()

      Returns:
        `true` if the server supports gzip/deflate compression

    - #### setCompressionSupported

          public HttpServerOptions setCompressionSupported​(boolean compressionSupported)

      Set whether the server should support gzip/deflate compression (serving compressed responses to clients advertising support for them with Accept-Encoding header)
      Parameters:
        `compressionSupported` - `true` to enable compression support
      Returns:
        a reference to this, so the API can be used fluently

    - #### getCompressionLevel

          public int getCompressionLevel()

      Returns:
        the server gzip/deflate 'compression level' to be used in responses when client and server support is turned on

    - #### setCompressionLevel

          public HttpServerOptions setCompressionLevel​(int compressionLevel)

      This method allows to set the compression level to be used in http1.x/2 response bodies when compression support is turned on (@see setCompressionSupported) and the client advertises to support `deflate/gzip` compression in the `Accept-Encoding` header default value is : 6 (Netty legacy) The compression level determines how much the data is compressed on a scale from 1 to 9, where '9' is trying to achieve the maximum compression ratio while '1' instead is giving priority to speed instead of compression ratio using some algorithm optimizations and skipping pedantic loops that usually gives just little improvements While one can think that best value is always the maximum compression ratio, there's a trade-off to consider: the most compressed level requires the most computational work to compress/decompress data, e.g. more dictionary lookups and loops. E.g. you have it set fairly high on a high-volume website, you may experience performance degradation and latency on resource serving due to CPU overload, and, however - as the computational work is required also client side while decompressing - setting an higher compression level can result in an overall higher page load time especially nowadays when many clients are handled mobile devices with a low CPU profile. see also: http://www.gzip.org/algorithm.txt
      Parameters:
        `compressionLevel` - integer 1-9, 1 means use fastest algorithm, 9 slower algorithm but better compression ratio
      Returns:
        a reference to this, so the API can be used fluently

    - #### getCompressionContentSizeThreshold

          public int getCompressionContentSizeThreshold()

      Returns:
        the compression content size threshold

    - #### setCompressionContentSizeThreshold

          public HttpServerOptions setCompressionContentSizeThreshold​(int compressionContentSizeThreshold)

      Set the compression content size threshold if compression is enabled. This is only applicable for HTTP/1.x response bodies. If the response content size in bytes is greater than this threshold, then the response is compressed. Otherwise, it is not compressed.
      Parameters:
        `compressionContentSizeThreshold` - integer greater than or equal to 0.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getCompressors

          public List<CompressionOptions> getCompressors()

      Returns:
        the list of compressor to use

    - #### addCompressor

          public HttpServerOptions addCompressor​(CompressionOptions compressor)

      Add a compressor.
      Returns:
        a reference to this, so the API can be used fluently
      See Also:
        `setCompressors(List)`

    - #### setCompressors

          public HttpServerOptions setCompressors​(List<CompressionOptions> compressors)

      Set the list of compressor to use instead of using the default gzip/deflate `setCompressionLevel(int)` configuration.

      This is only active when `setCompressionSupported(boolean)` is `true`.

      Parameters:
        `compressors` - the list of compressors
      Returns:
        a reference to this, so the API can be used fluently

    - #### isAcceptUnmaskedFrames

          public boolean isAcceptUnmaskedFrames()

    - #### setAcceptUnmaskedFrames

          public HttpServerOptions setAcceptUnmaskedFrames​(boolean acceptUnmaskedFrames)

      Set `true` when the server accepts unmasked frame. As default Server doesn't accept unmasked frame, you can bypass this behaviour (RFC 6455) setting `true`. It's set to `false` as default.
      Parameters:
        `acceptUnmaskedFrames` - `true` if enabled
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWebSocketFrameSize

          public int getMaxWebSocketFrameSize()

      Returns:
        the maximum WebSocket frame size

    - #### setMaxWebSocketFrameSize

          public HttpServerOptions setMaxWebSocketFrameSize​(int maxWebSocketFrameSize)

      Set the maximum WebSocket frames size
      Parameters:
        `maxWebSocketFrameSize` - the maximum frame size in bytes.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWebSocketMessageSize

          public int getMaxWebSocketMessageSize()

      Returns:
        the maximum WebSocket message size

    - #### setMaxWebSocketMessageSize

          public HttpServerOptions setMaxWebSocketMessageSize​(int maxWebSocketMessageSize)

      Set the maximum WebSocket message size
      Parameters:
        `maxWebSocketMessageSize` - the maximum message size in bytes.
      Returns:
        a reference to this, so the API can be used fluently

    - #### addWebSocketSubProtocol

          public HttpServerOptions addWebSocketSubProtocol​(String subProtocol)

      Add a WebSocket sub-protocol to the list supported by the server.
      Parameters:
        `subProtocol` - the sub-protocol to add
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWebSocketSubProtocols

          public HttpServerOptions setWebSocketSubProtocols​(List<String> subProtocols)

      Set the WebSocket list of sub-protocol supported by the server.
      Parameters:
        `subProtocols` - comma separated list of sub-protocols
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWebSocketSubProtocols

          public List<String> getWebSocketSubProtocols()

      Returns:
        Get the WebSocket list of sub-protocol

    - #### isHandle100ContinueAutomatically

          public boolean isHandle100ContinueAutomatically()

      Returns:
        whether 100 Continue should be handled automatically

    - #### setHandle100ContinueAutomatically

          public HttpServerOptions setHandle100ContinueAutomatically​(boolean handle100ContinueAutomatically)

      Set whether 100 Continue should be handled automatically
      Parameters:
        `handle100ContinueAutomatically` - `true` if it should be handled automatically
      Returns:
        a reference to this, so the API can be used fluently

    - #### setMaxChunkSize

          public HttpServerOptions setMaxChunkSize​(int maxChunkSize)

      Set the maximum HTTP chunk size that `HttpServerRequest.handler(Handler)` will receive
      Parameters:
        `maxChunkSize` - the maximum chunk size
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxChunkSize

          public int getMaxChunkSize()

      Returns:
        the maximum HTTP chunk size that `HttpServerRequest.handler(Handler)` will receive

    - #### getMaxInitialLineLength

          public int getMaxInitialLineLength()

      Returns:
        the maximum length of the initial line for HTTP/1.x (e.g. `"GET / HTTP/1.0"`)

    - #### setMaxInitialLineLength

          public HttpServerOptions setMaxInitialLineLength​(int maxInitialLineLength)

      Set the maximum length of the initial line for HTTP/1.x (e.g. `"GET / HTTP/1.0"`)
      Parameters:
        `maxInitialLineLength` - the new maximum initial length
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxHeaderSize

          public int getMaxHeaderSize()

      Returns:
        Returns the maximum length of all headers for HTTP/1.x

    - #### setMaxHeaderSize

          public HttpServerOptions setMaxHeaderSize​(int maxHeaderSize)

      Set the maximum length of all headers for HTTP/1.x .
      Parameters:
        `maxHeaderSize` - the new maximum length
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxFormAttributeSize

          public int getMaxFormAttributeSize()

      Returns:
        Returns the maximum size of a form attribute

    - #### setMaxFormAttributeSize

          public HttpServerOptions setMaxFormAttributeSize​(int maxSize)

      Set the maximum size of a form attribute. Set to `-1` to allow unlimited length
      Parameters:
        `maxSize` - the new maximum size
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxFormFields

          public int getMaxFormFields()

      Returns:
        Returns the maximum number of form fields

    - #### setMaxFormFields

          public HttpServerOptions setMaxFormFields​(int maxFormFields)

      Set the maximum number of fields of a form. Set to `-1` to allow unlimited number of attributes
      Parameters:
        `maxFormFields` - the new maximum
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxFormBufferedBytes

          public int getMaxFormBufferedBytes()

      Returns:
        Returns the maximum number of bytes a server can buffer when decoding a form

    - #### setMaxFormBufferedBytes

          public HttpServerOptions setMaxFormBufferedBytes​(int maxFormBufferedBytes)

      Set the maximum number of bytes a server can buffer when decoding a form. Set to `-1` to allow unlimited length
      Parameters:
        `maxFormBufferedBytes` - the new maximum
      Returns:
        a reference to this, so the API can be used fluently

    - #### getInitialSettings

          public Http2Settings getInitialSettings()

      Returns:
        the initial HTTP/2 connection settings

    - #### setInitialSettings

          public HttpServerOptions setInitialSettings​(Http2Settings settings)

      Set the HTTP/2 connection settings immediatly sent by the server when a client connects.
      Parameters:
        `settings` - the settings value
      Returns:
        a reference to this, so the API can be used fluently

    - #### getAlpnVersions

          public List<HttpVersion> getAlpnVersions()

      Returns:
        the list of protocol versions to provide during the Application-Layer Protocol Negotiatiation

    - #### setAlpnVersions

          public HttpServerOptions setAlpnVersions​(List<HttpVersion> alpnVersions)

      Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiatiation.
      Parameters:
        `alpnVersions` - the versions
      Returns:
        a reference to this, so the API can be used fluently

    - #### isHttp2ClearTextEnabled

          public boolean isHttp2ClearTextEnabled()

      Returns:
        whether the server accepts HTTP/2 over clear text connections

    - #### setHttp2ClearTextEnabled

          public HttpServerOptions setHttp2ClearTextEnabled​(boolean http2ClearTextEnabled)

      Set whether HTTP/2 over clear text is enabled or disabled, default is enabled.
      Parameters:
        `http2ClearTextEnabled` - whether to accept HTTP/2 over clear text
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHttp2ConnectionWindowSize

          public int getHttp2ConnectionWindowSize()

      Returns:
        the default HTTP/2 connection window size

    - #### setHttp2ConnectionWindowSize

          public HttpServerOptions setHttp2ConnectionWindowSize​(int http2ConnectionWindowSize)

      Set the default HTTP/2 connection window size. It overrides the initial window size set by `Http2Settings.getInitialWindowSize()`, so the connection window size is greater than for its streams, in order the data throughput.

      A value of `-1` reuses the initial window size setting.
      Parameters:
        `http2ConnectionWindowSize` - the window size applied to the connection
      Returns:
        a reference to this, so the API can be used fluently

    - #### setLogActivity

          public HttpServerOptions setLogActivity​(boolean logEnabled)

      Description copied from class: `NetworkOptions`
      Set to true to enabled network activity logging: Netty's pipeline is configured for logging on Netty's logger.
      Overrides:
        `setLogActivity` in class `NetServerOptions`
      Parameters:
        `logEnabled` - true for logging the network activity
      Returns:
        a reference to this, so the API can be used fluently

    - #### setActivityLogDataFormat

          public HttpServerOptions setActivityLogDataFormat​(ByteBufFormat activityLogDataFormat)

      Description copied from class: `NetworkOptions`
      Set the value of Netty's logging handler's data format: Netty's pipeline is configured for logging on Netty's logger.
      Overrides:
        `setActivityLogDataFormat` in class `NetServerOptions`
      Parameters:
        `activityLogDataFormat` - the format to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### setSni

          public HttpServerOptions setSni​(boolean sni)

      Description copied from class: `NetServerOptions`
      Set whether the server supports Server Name Indiciation
      Overrides:
        `setSni` in class `NetServerOptions`
      Returns:
        a reference to this, so the API can be used fluently

    - #### setUseProxyProtocol

          public HttpServerOptions setUseProxyProtocol​(boolean useProxyProtocol)

      Description copied from class: `NetServerOptions`
      Set whether the server uses the HA Proxy protocol
      Overrides:
        `setUseProxyProtocol` in class `NetServerOptions`
      Returns:
        a reference to this, so the API can be used fluently

    - #### setProxyProtocolTimeout

          public HttpServerOptions setProxyProtocolTimeout​(long proxyProtocolTimeout)

      Description copied from class: `NetServerOptions`
      Set the Proxy protocol timeout, default time unit is seconds.
      Overrides:
        `setProxyProtocolTimeout` in class `NetServerOptions`
      Parameters:
        `proxyProtocolTimeout` - the Proxy protocol timeout to set
      Returns:
        a reference to this, so the API can be used fluently

    - #### setProxyProtocolTimeoutUnit

          public HttpServerOptions setProxyProtocolTimeoutUnit​(TimeUnit proxyProtocolTimeoutUnit)

      Description copied from class: `NetServerOptions`
      Set the Proxy protocol timeout unit. If not specified, default is seconds.
      Overrides:
        `setProxyProtocolTimeoutUnit` in class `NetServerOptions`
      Parameters:
        `proxyProtocolTimeoutUnit` - specify time unit.
      Returns:
        a reference to this, so the API can be used fluently

    - #### isDecompressionSupported

          public boolean isDecompressionSupported()

      Returns:
        `true` if the server supports decompression

    - #### setDecompressionSupported

          public HttpServerOptions setDecompressionSupported​(boolean decompressionSupported)

      Set whether the server supports decompression
      Parameters:
        `decompressionSupported` - `true` if decompression supported
      Returns:
        a reference to this, so the API can be used fluently

    - #### getDecoderInitialBufferSize

          public int getDecoderInitialBufferSize()

      Returns:
        the initial buffer size for the HTTP decoder

    - #### setDecoderInitialBufferSize

          public HttpServerOptions setDecoderInitialBufferSize​(int decoderInitialBufferSize)

      Set the initial buffer size for the HTTP decoder
      Parameters:
        `decoderInitialBufferSize` - the initial size
      Returns:
        a reference to this, so the API can be used fluently

    - #### setPerFrameWebSocketCompressionSupported

          public HttpServerOptions setPerFrameWebSocketCompressionSupported​(boolean supported)

      Enable or disable support for the WebSocket per-frame deflate compression extension.
      Parameters:
        `supported` - `true` when the per-frame deflate compression extension is supported
      Returns:
        a reference to this, so the API can be used fluently

    - #### getPerFrameWebSocketCompressionSupported

          public boolean getPerFrameWebSocketCompressionSupported()

      Get whether WebSocket the per-frame deflate compression extension is supported.
      Returns:
        `true` if the http server will accept the per-frame deflate compression extension

    - #### setPerMessageWebSocketCompressionSupported

          public HttpServerOptions setPerMessageWebSocketCompressionSupported​(boolean supported)

      Enable or disable support for WebSocket per-message deflate compression extension.
      Parameters:
        `supported` - `true` when the per-message WebSocket compression extension is supported
      Returns:
        a reference to this, so the API can be used fluently

    - #### getPerMessageWebSocketCompressionSupported

          public boolean getPerMessageWebSocketCompressionSupported()

      Get whether WebSocket per-message deflate compression extension is supported.
      Returns:
        `true` if the http server will accept the per-message deflate compression extension

    - #### setWebSocketCompressionLevel

          public HttpServerOptions setWebSocketCompressionLevel​(int compressionLevel)

      Set the WebSocket compression level.
      Parameters:
        `compressionLevel` - the compression level
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWebSocketCompressionLevel

          public int getWebSocketCompressionLevel()

      Returns:
        the current WebSocket deflate compression level

    - #### setWebSocketAllowServerNoContext

          public HttpServerOptions setWebSocketAllowServerNoContext​(boolean accept)

      Set whether the WebSocket server will accept the `server_no_context_takeover` parameter of the per-message deflate compression extension offered by the client.
      Parameters:
        `accept` - `true` to accept the server_no_context_takeover parameter when the client offers it
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWebSocketAllowServerNoContext

          public boolean getWebSocketAllowServerNoContext()

      Returns:
        `true` when the WebSocket server will accept the `server_no_context_takeover` parameter for the per-message deflate compression extension offered by the client

    - #### setWebSocketPreferredClientNoContext

          public HttpServerOptions setWebSocketPreferredClientNoContext​(boolean accept)

      Set whether the WebSocket server will accept the `client_no_context_takeover` parameter of the per-message deflate compression extension offered by the client.
      Parameters:
        `accept` - `true` to accept the `client_no_context_takeover` parameter when the client offers it
      Returns:
        a reference to this, so the API can be used fluently

    - #### getWebSocketPreferredClientNoContext

          public boolean getWebSocketPreferredClientNoContext()

      Returns:
        `true` when the WebSocket server will accept the `client_no_context_takeover` parameter for the per-message deflate compression extension offered by the client

    - #### getWebSocketClosingTimeout

          public int getWebSocketClosingTimeout()

      Returns:
        the amount of time (in seconds) a client WebSocket will wait until it closes TCP connection after receiving a close frame

    - #### setWebSocketClosingTimeout

          public HttpServerOptions setWebSocketClosingTimeout​(int webSocketClosingTimeout)

      Set the amount of time a server WebSocket will wait until it closes the TCP connection after sending a close frame.

      When a server closes a WebSocket, it should wait the client close frame to close the TCP connection. This timeout will close the TCP connection on the server when it expires. When the TCP connection is closed receiving the close frame, the `WebSocket.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>)` instead of the `WebSocket.endHandler(io.vertx.core.Handler<java.lang.Void>)` will be called.

      Set to `0L` closes the TCP connection immediately after sending the close frame.

      Set to a negative value to disable it.

      Parameters:
        `webSocketClosingTimeout` - the timeout is seconds
      Returns:
        a reference to this, so the API can be used fluently

    - #### setTrafficShapingOptions

          public HttpServerOptions setTrafficShapingOptions​(TrafficShapingOptions trafficShapingOptions)

      Description copied from class: `NetServerOptions`
      Set traffic shaping options. If not specified, traffic is unthrottled.
      Overrides:
        `setTrafficShapingOptions` in class `NetServerOptions`
      Parameters:
        `trafficShapingOptions` - options used by traffic handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### getTracingPolicy

          public TracingPolicy getTracingPolicy()

      Returns:
        the tracing policy

    - #### setTracingPolicy

          public HttpServerOptions setTracingPolicy​(TracingPolicy tracingPolicy)

      Set the tracing policy for the server behavior when Vert.x has tracing enabled.
      Parameters:
        `tracingPolicy` - the tracing policy
      Returns:
        a reference to this, so the API can be used fluently

    - #### isRegisterWriteHandler

          public boolean isRegisterWriteHandler()

      Overrides:
        `isRegisterWriteHandler` in class `NetServerOptions`
      Returns:
        `false`, does not apply to HTTP servers

    - #### setRegisterWriteHandler

          public HttpServerOptions setRegisterWriteHandler​(boolean registerWriteHandler)

      Has no effect on HTTP server options.
      Overrides:
        `setRegisterWriteHandler` in class `NetServerOptions`
      Parameters:
        `registerWriteHandler` - true to register a write-handler
      Returns:
        a reference to this, so the API can be used fluently
      See Also:
        `NetSocket.writeHandlerID()`

    - #### isRegisterWebSocketWriteHandlers

          public boolean isRegisterWebSocketWriteHandlers()

      Returns:
        `true` if write-handlers for server websockets should be registered on the `EventBus`, otherwise `false`

    - #### setRegisterWebSocketWriteHandlers

          public HttpServerOptions setRegisterWebSocketWriteHandlers​(boolean registerWebSocketWriteHandlers)

      Whether write-handlers for server websockets should be registered on the `EventBus`.

      Defaults to `false`.

      Parameters:
        `registerWebSocketWriteHandlers` - true to register write-handlers
      Returns:
        a reference to this, so the API can be used fluently
      See Also:
        `WebSocketBase.textHandlerID()`, `WebSocketBase.binaryHandlerID()`

    - #### getHttp2RstFloodMaxRstFramePerWindow

          public int getHttp2RstFloodMaxRstFramePerWindow()

      Returns:
        the max number of RST frame allowed per time window

    - #### setHttp2RstFloodMaxRstFramePerWindow

          public HttpServerOptions setHttp2RstFloodMaxRstFramePerWindow​(int http2RstFloodMaxRstFramePerWindow)

      Set the max number of RST frame allowed per time window, this is used to prevent HTTP/2 RST frame flood DDOS attacks. The default value is `DEFAULT_HTTP2_RST_FLOOD_MAX_RST_FRAME_PER_WINDOW`, setting zero or a negative value, disables flood protection.
      Parameters:
        `http2RstFloodMaxRstFramePerWindow` - the new maximum
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHttp2RstFloodWindowDuration

          public int getHttp2RstFloodWindowDuration()

      Returns:
        the duration of the time window when checking the max number of RST frames.

    - #### setHttp2RstFloodWindowDuration

          public HttpServerOptions setHttp2RstFloodWindowDuration​(int http2RstFloodWindowDuration)

      Set the duration of the time window when checking the max number of RST frames, this is used to prevent HTTP/2 RST frame flood DDOS attacks. The default value is `DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION`, setting zero or a negative value, disables flood protection.
      Parameters:
        `http2RstFloodWindowDuration` - the new duration
      Returns:
        a reference to this, so the API can be used fluently

    - #### getHttp2RstFloodWindowDurationTimeUnit

          public TimeUnit getHttp2RstFloodWindowDurationTimeUnit()

      Returns:
        the time unit of the duration of the time window when checking the max number of RST frames.

    - #### setHttp2RstFloodWindowDurationTimeUnit

          public HttpServerOptions setHttp2RstFloodWindowDurationTimeUnit​(TimeUnit http2RstFloodWindowDurationTimeUnit)

      Set the time unit of the duration of the time window when checking the max number of RST frames, this is used to prevent HTTP/2 RST frame flood DDOS attacks. The default value is `DEFAULT_HTTP2_RST_FLOOD_WINDOW_DURATION_TIME_UNIT`, setting zero or a negative value, disables the flood protection.
      Parameters:
        `http2RstFloodWindowDurationTimeUnit` - the new duration
      Returns:
        a reference to this, so the API can be used fluently

    - #### isFileRegionEnabled

          public boolean isFileRegionEnabled()

      Overrides:
        `isFileRegionEnabled` in class `NetServerOptions`
      Returns: