java.lang.Object

reactor.netty.transport.Transport<T,CONF>

reactor.netty.quic.QuicServer

public abstract class QuicServer extends Transport<T,CONF>

A QuicServer allows building in a safe immutable way a QUIC server that is materialized and bound when bind() is ultimately called.

Example:

 
     QuicServer.create()
               .tokenHandler(InsecureQuicTokenHandler.INSTANCE)
               .port(7777)
               .wiretap(true)
               .secure(serverCtx)
               .idleTimeout(Duration.ofSeconds(5))
               .initialSettings(spec ->
                   spec.maxData(10000000)
                       .maxStreamDataBidirectionalLocal(1000000)
                       .maxStreamDataBidirectionalRemote(1000000)
                       .maxStreamsBidirectional(100)
                       .maxStreamsUnidirectional(100))
               .bindNow();

Author:: Violeta Georgieva

Constructor Summary

Constructors

Constructor

Description

QuicServer()
Method Summary

Modifier and Type

Method

Description

final QuicServer

ackDelayExponent(long ackDelayExponent)

Set the delay exponent used for ACKs.

final QuicServer

activeMigration(boolean enable)

Enable/disable active migration.

abstract Mono<? extends Connection>

bind()

Binds the QuicServer and returns a Mono of Connection.

final Connection

bindNow()

Starts the server in a blocking fashion, and waits for it to finish initializing or the startup timeout expires (the startup timeout is 45 seconds).

final Connection

bindNow(Duration timeout)

Start the server in a blocking fashion, and wait for it to finish initializing or the provided startup timeout expires.

final QuicServer

congestionControlAlgorithm(QuicCongestionControlAlgorithm congestionControlAlgorithm)

Set the congestion control algorithm to use.

final QuicServer

connectionIdAddressGenerator(QuicConnectionIdGenerator connectionIdAddressGenerator)

Set the QuicConnectionIdGenerator to use.

static QuicServer

create()

Prepare a QuicServer.

final QuicServer

datagram(int recvQueueLen, int sendQueueLen)

If configured this will enable Datagram support.

final QuicServer

doOnBind(Consumer<? super QuicServerConfig> doOnBind)

Set or add a callback called when QuicTransport is about to start listening for incoming traffic.

final QuicServer

doOnBound(Consumer<? super Connection> doOnBound)

Set or add a callback called after QuicTransport has been started.

final QuicServer

doOnConnection(Consumer<? super QuicConnection> doOnConnection)

Set or add a callback called on new remote QuicConnection.

final QuicServer

doOnUnbound(Consumer<? super Connection> doOnUnbound)

Set or add a callback called after QuicTransport has been shutdown.

final QuicServer

grease(boolean enable)

Set if greasing should be enabled or not.

final QuicServer

handleStream(BiFunction<? super QuicInbound,? super QuicOutbound,? extends Publisher<Void>> streamHandler)

Attach an IO handler to react on incoming stream.

final QuicServer

host(String host)

The host to which this server should bind.

final QuicServer

hystart(boolean enable)

Enable/disable Hystart.

final QuicServer

idleTimeout(Duration idleTimeout)

Set the maximum idle timeout (resolution: ms) See set_max_idle_timeout.

final QuicServer

initialSettings(Consumer<QuicInitialSettingsSpec.Builder> initialSettings)

Configure QUIC initial settings.

final QuicServer

localConnectionIdLength(int localConnectionIdLength)

Sets the local connection id length that is used.

final QuicServer

maxAckDelay(Duration maxAckDelay)

Set max ACK delay (resolution: ms).

final QuicServer

maxRecvUdpPayloadSize(long maxRecvUdpPayloadSize)

See set_max_recv_udp_payload_size.

final QuicServer

maxSendUdpPayloadSize(long maxSendUdpPayloadSize)

See set_max_send_udp_payload_size.

final QuicServer

port(int port)

The port to which this server should bind.

final QuicServer

secure(QuicSslContext sslContext)

The QuicSslContext that will be used to create QuicSslEngines for QuicChannels.

final QuicServer

secure(Function<QuicChannel,? extends QuicSslEngine> sslEngineProvider)

