QuicClient (reactor-netty 1.0.48-SNAPSHOT)

java.lang.Object
- reactor.netty.transport.Transport<T,CONF>
- - reactor.netty.incubator.quic.QuicClient

public abstract class QuicClient
extends Transport<T,CONF>

A QuicClient allows building in a safe immutable way a QUIC client that is materialized and connecting when connect() is ultimately called.

Example:

 
     QuicClient.create()
               .port(7777)
               .bindAddress(() -> new InetSocketAddress(0))
               .wiretap(true)
               .secure(clientCtx)
               .idleTimeout(Duration.ofSeconds(5))
               .initialSettings(spec ->
                   spec.maxData(10000000)
                       .maxStreamDataBidirectionalLocal(1000000))
               .connectNow();

Author:: Violeta Georgieva

Constructor Summary

Constructors
Constructor and Description

QuicClient()

Constructors
Constructor and Description
`QuicClient()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`T`	`ackDelayExponent(long ackDelayExponent)` Set the delay exponent used for ACKs.
`T`	`activeMigration(boolean enable)` Enable/disable active migration.
`T`	`congestionControlAlgorithm(io.netty.incubator.codec.quic.QuicCongestionControlAlgorithm congestionControlAlgorithm)` Set the congestion control algorithm to use.
`abstract Mono<? extends QuicConnection>`	`connect()` Connect the `QuicClient` and return a `Mono` of `QuicConnection`.
`QuicConnection`	`connectNow()` Block the `QuicClient` and return a `QuicConnection`.
`QuicConnection`	`connectNow(Duration timeout)` Block the `QuicClient` and return a `QuicConnection`.
`static QuicClient`	`create()` Prepare a `QuicClient`.
`T`	`datagram(int recvQueueLen, int sendQueueLen)` If configured this will enable Datagram support.
`T`	`doOnBind(Consumer<? super CONF> doOnBind)` Set or add a callback called when `QuicTransport` is about to start listening for incoming traffic.
`T`	`doOnBound(Consumer<? super Connection> doOnBound)` Set or add a callback called after `QuicTransport` has been started.
`QuicClient`	`doOnConnect(Consumer<? super QuicClientConfig> doOnConnect)` Set or add a callback called when `QuicClient` is about to connect to the remote endpoint.
`QuicClient`	`doOnConnected(Consumer<? super QuicConnection> doOnConnected)` Set or add a callback called after `QuicConnection` has been connected.
`QuicClient`	`doOnDisconnected(Consumer<? super QuicConnection> doOnDisconnected)` Set or add a callback called after `QuicConnection` has been disconnected.
`T`	`doOnUnbound(Consumer<? super Connection> doOnUnbound)` Set or add a callback called after `QuicTransport` has been shutdown.
`T`	`grease(boolean enable)` Set if greasing should be enabled or not.
`T`	`handleStream(BiFunction<? super QuicInbound,? super QuicOutbound,? extends Publisher<Void>> streamHandler)` Attach an IO handler to react on incoming stream.
`QuicClient`	`host(String host)` The host to which this client should connect.
`T`	`hystart(boolean enable)` Enable/disable Hystart.
`T`	`idleTimeout(Duration idleTimeout)` Set the maximum idle timeout (resolution: ms) See set_max_idle_timeout.
`T`	`initialSettings(Consumer<QuicInitialSettingsSpec.Builder> initialSettings)` Configure QUIC initial settings.
`T`	`localConnectionIdLength(int localConnectionIdLength)` Sets the local connection id length that is used.
`T`	`maxAckDelay(Duration maxAckDelay)` Set max ACK delay (resolution: ms).
`T`	`maxRecvUdpPayloadSize(long maxRecvUdpPayloadSize)` See set_max_recv_udp_payload_size.
`T`	`maxSendUdpPayloadSize(long maxSendUdpPayloadSize)` See set_max_send_udp_payload_size.
`QuicClient`	`port(int port)` The port to which this client should connect.
`QuicClient`	`remoteAddress(Supplier<? extends SocketAddress> remoteAddressSupplier)` The address to which this client should connect on each subscribe.
`T`	`secure(Function<io.netty.incubator.codec.quic.QuicChannel,? extends io.netty.incubator.codec.quic.QuicSslEngine> sslEngineProvider)` The `Function` that will return the `QuicSslEngine` that should be used for the `QuicChannel`.
`T`	`secure(io.netty.incubator.codec.quic.QuicSslContext sslContext)` The `QuicSslContext` that will be used to create `QuicSslEngine`s for `QuicChannel`s.
`<A> T`	`streamAttr(AttributeKey<A> key, A value)` Injects default attribute to the future `QuicStreamChannel`.
`T`	`streamObserve(ConnectionObserver observer)` Set or add the given `ConnectionObserver` for each stream.
`<A> T`	`streamOption(ChannelOption<A> key, A value)` Injects default options to the future `QuicStreamChannel`.
`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 Detail
  - QuicClient
