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:

reactor.core.Disposable, ConnectionProvider

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

Base ConnectionProvider implementation.

Since:

1.0.0

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

reactor.core.Disposable.Composite, reactor.core.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
reactor.core.publisher.Mono<? extends Connection>	acquire(TransportConfig config, ConnectionObserver connectionObserver, java.util.function.Supplier<? extends java.net.SocketAddress> remote, io.netty.resolver.AddressResolverGroup<?> resolverGroup) Return an existing or new Connection on subscribe.
protected abstract reactor.core.CoreSubscriber<reactor.pool.PooledRef<T>>	createDisposableAcquire(TransportConfig config, ConnectionObserver connectionObserver, long pendingAcquireTimeout, reactor.pool.InstrumentedPool<T> pool, reactor.core.publisher.MonoSink<Connection> sink)
protected abstract reactor.pool.InstrumentedPool<T>	createPool(TransportConfig config, PooledConnectionProvider.PoolFactory<T> poolFactory, java.net.SocketAddress remoteAddress, io.netty.resolver.AddressResolverGroup<?> resolverGroup)
reactor.core.publisher.Mono<java.lang.Void>	disposeLater() Returns a Mono that triggers the disposal of the ConnectionProvider when subscribed to.
void	disposeWhen(java.net.SocketAddress address) Dispose all connection pools for the specified remote address.
boolean	isDisposed()
int	maxConnections() Returns the maximum number of connections before starting pending
protected PooledConnectionProvider.PoolFactory<T>	poolFactory(java.net.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 reactor.core.publisher.Mono<? extends Connection> acquire(TransportConfig config,
                                                                       ConnectionObserver connectionObserver,
                                                                       @Nullable
                                                                       java.util.function.Supplier<? extends java.net.SocketAddress> remote,
                                                                       @Nullable
                                                                       io.netty.resolver.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 reactor.core.publisher.Mono<java.lang.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(java.net.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 reactor.core.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 reactor.core.CoreSubscriber<reactor.pool.PooledRef<T>> createDisposableAcquire(TransportConfig config,
                                                                                                  ConnectionObserver connectionObserver,
                                                                                                  long pendingAcquireTimeout,
                                                                                                  reactor.pool.InstrumentedPool<T> pool,
                                                                                                  reactor.core.publisher.MonoSink<Connection> sink)

createPool

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

poolFactory

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