org.apache.pekko.http.scaladsl.settings

Class ConnectionPoolSettings

java.lang.Object

org.apache.pekko.http.javadsl.settings.ConnectionPoolSettings

org.apache.pekko.http.scaladsl.settings.ConnectionPoolSettings

Direct Known Subclasses:

ConnectionPoolSettingsImpl

public abstract class ConnectionPoolSettings
extends ConnectionPoolSettings

Public API but not intended for subclassing

Constructor Summary

Constructors

Constructor and Description
ConnectionPoolSettings()

Method Summary

Modifier and Type	Method and Description
ConnectionPoolSettings	appendHostOverride(java.lang.String hostPattern, ConnectionPoolSettings settings)
static ConnectionPoolSettingsImpl	apply(com.typesafe.config.Config config)
static ConnectionPoolSettingsImpl	apply(java.lang.String configOverrides)
abstract scala.concurrent.duration.FiniteDuration	baseConnectionBackoff()
abstract ClientConnectionSettings	connectionSettings()
ConnectionPoolSettings	forHost(java.lang.String host) This checks to see if there's a matching host override.
abstract scala.collection.immutable.Seq<scala.Tuple2<scala.util.matching.Regex,ConnectionPoolSettings>>	hostOverrides()
abstract scala.concurrent.duration.Duration	idleTimeout()
abstract scala.concurrent.duration.Duration	keepAliveTimeout()
abstract scala.concurrent.duration.FiniteDuration	maxConnectionBackoff()
abstract scala.concurrent.duration.Duration	maxConnectionLifetime()
abstract int	maxConnections()
abstract int	maxOpenRequests()
abstract int	maxRetries()
abstract int	minConnections()
abstract int	pipeliningLimit()
abstract scala.concurrent.duration.Duration	responseEntitySubscriptionTimeout() The time after which the pool will drop an entity automatically if it wasn't read or discarded
ClientTransport	transport() Deprecated. Deprecated in favor of connectionSettings.transport. Since Akka HTTP 10.1.0.
ConnectionPoolSettings	withBaseConnectionBackoff(scala.concurrent.duration.FiniteDuration newValue)
ConnectionPoolSettings	withConnectionSettings(ClientConnectionSettings newValue)
ConnectionPoolSettings	withHostOverrides(scala.collection.immutable.Seq<scala.Tuple2<java.lang.String,ConnectionPoolSettings>> hostOverrides)
ConnectionPoolSettings	withIdleTimeout(scala.concurrent.duration.Duration newValue)
ConnectionPoolSettings	withKeepAliveTimeout(scala.concurrent.duration.Duration newValue)
ConnectionPoolSettings	withMaxConnectionBackoff(scala.concurrent.duration.FiniteDuration newValue)
ConnectionPoolSettings	withMaxConnectionLifetime(scala.concurrent.duration.Duration newValue)
ConnectionPoolSettings	withMaxConnections(int n)
ConnectionPoolSettings	withMaxOpenRequests(int newValue)
ConnectionPoolSettings	withMaxRetries(int n)
ConnectionPoolSettings	withMinConnections(int n)
ConnectionPoolSettings	withPipeliningLimit(int newValue) Client-side pipelining is not currently supported, see https://github.com/akka/akka-http/issues/32
ConnectionPoolSettings	withResponseEntitySubscriptionTimeout(scala.concurrent.duration.Duration newValue)
ConnectionPoolSettings	withTransport(ClientTransport newValue) Since Akka HTTP 10.1.0, the transport is configured in ClientConnectionSettings.
abstract ConnectionPoolSettings	withUpdatedConnectionSettings(scala.Function1<ClientConnectionSettings,ClientConnectionSettings> f)

Methods inherited from class org.apache.pekko.http.javadsl.settings.ConnectionPoolSettings

appendHostOverride, create, create, create, getBaseConnectionBackoff, getConnectionSettings, getIdleTimeout, getKeepAliveTimeout, getMaxConnectionBackoff, getMaxConnectionLifetime, getMaxConnections, getMaxOpenRequests, getMaxRetries, getMinConnections, getPipeliningLimit, getResponseEntitySubscriptionTimeout, withConnectionSettings, withHostOverrides, withTransport

Methods inherited from class java.lang.Object

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

Constructor Detail

ConnectionPoolSettings

public ConnectionPoolSettings()

Method Detail

apply

public static ConnectionPoolSettingsImpl apply(com.typesafe.config.Config config)

apply

public static ConnectionPoolSettingsImpl apply(java.lang.String configOverrides)

maxConnections

public abstract int maxConnections()

minConnections

public abstract int minConnections()

maxRetries

public abstract int maxRetries()

maxOpenRequests

public abstract int maxOpenRequests()

pipeliningLimit

