reactor.netty.resources

Class PooledConnectionProvider<T extends Connection>

java.lang.Object

reactor.netty.resources.PooledConnectionProvider<T>

Type Parameters:

T - the poolable resource

All Implemented Interfaces:

Disposable, ConnectionProvider

public abstract class PooledConnectionProvider<T extends Connection>
extends Object
implements ConnectionProvider

Base ConnectionProvider implementation.

Since:

1.0.0

Author:

Violeta Georgieva

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	PooledConnectionProvider.PoolFactory<T extends Connection>

Nested classes/interfaces inherited from interface reactor.netty.resources.ConnectionProvider

ConnectionProvider.Builder, ConnectionProvider.ConnectionPoolSpec<SPEC extends ConnectionProvider.ConnectionPoolSpec<SPEC>>, ConnectionProvider.HostSpecificSpec, ConnectionProvider.MeterRegistrar

Nested classes/interfaces inherited from interface reactor.core.Disposable

Disposable.Composite, Disposable.Swap

Field Summary

Fields inherited from interface reactor.netty.resources.ConnectionProvider

DEFAULT_POOL_ACQUIRE_TIMEOUT, DEFAULT_POOL_LEASING_STRATEGY, DEFAULT_POOL_MAX_CONNECTIONS, DEFAULT_POOL_MAX_IDLE_TIME, DEFAULT_POOL_MAX_LIFE_TIME, LEASING_STRATEGY_FIFO, LEASING_STRATEGY_LIFO

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	PooledConnectionProvider(ConnectionProvider.Builder builder)

Method Summary

Modifier and Type	Method and Description
Mono<? extends Connection>	acquire(TransportConfig config, ConnectionObserver connectionObserver, java.util.function.Supplier<? extends SocketAddress> remote, AddressResolverGroup<?> resolverGroup) Return an existing or new Connection on subscribe.
protected abstract CoreSubscriber<reactor.pool.PooledRef<T>>	createDisposableAcquire(TransportConfig config, ConnectionObserver connectionObserver, long pendingAcquireTimeout, reactor.pool.InstrumentedPool<T> pool, MonoSink<Connection> sink)
protected abstract reactor.pool.InstrumentedPool<T>	createPool(TransportConfig config, PooledConnectionProvider.PoolFactory<T> poolFactory, SocketAddress remoteAddress, AddressResolverGroup<?> resolverGroup)
Mono<Void>	disposeLater() Returns a Mono that triggers the disposal of the ConnectionProvider when subscribed to.
void	disposeWhen(SocketAddress address) Dispose all connection pools for the specified remote address.
boolean	isDisposed()
protected static void	logPoolState(Channel channel, reactor.pool.InstrumentedPool<? extends Connection> pool, String msg)
protected static void	logPoolState(Channel channel, reactor.pool.InstrumentedPool<? extends Connection> pool, String msg, Throwable t)
int	maxConnections() Returns the maximum number of connections before starting pending
protected PooledConnectionProvider.PoolFactory<T>	poolFactory(SocketAddress remoteAddress)

Methods inherited from class java.lang.Object

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

Methods inherited from interface reactor.netty.resources.ConnectionProvider

builder, create, create, dispose, maxConnectionsPerHost, newConnection

Constructor Detail

PooledConnectionProvider

protected PooledConnectionProvider(ConnectionProvider.Builder builder)

Method Detail

acquire

public final Mono<? extends Connection> acquire(TransportConfig config,
                                                ConnectionObserver connectionObserver,
                                                @Nullable
                                                java.util.function.Supplier<? extends SocketAddress> remote,
                                                @Nullable
                                                AddressResolverGroup<?> resolverGroup)

Description copied from interface: ConnectionProvider

Return an existing or new Connection on subscribe.

Specified by:

acquire in interface ConnectionProvider

Parameters:

config - the transport configuration

connectionObserver - the ConnectionObserver

remote - the SocketAddress to connect to

resolverGroup - the resolver which will resolve the address of the unresolved named address

Returns:

an existing or new Mono of Connection

disposeLater

public final Mono<Void> disposeLater()

Description copied from interface: ConnectionProvider

Returns a Mono that triggers the disposal of the ConnectionProvider when subscribed to.

This method has NOOP default implementation. ConnectionProvider implementations may decide to provide more specific implementation.

Specified by:

disposeLater in interface ConnectionProvider

Returns:

a Mono representing the completion of the ConnectionProvider disposal.

disposeWhen

public final void disposeWhen(SocketAddress address)

Description copied from interface: ConnectionProvider

Dispose all connection pools for the specified remote address.

This method has NOOP default implementation. ConnectionProvider implementations may decide to provide more specific implementation.

Specified by:

disposeWhen in interface ConnectionProvider

Parameters:

address - the remote address

isDisposed

public final boolean isDisposed()

Specified by:

isDisposed in interface Disposable

maxConnections

public int maxConnections()

Description copied from interface: ConnectionProvider

Returns the maximum number of connections before starting pending

Specified by:

maxConnections in interface ConnectionProvider

Returns:

the maximum number of connections before starting pending

createDisposableAcquire

protected abstract CoreSubscriber<reactor.pool.PooledRef<T>> createDisposableAcquire(TransportConfig config,
                                                                                     ConnectionObserver connectionObserver,
                                                                                     long pendingAcquireTimeout,
                                                                                     reactor.pool.InstrumentedPool<T> pool,
                                                                                     MonoSink<Connection> sink)

createPool

protected abstract reactor.pool.InstrumentedPool<T> createPool(TransportConfig config,
                                                               PooledConnectionProvider.PoolFactory<T> poolFactory,
                                                               SocketAddress remoteAddress,
                                                               AddressResolverGroup<?> resolverGroup)

poolFactory

protected PooledConnectionProvider.PoolFactory<T> poolFactory(SocketAddress remoteAddress)

logPoolState

protected static void logPoolState(Channel channel,
                                   reactor.pool.InstrumentedPool<? extends Connection> pool,
                                   String msg)

logPoolState

protected static void logPoolState(Channel channel,
                                   reactor.pool.InstrumentedPool<? extends Connection> pool,
                                   String msg,
                                   @Nullable
                                   Throwable t)