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.AllocationStrategy<A extends ConnectionProvider.AllocationStrategy<A>>, ConnectionProvider.Builder, ConnectionProvider.ConnectionMetadata, 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

Modifier and Type	Field and Description
protected static String	CONTEXT_CALLER_EVENTLOOP Context key used to propagate the caller event loop in the connection pool subscription.

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, 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, Context currentContext)
protected CoreSubscriber<reactor.pool.PooledRef<T>>	createDisposableAcquire(TransportConfig config, ConnectionObserver connectionObserver, long pendingAcquireTimeout, reactor.pool.InstrumentedPool<T> pool, SocketAddress remoteAddress, MonoSink<Connection> sink, Context currentContext)
protected reactor.pool.InstrumentedPool<T>	createPool(String id, TransportConfig config, PooledConnectionProvider.PoolFactory<T> poolFactory, SocketAddress remoteAddress, AddressResolverGroup<?> resolverGroup)
protected abstract reactor.pool.InstrumentedPool<T>	createPool(TransportConfig config, PooledConnectionProvider.PoolFactory<T> poolFactory, SocketAddress remoteAddress, AddressResolverGroup<?> resolverGroup)
protected void	deRegisterDefaultMetrics(String id, SocketAddress remoteAddress)
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.
Map<SocketAddress,Integer>	maxConnectionsPerHost() Returns the maximum number of connections per host before starting pending.
ConnectionProvider.Builder	mutate() Returns a builder to mutate properties of this ConnectionProvider.
String	name() Returns ConnectionProvider name used for metrics.
void	onDispose(Mono<Void> disposeMono)
protected PooledConnectionProvider.PoolFactory<T>	poolFactory(SocketAddress remoteAddress)
protected void	registerDefaultMetrics(String id, SocketAddress remoteAddress, reactor.pool.InstrumentedPool.PoolMetrics metrics)

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, create, dispose, newConnection

Field Detail

CONTEXT_CALLER_EVENTLOOP

protected static final String CONTEXT_CALLER_EVENTLOOP

Context key used to propagate the caller event loop in the connection pool subscription.

See Also:

Constant Field Values

Constructor Detail

PooledConnectionProvider

protected PooledConnectionProvider(ConnectionProvider.Builder builder)

Method Detail

acquire

public final Mono<? extends Connection> acquire(TransportConfig config,
                                                ConnectionObserver connectionObserver,
                                                @Nullable
                                                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

maxConnectionsPerHost

public Map<SocketAddress,Integer> maxConnectionsPerHost()

Description copied from interface: ConnectionProvider

Returns the maximum number of connections per host before starting pending.

Specified by:

maxConnectionsPerHost in interface ConnectionProvider

Returns:

the maximum number of connections per host before starting pending

mutate

public ConnectionProvider.Builder mutate()

Description copied from interface: ConnectionProvider

Returns a builder to mutate properties of this ConnectionProvider.

Specified by:

mutate in interface ConnectionProvider

Returns:

a builder to mutate properties of this ConnectionProvider

name

public String name()

Description copied from interface: ConnectionProvider

Returns ConnectionProvider name used for metrics.

Specified by:

name in interface ConnectionProvider

Returns:

ConnectionProvider name used for metrics

onDispose

public void onDispose(Mono<Void> disposeMono)

createDisposableAcquire

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

createDisposableAcquire

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

createPool

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

createPool

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

poolFactory

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

registerDefaultMetrics

protected void registerDefaultMetrics(String id,
                                      SocketAddress remoteAddress,
                                      reactor.pool.InstrumentedPool.PoolMetrics metrics)

deRegisterDefaultMetrics

protected void deRegisterDefaultMetrics(String id,
                                        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)