The Function that will return the QuicSslEngine that should be used for the QuicChannel.

final <A> QuicServer

streamAttr(AttributeKey<A> key, @Nullable A value)

Injects default attribute to the future QuicStreamChannel.

QuicServer

streamObserve(ConnectionObserver observer)

Set or add the given ConnectionObserver for each stream.

final <A> QuicServer

streamOption(ChannelOption<A> key, @Nullable A value)

Injects default options to the future QuicStreamChannel.

final QuicServer

tokenHandler(QuicTokenHandler tokenHandler)

Configure the QuicTokenHandler that is used to generate and validate tokens.

final Mono<Void>

warmup()

Based on the actual configuration, returns a Mono that triggers: an initialization of the event loop group loads the necessary native libraries for the transport By default, when method is not used, the bind operation absorbs the extra time needed to load resources.

Methods inherited from class reactor.netty.transport.Transport
attr, bindAddress, channelGroup, configuration, doOnChannelInit, duplicate, metrics, metrics, observe, option, runOn, runOn, runOn, wiretap, wiretap, wiretap, wiretap, wiretap

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details
- QuicServer
  
  public QuicServer()
Method Details
- create
  
  public static QuicServer create()
  
  Prepare a QuicServer.
  
  Returns:
  
  a QuicServer
- bind
  
  public abstract Mono<? extends Connection> bind()
  
  Binds the QuicServer and returns a Mono of Connection. If Mono is cancelled, the underlying binding will be aborted. Once the Connection has been emitted and is not necessary anymore, disposing the main server loop must be done by the user via DisposableChannel.dispose().
  
  Returns:
  
  a Mono of Connection
- bindNow
  
  public final Connection bindNow()
  
  Starts the server in a blocking fashion, and waits for it to finish initializing or the startup timeout expires (the startup timeout is 45 seconds). The returned Connection offers simple server API, including to DisposableChannel.disposeNow() shut it down in a blocking fashion.
  
  Returns:
  
  a Connection
- bindNow
  
  public final Connection bindNow(Duration timeout)
  
  Start the server in a blocking fashion, and wait for it to finish initializing or the provided startup timeout expires. The returned Connection offers simple server API, including to DisposableChannel.disposeNow() shut it down in a blocking fashion.
  
  Parameters:
  
  timeout - max startup timeout (resolution: ns)
  
  Returns:
  
  a Connection
- connectionIdAddressGenerator
  
  public final QuicServer connectionIdAddressGenerator(QuicConnectionIdGenerator connectionIdAddressGenerator)
  
  Set the QuicConnectionIdGenerator to use. Default to QuicConnectionIdGenerator.randomGenerator().
  
  Parameters:
  
  connectionIdAddressGenerator - the QuicConnectionIdGenerator to use.
  
  Returns:
  
  a QuicServer reference
- doOnConnection
  
  public final QuicServer doOnConnection(Consumer<? super QuicConnection> doOnConnection)
  
  Set or add a callback called on new remote QuicConnection.
  
  Parameters:
  
  doOnConnection - a consumer observing remote QUIC connections
  
  Returns:
  
  a QuicServer reference
- host
  
  public final QuicServer host(String host)
  
  The host to which this server should bind.
  
  Parameters:
  
  host - the host to bind to.
  
  Returns:
  
  a QuicServer reference
- port
  
  public final QuicServer port(int port)
  
  The port to which this server should bind. If a port is not specified, the system picks up an ephemeral port.
  
  Parameters:
  
  port - The port to bind to.
  
  Returns:
  
  a QuicServer reference
- tokenHandler
  
  public final QuicServer tokenHandler(QuicTokenHandler tokenHandler)
  
  Configure the QuicTokenHandler that is used to generate and validate tokens.
  
  Parameters:
  
  tokenHandler - the QuicTokenHandler to use
  
  Returns:
  
  a QuicServer
- ackDelayExponent
  
  public final QuicServer ackDelayExponent(long ackDelayExponent)
  
  Set the delay exponent used for ACKs. See set_ack_delay_exponent. Default to 3.
  
  Parameters:
  
  ackDelayExponent - the delay exponent used for ACKs.
  
  Returns:
  
  a QuicTransport reference