```
public QuicClient()
```
- Method Detail
  - create
```
public static QuicClient create()
```
    Prepare a QuicClient.
    
    Returns:
    
    a QuicClient
  - connect
```
public abstract Mono<? extends QuicConnection> connect()
```
    Connect the QuicClient and return a Mono of QuicConnection. If Mono is cancelled, the underlying connection will be aborted. Once the QuicConnection has been emitted and is not necessary anymore, disposing must be done by the user via DisposableChannel.dispose().
    
    Returns:
    
    a Mono of QuicConnection
  - connectNow
```
public final QuicConnection connectNow()
```
    Block the QuicClient and return a QuicConnection. Disposing must be done by the user via DisposableChannel.dispose(). The max connection timeout is 45 seconds.
    
    Returns:
    
    a QuicConnection
  - connectNow
```
public final QuicConnection connectNow(Duration timeout)
```
    Block the QuicClient and return a QuicConnection. Disposing must be done by the user via DisposableChannel.dispose().
    
    Parameters:
    
    timeout - connect timeout (resolution: ns)
    
    Returns:
    
    a QuicConnection
  - doOnConnect
```
public final QuicClient doOnConnect(Consumer<? super QuicClientConfig> doOnConnect)
```
    Set or add a callback called when QuicClient is about to connect to the remote endpoint.
    
    Parameters:
    
    doOnConnect - a consumer observing connect events
    
    Returns:
    
    a QuicClient reference
  - doOnConnected
```
public final QuicClient doOnConnected(Consumer<? super QuicConnection> doOnConnected)
```
    Set or add a callback called after QuicConnection has been connected.
    
    Parameters:
    
    doOnConnected - a consumer observing connected events
    
    Returns:
    
    a QuicClient reference
  - doOnDisconnected
```
public final QuicClient doOnDisconnected(Consumer<? super QuicConnection> doOnDisconnected)
```
    Set or add a callback called after QuicConnection has been disconnected.
    
    Parameters:
    
    doOnDisconnected - a consumer observing disconnected events
    
    Returns:
    
    a QuicClient reference
  - host
```
public final QuicClient host(String host)
```
    The host to which this client should connect.
    
    Parameters:
    
    host - the host to connect to
    
    Returns:
    
    a QuicClient reference
  - port
```
public final QuicClient port(int port)
```
    The port to which this client should connect. If a port is not specified, the default port 12012 is used.
    Note: The port can be specified also with QUIC_PORT environment variable.
    
    Parameters:
    
    port - the port to connect to
    
    Returns:
    
    a QuicClient reference
  - remoteAddress
```
public final QuicClient remoteAddress(Supplier<? extends SocketAddress> remoteAddressSupplier)
```
    The address to which this client should connect on each subscribe.
    
    Parameters:
    
    remoteAddressSupplier - A supplier of the address to connect to.
    
    Returns:
    
    a QuicClient
  - ackDelayExponent
```
public final T 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 T 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 T congestionControlAlgorithm(io.netty.incubator.codec.quic.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 T 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 T doOnBind(Consumer<? super CONF> 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 T 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 T 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 T 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 T 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 T 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 T 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 T initialSettings(Consumer<QuicInitialSettingsSpec.Builder> initialSettings)
```
    Configure QUIC initial settings.
    
    Parameters:
    
    initialSettings - configures QUIC initial settings
    
    Returns:
    
    a QuicTransport reference
  - localConnectionIdLength
```
public final T 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 T 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 T 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 T 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 T secure(io.netty.incubator.codec.quic.QuicSslContext sslContext)
```
    The QuicSslContext that will be used to create QuicSslEngines for QuicChannels.
    
    Parameters:
    
    sslContext - the QuicSslContext
    
    Returns:
    
    a QuicTransport reference
  - secure
```
public final T secure(Function<io.netty.incubator.codec.quic.QuicChannel,? extends io.netty.incubator.codec.quic.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> T 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 T 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> T 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 QuicClient

Constructor Summary

Method Summary

Methods inherited from class reactor.netty.transport.Transport

Methods inherited from class java.lang.Object

Constructor Detail

QuicClient

Method Detail

create

connect

connectNow

connectNow

doOnConnect

doOnConnected

doOnDisconnected

host

port

remoteAddress

ackDelayExponent

activeMigration

congestionControlAlgorithm

datagram

doOnBind

doOnBound

doOnUnbound

grease

handleStream

hystart

idleTimeout

initialSettings

localConnectionIdLength

maxAckDelay

maxRecvUdpPayloadSize

maxSendUdpPayloadSize

secure

secure

streamAttr

streamObserve

streamOption

warmup