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 Details

    • DEFAULT_PORT

      public static final int DEFAULT_PORT
      Default port the server will listen on = 80
      See Also:

    • DEFAULT_COMPRESSION_SUPPORTED

      public static final boolean DEFAULT_COMPRESSION_SUPPORTED
      Default value of whether compression is supported = false
      See Also:

    • DEFAULT_COMPRESSION_LEVEL

      public static final int DEFAULT_COMPRESSION_LEVEL
      Default gzip/deflate compression level = 6 (Netty legacy)
      See Also:

    • 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:

    • DEFAULT_MAX_WEBSOCKET_FRAME_SIZE

      public static final int DEFAULT_MAX_WEBSOCKET_FRAME_SIZE
      Default max WebSocket frame size = 65536
      See Also:

    • 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:

    • DEFAULT_MAX_CHUNK_SIZE

      public static final int DEFAULT_MAX_CHUNK_SIZE
      Default max HTTP chunk size = 8192
      See Also:

    • 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:

    • DEFAULT_MAX_HEADER_SIZE

      public static final int DEFAULT_MAX_HEADER_SIZE
      Default max length of all headers = 8192
      See Also:

    • DEFAULT_MAX_FORM_ATTRIBUTE_SIZE

      public static final int DEFAULT_MAX_FORM_ATTRIBUTE_SIZE
      Default max size of a form attribute = 8192
      See Also:

    • DEFAULT_MAX_FORM_FIELDS

      public static final int DEFAULT_MAX_FORM_FIELDS
      Default max number of form fields = 256
      See Also:

    • 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:

    • 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:

    • 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:

    • 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:

    • DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE

      public static final int DEFAULT_HTTP2_CONNECTION_WINDOW_SIZE
      The default HTTP/2 connection window size = -1
      See Also:

    • DEFAULT_DECOMPRESSION_SUPPORTED

      public static final boolean DEFAULT_DECOMPRESSION_SUPPORTED
      Default value of whether decompression is supported = false
      See Also:

    • 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:

    • DEFAULT_DECODER_INITIAL_BUFFER_SIZE

      public static final int DEFAULT_DECODER_INITIAL_BUFFER_SIZE
      Default initial buffer size for HttpObjectDecoder = 128 bytes
      See Also:

    • 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:

    • 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:

    • DEFAULT_WEBSOCKET_COMPRESSION_LEVEL

      public static final int DEFAULT_WEBSOCKET_COMPRESSION_LEVEL
      Default WebSocket deflate compression level = 6
      See Also:

    • 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:

    • 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:

    • DEFAULT_WEBSOCKET_CLOSING_TIMEOUT

      public static final int DEFAULT_WEBSOCKET_CLOSING_TIMEOUT
      Default WebSocket closing timeout = 10 second)
      See Also:

    • DEFAULT_TRACING_POLICY

      public static final TracingPolicy DEFAULT_TRACING_POLICY
      Default tracing control = TracingPolicy.ALWAYS

    • DEFAULT_METRICS_NAME

      public static final String DEFAULT_METRICS_NAME
      The default value of the server metrics = "":
      See Also:

    • 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:

    • 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:

    • 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:

    • 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.

    • DEFAULT_HTTP2_MAX_SMALL_CONTINUATION_FRAMES

      public static final int DEFAULT_HTTP2_MAX_SMALL_CONTINUATION_FRAMES
      HTTP/2 maximum allowed number of small continuation frames.
      See Also:

    • DEFAULT_STRICT_THREAD_MODE_STRICT

      public static final boolean DEFAULT_STRICT_THREAD_MODE_STRICT
      Strict thread mode = false.
      See Also:

    • DEFAULT_HTTP_2_MULTIPLEX_IMPLEMENTATION

      public static final boolean DEFAULT_HTTP_2_MULTIPLEX_IMPLEMENTATION
      Use HTTP/2 multiplex implementation = false
      See Also:

  • Constructor Details

    • 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 Details

    • 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

    • getHttp1Config

      public Http1ServerConfig getHttp1Config()
      Returns:
      the configuration specific to the HTTP/1.x protocol.

    • getHttp2Config

      public Http2ServerConfig getHttp2Config()
      Returns:
      the configuration specific to the HTTP/2 protocol.

    • getWebSocketConfig

      public WebSocketServerConfig getWebSocketConfig()
      Returns:
      the configuration specific to the WebSocket protocol.

    • createSSLOptions

      protected ServerSSLOptions createSSLOptions()
      Overrides:
      createSSLOptions in class NetServerOptions

    • 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:

    • 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

    • setTcpUserTimeout

      public HttpServerOptions setTcpUserTimeout(int tcpUserTimeout)
      Description copied from class: TCPSSLOptions
      Sets the TCP_USER_TIMEOUT option - only with linux native transport.
      Overrides:
      setTcpUserTimeout in class NetServerOptions
      Parameters:
      tcpUserTimeout - the tcp user timeout 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

    • getCompression

      public CompressionConfig getCompression()
      Returns:
      the compression configuration

    • setCompression

      public HttpServerOptions setCompression(CompressionConfig compression)
      Configure the server compression, this overwrites any previously configuration.
      Parameters:
      compression - the new configuration
      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

      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 Negotiation

    • setAlpnVersions

      public HttpServerOptions setAlpnVersions(List<HttpVersion> alpnVersions)
      Set the list of protocol versions to provide to the server during the Application-Layer Protocol Negotiation.
      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(Handler) instead of the WebSocket.endHandler(Handler) 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

    • getMetricsName

      public String getMetricsName()
      Returns:
      the metrics name identifying the reported metrics.

    • setMetricsName

      public HttpServerOptions setMetricsName(String metricsName)
      Set the metrics name identifying the reported metrics, useful for naming the server metrics.
      Parameters:
      metricsName - the metrics name
      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:

    • 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:

    • 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

    • getHttp2MaxSmallContinuationFrames

      public int getHttp2MaxSmallContinuationFrames()
      Returns:
      the max number of small continuation frame allowed

    • setHttp2MaxSmallContinuationFrames

      public HttpServerOptions setHttp2MaxSmallContinuationFrames(int http2MaxSmallContinuationFrames)
      Set the maximum number of small continuation frames allowed, this is used to prevent flood DoS attack via zero-byte continuation frames. The default value is DEFAULT_HTTP2_MAX_SMALL_CONTINUATION_FRAMES.
      Parameters:
      http2MaxSmallContinuationFrames - the max number of small continuation frame allowed
      Returns:
      a reference to this, so the API can be used fluently

    • isFileRegionEnabled

      public boolean isFileRegionEnabled()
      Overrides:
      isFileRegionEnabled in class NetServerOptions
      Returns:
      whether the strict thread mode is used

    • getStrictThreadMode

      @Unstable("Experimental") public boolean getStrictThreadMode()
      Returns:
      whether to use the strict thread mode.

    • setStrictThreadMode

      @Unstable("Experimental") public HttpServerOptions setStrictThreadMode(boolean strictThreadMode)
      Indicates the server that the HTTP request/response interactions will happen exclusively on the expected thread when the threading model is event-loop.
      Parameters:
      strictThreadMode - whether to use the strict thread mode
      Returns:
      a reference to this, so the API can be used fluently

    • getHttp2MultiplexImplementation

      public boolean getHttp2MultiplexImplementation()
      Returns:
      whether to use the HTTP/2 implementation based on multiplexed channel

    • setHttp2MultiplexImplementation

      public HttpServerOptions setHttp2MultiplexImplementation(boolean http2MultiplexImplementation)
      Set which HTTP/2 implementation to use
      Parameters:
      http2MultiplexImplementation - whether to use the HTTP/2 multiplex implementation
      Returns:
      a reference to this, so the API can be used fluently