- activeMigration
  
  public final QuicServer activeMigration(boolean enable)
  
  Enable/disable active migration. See set_disable_active_migration. Default to true.
  
  Parameters:
  
  enable - true if migration should be enabled, false otherwise
  
  Returns:
  
  a QuicTransport reference
- congestionControlAlgorithm
  
  public final QuicServer congestionControlAlgorithm(QuicCongestionControlAlgorithm congestionControlAlgorithm)
  
  Set the congestion control algorithm to use. Default to QuicCongestionControlAlgorithm.CUBIC.
  
  Parameters:
  
  congestionControlAlgorithm - the QuicCongestionControlAlgorithm to use.
  
  Returns:
  
  a QuicTransport reference
- datagram
  
  public final QuicServer datagram(int recvQueueLen, int sendQueueLen)
  
  If configured this will enable Datagram support.
  
  Parameters:
  
  recvQueueLen - the RECV queue length.
  
  sendQueueLen - the SEND queue length.
  
  Returns:
  
  a QuicTransport reference
- doOnBind
  
  public final QuicServer doOnBind(Consumer<? super QuicServerConfig> doOnBind)
  
  Set or add a callback called when QuicTransport is about to start listening for incoming traffic.
  
  Parameters:
  
  doOnBind - a consumer observing connected events
  
  Returns:
  
  a QuicTransport reference
- doOnBound
  
  public final QuicServer doOnBound(Consumer<? super Connection> doOnBound)
  
  Set or add a callback called after QuicTransport has been started.
  
  Parameters:
  
  doOnBound - a consumer observing connected events
  
  Returns:
  
  a QuicTransport reference
- doOnUnbound
  
  public final QuicServer doOnUnbound(Consumer<? super Connection> doOnUnbound)
  
  Set or add a callback called after QuicTransport has been shutdown.
  
  Parameters:
  
  doOnUnbound - a consumer observing unbound events
  
  Returns:
  
  a QuicTransport reference
- grease
  
  public final QuicServer grease(boolean enable)
  
  Set if greasing should be enabled or not. Default to true.
  
  Parameters:
  
  enable - true if enabled, false otherwise.
  
  Returns:
  
  a QuicTransport reference
- handleStream
  
  public final QuicServer handleStream(BiFunction<? super QuicInbound,? super QuicOutbound,? extends Publisher<Void>> streamHandler)
  
  Attach an IO handler to react on incoming stream.
  Note: If an IO handler is not specified the incoming streams will be closed automatically.
  
  Parameters:
  
  streamHandler - an IO handler that can dispose underlying connection when Publisher terminates.
  
  Returns:
  
  a QuicTransport reference
- hystart
  
  public final QuicServer hystart(boolean enable)
  
  Enable/disable Hystart. See enable_hystart. Default to true.
  
  Parameters:
  
  enable - true if Hystart should be enabled
  
  Returns:
  
  a QuicTransport reference
- idleTimeout
  
  public final QuicServer idleTimeout(Duration idleTimeout)
  
  Set the maximum idle timeout (resolution: ms) See set_max_idle_timeout.
  By default idleTimeout is not specified.
  
  Parameters:
  
  idleTimeout - the maximum idle timeout (resolution: ms)
  
  Returns:
  
  a QuicTransport reference
- initialSettings
  
  public final QuicServer initialSettings(Consumer<QuicInitialSettingsSpec.Builder> initialSettings)
  
  Configure QUIC initial settings.
  
  Parameters:
  
  initialSettings - configures QUIC initial settings
  
  Returns:
  
  a QuicTransport reference
- localConnectionIdLength
  
  public final QuicServer localConnectionIdLength(int localConnectionIdLength)
  
  Sets the local connection id length that is used. Default 20, which is also the maximum that is supported.
  
  Parameters:
  
  localConnectionIdLength - the length of local generated connections ids
  
  Returns:
  
  a QuicTransport reference
- maxAckDelay
  
  public final QuicServer maxAckDelay(Duration maxAckDelay)
  
  Set max ACK delay (resolution: ms). See set_max_ack_delay. Default to 25 ms.
  
  Parameters:
  
  maxAckDelay - the max ACK delay (resolution: ms)
  
  Returns:
  
  a QuicTransport reference