public abstract int pipeliningLimit()

baseConnectionBackoff

public abstract scala.concurrent.duration.FiniteDuration baseConnectionBackoff()

maxConnectionBackoff

public abstract scala.concurrent.duration.FiniteDuration maxConnectionBackoff()

idleTimeout

public abstract scala.concurrent.duration.Duration idleTimeout()

keepAliveTimeout

public abstract scala.concurrent.duration.Duration keepAliveTimeout()

connectionSettings

public abstract ClientConnectionSettings connectionSettings()

maxConnectionLifetime

public abstract scala.concurrent.duration.Duration maxConnectionLifetime()

hostOverrides

public abstract scala.collection.immutable.Seq<scala.Tuple2<scala.util.matching.Regex,ConnectionPoolSettings>> hostOverrides()

forHost

public ConnectionPoolSettings forHost(java.lang.String host)

This checks to see if there's a matching host override. When multiple patterns match, the first matching set of overrides is selected.

Parameters:

host - (undocumented)

Returns:

(undocumented)

transport

public ClientTransport transport()

Deprecated. Deprecated in favor of connectionSettings.transport. Since Akka HTTP 10.1.0.

The underlying transport used to connect to hosts. By default ClientTransport.TCP is used.

Returns:

(undocumented)

responseEntitySubscriptionTimeout

public abstract scala.concurrent.duration.Duration responseEntitySubscriptionTimeout()

The time after which the pool will drop an entity automatically if it wasn't read or discarded

withHostOverrides

public ConnectionPoolSettings withHostOverrides(scala.collection.immutable.Seq<scala.Tuple2<java.lang.String,ConnectionPoolSettings>> hostOverrides)

appendHostOverride

public ConnectionPoolSettings appendHostOverride(java.lang.String hostPattern,
                                                 ConnectionPoolSettings settings)

withMaxConnections

public ConnectionPoolSettings withMaxConnections(int n)

Specified by:

withMaxConnections in class ConnectionPoolSettings

withMinConnections

public ConnectionPoolSettings withMinConnections(int n)

Specified by:

withMinConnections in class ConnectionPoolSettings

withMaxRetries

public ConnectionPoolSettings withMaxRetries(int n)

Specified by:

withMaxRetries in class ConnectionPoolSettings

withMaxOpenRequests

public ConnectionPoolSettings withMaxOpenRequests(int newValue)

Specified by:

withMaxOpenRequests in class ConnectionPoolSettings

withBaseConnectionBackoff

public ConnectionPoolSettings withBaseConnectionBackoff(scala.concurrent.duration.FiniteDuration newValue)

Specified by:

withBaseConnectionBackoff in class ConnectionPoolSettings

withMaxConnectionBackoff

public ConnectionPoolSettings withMaxConnectionBackoff(scala.concurrent.duration.FiniteDuration newValue)

Specified by:

withMaxConnectionBackoff in class ConnectionPoolSettings

withPipeliningLimit

public ConnectionPoolSettings withPipeliningLimit(int newValue)

Description copied from class: ConnectionPoolSettings

Client-side pipelining is not currently supported, see https://github.com/akka/akka-http/issues/32

Specified by:

withPipeliningLimit in class ConnectionPoolSettings

withIdleTimeout

public ConnectionPoolSettings withIdleTimeout(scala.concurrent.duration.Duration newValue)

Specified by:

withIdleTimeout in class ConnectionPoolSettings

withKeepAliveTimeout

public ConnectionPoolSettings withKeepAliveTimeout(scala.concurrent.duration.Duration newValue)

Specified by:

withKeepAliveTimeout in class ConnectionPoolSettings

withMaxConnectionLifetime

public ConnectionPoolSettings withMaxConnectionLifetime(scala.concurrent.duration.Duration newValue)

Specified by:

withMaxConnectionLifetime in class ConnectionPoolSettings

withConnectionSettings

public ConnectionPoolSettings withConnectionSettings(ClientConnectionSettings newValue)

withResponseEntitySubscriptionTimeout

public ConnectionPoolSettings withResponseEntitySubscriptionTimeout(scala.concurrent.duration.Duration newValue)

Specified by:

withResponseEntitySubscriptionTimeout in class ConnectionPoolSettings

withTransport

public ConnectionPoolSettings withTransport(ClientTransport newValue)

Since Akka HTTP 10.1.0, the transport is configured in ClientConnectionSettings. This method is a shortcut for withUpdatedConnectionSettings(_.withTransport(newTransport)).

Parameters:

newValue - (undocumented)

Returns:

(undocumented)

withUpdatedConnectionSettings

public abstract ConnectionPoolSettings withUpdatedConnectionSettings(scala.Function1<ClientConnectionSettings,ClientConnectionSettings> f)