- maxRecvUdpPayloadSize
  
  public final QuicServer maxRecvUdpPayloadSize(long maxRecvUdpPayloadSize)
  
  See set_max_recv_udp_payload_size. The default value is 65527.
  
  Parameters:
  
  maxRecvUdpPayloadSize - the maximum payload size that is advertised to the remote peer.
  
  Returns:
  
  a QuicTransport reference
- maxSendUdpPayloadSize
  
  public final QuicServer maxSendUdpPayloadSize(long maxSendUdpPayloadSize)
  
  See set_max_send_udp_payload_size. The default and minimum value is 1200.
  
  Parameters:
  
  maxSendUdpPayloadSize - the maximum payload size that is advertised to the remote peer.
  
  Returns:
  
  a QuicTransport reference
- secure
  
  public final QuicServer secure(QuicSslContext sslContext)
  
  The QuicSslContext that will be used to create QuicSslEngines for QuicChannels.
  
  Parameters:
  
  sslContext - the QuicSslContext
  
  Returns:
  
  a QuicTransport reference
- secure
  
  public final QuicServer secure(Function<QuicChannel,? extends QuicSslEngine> sslEngineProvider)
  
  The Function that will return the QuicSslEngine that should be used for the QuicChannel.
  
  Parameters:
  
  sslEngineProvider - the Function that will return the QuicSslEngine that should be used for the QuicChannel
  
  Returns:
  
  a QuicTransport reference
- streamAttr
  
  public final <A> QuicServer streamAttr(AttributeKey<A> key, @Nullable A value)
  
  Injects default attribute to the future QuicStreamChannel. It will be available via AttributeMap.attr(AttributeKey). If the value is null, the attribute of the specified key is removed.
  Type Parameters:
  
  A - the attribute type
  
  Parameters:
  
  key - the attribute key
  
  value - the attribute value - null to remove a key
  
  Returns:
  
  a QuicTransport reference
  
  See Also:
  
  QuicStreamChannelBootstrap.attr(AttributeKey, Object)
  
  QuicChannelBootstrap.streamAttr(AttributeKey, Object)
- streamObserve
  
  public QuicServer streamObserve(ConnectionObserver observer)
  
  Set or add the given ConnectionObserver for each stream.
  
  Parameters:
  
  observer - the ConnectionObserver addition
  
  Returns:
  
  a QuicTransport reference
- streamOption
  
  public final <A> QuicServer streamOption(ChannelOption<A> key, @Nullable A value)
  
  Injects default options to the future QuicStreamChannel. It will be available via QuicStreamChannel.config(). If the value is null, the attribute of the specified key is removed.
  Type Parameters:
  
  A - the option type
  
  Parameters:
  
  key - the option key
  
  value - the option value - null to remove a key
  
  Returns:
  
  a QuicTransport reference
  
  See Also:
  
  QuicStreamChannelBootstrap.option(ChannelOption, Object)
  
  QuicChannelBootstrap.streamOption(ChannelOption, Object)
- warmup
  
  public final Mono<Void> warmup()
  Based on the actual configuration, returns a Mono that triggers:
  
  an initialization of the event loop group
  
  loads the necessary native libraries for the transport
  
  By default, when method is not used, the bind operation absorbs the extra time needed to load resources.
  Returns:
  
  a Mono representing the completion of the warmup

Class QuicServer

Constructor Summary

Method Summary

Methods inherited from class reactor.netty.transport.Transport

Methods inherited from class java.lang.Object

Constructor Details

QuicServer

Method Details

create

bind

bindNow

bindNow

connectionIdAddressGenerator

doOnConnection

host

port

tokenHandler

ackDelayExponent

activeMigration

congestionControlAlgorithm

datagram

doOnBind

doOnBound

doOnUnbound

grease

handleStream

hystart

idleTimeout

initialSettings

localConnectionIdLength

maxAckDelay

maxRecvUdpPayloadSize

maxSendUdpPayloadSize

secure

secure

streamAttr

streamObserve

streamOption

warmup