java.lang.Object
- akka.stream.scaladsl.Tcp

All Implemented Interfaces:: Extension

public final class Tcp
extends java.lang.Object
implements Extension

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`Tcp.IncomingConnection`	Represents an accepted incoming TCP connection.
`static class`	`Tcp.IncomingConnection$`
`static class`	`Tcp.OutgoingConnection`	Represents a prospective outgoing TCP connection.
`static class`	`Tcp.OutgoingConnection$`
`static class`	`Tcp.ServerBinding`	Represents a successful TCP server binding.
`static class`	`Tcp.ServerBinding$`

Constructor Summary

Constructors
Constructor Description

Tcp(ExtendedActorSystem system)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static Tcp`	`apply(ActorSystem system)`
`Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>>`	`bind(java.lang.String interface_, int port, int backlog, scala.collection.immutable.Iterable<Inet.SocketOption> options, boolean halfClose, scala.concurrent.duration.Duration idleTimeout)`	Creates a `Tcp.ServerBinding` instance which represents a prospective TCP server binding on the given `endpoint`.
`int`	`bind$default$3()`
`scala.collection.immutable.Iterable<Inet.SocketOption>`	`bind$default$4()`
`boolean`	`bind$default$5()`
`scala.concurrent.duration.Duration`	`bind$default$6()`
`scala.concurrent.Future<Tcp.ServerBinding>`	`bindAndHandle(Flow<ByteString,ByteString,?> handler, java.lang.String interface_, int port, int backlog, scala.collection.immutable.Iterable<Inet.SocketOption> options, boolean halfClose, scala.concurrent.duration.Duration idleTimeout, Materializer m)`	Creates a `Tcp.ServerBinding` instance which represents a prospective TCP server binding on the given `endpoint` handling the incoming connections using the provided Flow.
`int`	`bindAndHandle$default$4()`
`scala.collection.immutable.Iterable<Inet.SocketOption>`	`bindAndHandle$default$5()`
`boolean`	`bindAndHandle$default$6()`
`scala.concurrent.duration.Duration`	`bindAndHandle$default$7()`
`scala.concurrent.Future<Tcp.ServerBinding>`	`bindAndHandleTls(Flow<ByteString,ByteString,?> handler, java.lang.String interface_, int port, javax.net.ssl.SSLContext sslContext, TLSProtocol.NegotiateNewSession negotiateNewSession, int backlog, scala.collection.immutable.Iterable<Inet.SocketOption> options, scala.concurrent.duration.Duration idleTimeout, Materializer m)`	Deprecated. Use bindAndHandleWithTls that takes a SSLEngine factory instead.
`int`	`bindAndHandleTls$default$6()`
`scala.collection.immutable.Iterable<Inet.SocketOption>`	`bindAndHandleTls$default$7()`
`scala.concurrent.duration.Duration`	`bindAndHandleTls$default$8()`
`scala.concurrent.Future<Tcp.ServerBinding>`	`bindAndHandleWithTls(Flow<ByteString,ByteString,?> handler, java.lang.String interface_, int port, scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine, int backlog, scala.collection.immutable.Seq<Inet.SocketOption> options, scala.concurrent.duration.Duration idleTimeout, scala.Function1<javax.net.ssl.SSLSession,scala.util.Try<scala.runtime.BoxedUnit>> verifySession, TLSClosing closing, Materializer m)`	Creates a `Tcp.ServerBinding` instance which represents a prospective TCP server binding on the given `endpoint` all incoming and outgoing bytes are passed through TLS and handling the incoming connections using the provided Flow.
`scala.concurrent.Future<Tcp.ServerBinding>`	`bindAndHandleWithTls(Flow<ByteString,ByteString,?> handler, java.lang.String interface_, int port, scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine, Materializer m)`	Creates a `Tcp.ServerBinding` instance which represents a prospective TCP server binding on the given `endpoint` all incoming and outgoing bytes are passed through TLS and handling the incoming connections using the provided Flow.
`scala.concurrent.duration.FiniteDuration`	`bindShutdownTimeout()`
`Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>>`	`bindTls(java.lang.String interface_, int port, javax.net.ssl.SSLContext sslContext, TLSProtocol.NegotiateNewSession negotiateNewSession, int backlog, scala.collection.immutable.Iterable<Inet.SocketOption> options, scala.concurrent.duration.Duration idleTimeout)`	Deprecated. Use bindWithTls that takes a SSLEngine factory instead.
`int`	`bindTls$default$5()`
`scala.collection.immutable.Iterable<Inet.SocketOption>`	`bindTls$default$6()`
`scala.concurrent.duration.Duration`	`bindTls$default$7()`
`Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>>`	`bindWithTls(java.lang.String interface_, int port, scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine)`	Creates a `Tcp.ServerBinding` instance which represents a prospective TCP server binding on the given `endpoint` where all incoming and outgoing bytes are passed through TLS.
`Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>>`	`bindWithTls(java.lang.String interface_, int port, scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine, int backlog, scala.collection.immutable.Seq<Inet.SocketOption> options, scala.concurrent.duration.Duration idleTimeout, scala.Function1<javax.net.ssl.SSLSession,scala.util.Try<scala.runtime.BoxedUnit>> verifySession, TLSClosing closing)`	Creates a `Tcp.ServerBinding` instance which represents a prospective TCP server binding on the given `endpoint` where all incoming and outgoing bytes are passed through TLS.
`static Tcp`	`createExtension(ExtendedActorSystem system)`
`static boolean`	`equals(java.lang.Object other)`
`static Tcp`	`get(ActorSystem system)`
`static Tcp`	`get(ClassicActorSystemProvider system)`
`static int`	`hashCode()`
`static Tcp$`	`lookup()`
`Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>`	`outgoingConnection(java.lang.String host, int port)`	Creates an `Tcp.OutgoingConnection` without specifying options.
`Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>`	`outgoingConnection(java.net.InetSocketAddress remoteAddress, scala.Option<java.net.InetSocketAddress> localAddress, scala.collection.immutable.Iterable<Inet.SocketOption> options, boolean halfClose, scala.concurrent.duration.Duration connectTimeout, scala.concurrent.duration.Duration idleTimeout)`	Creates an `Tcp.OutgoingConnection` instance representing a prospective TCP client connection to the given endpoint.
`scala.Option<java.net.InetSocketAddress>`	`outgoingConnection$default$2()`
`scala.collection.immutable.Iterable<Inet.SocketOption>`	`outgoingConnection$default$3()`
`boolean`	`outgoingConnection$default$4()`
`scala.concurrent.duration.Duration`	`outgoingConnection$default$5()`
`scala.concurrent.duration.Duration`	`outgoingConnection$default$6()`
`Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>`	`outgoingConnectionWithTls(java.net.InetSocketAddress remoteAddress, scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine)`	Creates an `Tcp.OutgoingConnection` with TLS.
`Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>`	`outgoingConnectionWithTls(java.net.InetSocketAddress remoteAddress, scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine, scala.Option<java.net.InetSocketAddress> localAddress, scala.collection.immutable.Seq<Inet.SocketOption> options, scala.concurrent.duration.Duration connectTimeout, scala.concurrent.duration.Duration idleTimeout, scala.Function1<javax.net.ssl.SSLSession,scala.util.Try<scala.runtime.BoxedUnit>> verifySession, TLSClosing closing)`	Creates an `Tcp.OutgoingConnection` with TLS.
`Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>`	`outgoingTlsConnection(java.lang.String host, int port, javax.net.ssl.SSLContext sslContext, TLSProtocol.NegotiateNewSession negotiateNewSession)`	Deprecated. Use outgoingConnectionWithTls that takes a SSLEngine factory instead.
`Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>`	`outgoingTlsConnection(java.net.InetSocketAddress remoteAddress, javax.net.ssl.SSLContext sslContext, TLSProtocol.NegotiateNewSession negotiateNewSession, scala.Option<java.net.InetSocketAddress> localAddress, scala.collection.immutable.Iterable<Inet.SocketOption> options, scala.concurrent.duration.Duration connectTimeout, scala.concurrent.duration.Duration idleTimeout)`	Deprecated. Use outgoingConnectionWithTls that takes a SSLEngine factory instead.
`scala.Option<java.net.InetSocketAddress>`	`outgoingTlsConnection$default$4()`
`scala.collection.immutable.Iterable<Inet.SocketOption>`	`outgoingTlsConnection$default$5()`
`scala.concurrent.duration.Duration`	`outgoingTlsConnection$default$6()`
`scala.concurrent.duration.Duration`	`outgoingTlsConnection$default$7()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Tcp

public Tcp(ExtendedActorSystem system)

Method Detail

apply

public static Tcp apply(ActorSystem system)

get

public static Tcp get(ActorSystem system)

get

public static Tcp get(ClassicActorSystemProvider system)

lookup
```
public static Tcp$ lookup()
```

createExtension

public static Tcp createExtension(ExtendedActorSystem system)

hashCode
```
public static final int hashCode()
```

equals

public static final boolean equals(java.lang.Object other)

bindShutdownTimeout

public scala.concurrent.duration.FiniteDuration bindShutdownTimeout()

bind
```
public Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>> bind(java.lang.String interface_,
                                                                                            int port,
                                                                                            int backlog,
                                                                                            scala.collection.immutable.Iterable<Inet.SocketOption> options,
                                                                                            boolean halfClose,
                                                                                            scala.concurrent.duration.Duration idleTimeout)
```
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint.
Please note that the startup of the server is asynchronous, i.e. after materializing the enclosing RunnableGraph the server is not immediately available. Only after the materialized future completes is the server ready to accept client connections.

Parameters:

interface - The interface to listen on

port - The port to listen on

backlog - Controls the size of the connection backlog

options - TCP options for the connections, see Tcp for details

halfClose - Controls whether the connection is kept open even after writing has been completed to the accepted TCP connections. If set to true, the connection will implement the TCP half-close mechanism, allowing the client to write to the connection even after the server has finished writing. The TCP socket is only closed after both the client and server finished writing. If set to false, the connection will immediately closed once the server closes its write side, independently whether the client is still attempting to write. This setting is recommended for servers, and therefore it is the default setting.

bind$default$3
```
public int bind$default$3()
```

bind$default$4

public scala.collection.immutable.Iterable<Inet.SocketOption> bind$default$4()

bind$default$5
```
public boolean bind$default$5()
```

bind$default$6

public scala.concurrent.duration.Duration bind$default$6()

bindAndHandle
```
public scala.concurrent.Future<Tcp.ServerBinding> bindAndHandle(Flow<ByteString,ByteString,?> handler,
                                                                java.lang.String interface_,
                                                                int port,
                                                                int backlog,
                                                                scala.collection.immutable.Iterable<Inet.SocketOption> options,
                                                                boolean halfClose,
                                                                scala.concurrent.duration.Duration idleTimeout,
                                                                Materializer m)
```
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint handling the incoming connections using the provided Flow.
Please note that the startup of the server is asynchronous, i.e. after materializing the enclosing RunnableGraph the server is not immediately available. Only after the returned future completes is the server ready to accept client connections.

Parameters:

handler - A Flow that represents the server logic

interface - The interface to listen on

port - The port to listen on

backlog - Controls the size of the connection backlog

options - TCP options for the connections, see Tcp for details

halfClose - Controls whether the connection is kept open even after writing has been completed to the accepted TCP connections. If set to true, the connection will implement the TCP half-close mechanism, allowing the client to write to the connection even after the server has finished writing. The TCP socket is only closed after both the client and server finished writing. If set to false, the connection will immediately closed once the server closes its write side, independently whether the client is still attempting to write. This setting is recommended for servers, and therefore it is the default setting.

bindAndHandle$default$4
```
public int bindAndHandle$default$4()
```

bindAndHandle$default$5

public scala.collection.immutable.Iterable<Inet.SocketOption> bindAndHandle$default$5()

bindAndHandle$default$6

public boolean bindAndHandle$default$6()

bindAndHandle$default$7

public scala.concurrent.duration.Duration bindAndHandle$default$7()

outgoingConnection
```
public Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingConnection(java.net.InetSocketAddress remoteAddress,
                                                                                                                  scala.Option<java.net.InetSocketAddress> localAddress,
                                                                                                                  scala.collection.immutable.Iterable<Inet.SocketOption> options,
                                                                                                                  boolean halfClose,
                                                                                                                  scala.concurrent.duration.Duration connectTimeout,
                                                                                                                  scala.concurrent.duration.Duration idleTimeout)
```
Creates an Tcp.OutgoingConnection instance representing a prospective TCP client connection to the given endpoint.
Note that the ByteString chunk boundaries are not retained across the network, to achieve application level chunks you have to introduce explicit framing in your streams, for example using the Framing operators.

Parameters:

remoteAddress - The remote address to connect to

localAddress - Optional local address for the connection

options - TCP options for the connections, see Tcp for details

halfClose - Controls whether the connection is kept open even after writing has been completed to the accepted TCP connections. If set to true, the connection will implement the TCP half-close mechanism, allowing the server to write to the connection even after the client has finished writing. The TCP socket is only closed after both the client and server finished writing. This setting is recommended for clients and therefore it is the default setting. If set to false, the connection will immediately closed once the client closes its write side, independently whether the server is still attempting to write.

outgoingConnection
```
public Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingConnection(java.lang.String host,
                                                                                                                  int port)
```
Creates an Tcp.OutgoingConnection without specifying options. It represents a prospective TCP client connection to the given endpoint.
Note that the ByteString chunk boundaries are not retained across the network, to achieve application level chunks you have to introduce explicit framing in your streams, for example using the Framing operators.

outgoingConnection$default$2

public scala.Option<java.net.InetSocketAddress> outgoingConnection$default$2()

outgoingConnection$default$3

public scala.collection.immutable.Iterable<Inet.SocketOption> outgoingConnection$default$3()

outgoingConnection$default$4

public boolean outgoingConnection$default$4()

outgoingConnection$default$5

public scala.concurrent.duration.Duration outgoingConnection$default$5()

outgoingConnection$default$6

public scala.concurrent.duration.Duration outgoingConnection$default$6()

outgoingTlsConnection

public Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingTlsConnection(java.lang.String host,
                                                                                                                     int port,
                                                                                                                     javax.net.ssl.SSLContext sslContext,
                                                                                                                     TLSProtocol.NegotiateNewSession negotiateNewSession)

Deprecated.

Use outgoingConnectionWithTls that takes a SSLEngine factory instead. Setup the SSLEngine with needed parameters. Since 2.6.0.

Creates an Tcp.OutgoingConnection with TLS. The returned flow represents a TCP client connection to the given endpoint where all bytes in and out go through TLS.

For more advanced use cases you can manually combine Tcp.outgoingConnection and TLS

Parameters:: negotiateNewSession - Details about what to require when negotiating the connection with the server; sslContext - Context containing details such as the trust and keystore
See Also:: Tcp.outgoingConnection

outgoingTlsConnection

public Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingTlsConnection(java.net.InetSocketAddress remoteAddress,
                                                                                                                     javax.net.ssl.SSLContext sslContext,
                                                                                                                     TLSProtocol.NegotiateNewSession negotiateNewSession,
                                                                                                                     scala.Option<java.net.InetSocketAddress> localAddress,
                                                                                                                     scala.collection.immutable.Iterable<Inet.SocketOption> options,
                                                                                                                     scala.concurrent.duration.Duration connectTimeout,
                                                                                                                     scala.concurrent.duration.Duration idleTimeout)

Deprecated.

Use outgoingConnectionWithTls that takes a SSLEngine factory instead. Setup the SSLEngine with needed parameters. Since 2.6.0.

Creates an Tcp.OutgoingConnection with TLS. The returned flow represents a TCP client connection to the given endpoint where all bytes in and out go through TLS.

Parameters:: negotiateNewSession - Details about what to require when negotiating the connection with the server; sslContext - Context containing details such as the trust and keystore
See Also:: Tcp.outgoingConnection

outgoingTlsConnection$default$4

public scala.Option<java.net.InetSocketAddress> outgoingTlsConnection$default$4()

outgoingTlsConnection$default$5

public scala.collection.immutable.Iterable<Inet.SocketOption> outgoingTlsConnection$default$5()

outgoingTlsConnection$default$6

public scala.concurrent.duration.Duration outgoingTlsConnection$default$6()

outgoingTlsConnection$default$7

public scala.concurrent.duration.Duration outgoingTlsConnection$default$7()

outgoingConnectionWithTls
```
public Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingConnectionWithTls(java.net.InetSocketAddress remoteAddress,
                                                                                                                         scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine)
```
Creates an Tcp.OutgoingConnection with TLS. The returned flow represents a TCP client connection to the given endpoint where all bytes in and out go through TLS.
You specify a factory to create an SSLEngine that must already be configured for client mode and with all the parameters for the first session.

See Also:

Tcp.outgoingConnection

outgoingConnectionWithTls

public Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingConnectionWithTls(java.net.InetSocketAddress remoteAddress,
                                                                                                                         scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine,
                                                                                                                         scala.Option<java.net.InetSocketAddress> localAddress,
                                                                                                                         scala.collection.immutable.Seq<Inet.SocketOption> options,
                                                                                                                         scala.concurrent.duration.Duration connectTimeout,
                                                                                                                         scala.concurrent.duration.Duration idleTimeout,
                                                                                                                         scala.Function1<javax.net.ssl.SSLSession,scala.util.Try<scala.runtime.BoxedUnit>> verifySession,
                                                                                                                         TLSClosing closing)

Creates an Tcp.OutgoingConnection with TLS. The returned flow represents a TCP client connection to the given endpoint where all bytes in and out go through TLS.

You specify a factory to create an SSLEngine that must already be configured for client mode and with all the parameters for the first session.

See Also:: Tcp.outgoingConnection

bindTls

public Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>> bindTls(java.lang.String interface_,
                                                                                               int port,
                                                                                               javax.net.ssl.SSLContext sslContext,
                                                                                               TLSProtocol.NegotiateNewSession negotiateNewSession,
                                                                                               int backlog,
                                                                                               scala.collection.immutable.Iterable<Inet.SocketOption> options,
                                                                                               scala.concurrent.duration.Duration idleTimeout)

Deprecated.

Use bindWithTls that takes a SSLEngine factory instead. Setup the SSLEngine with needed parameters. Since 2.6.0.

Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint where all incoming and outgoing bytes are passed through TLS.

Parameters:: negotiateNewSession - Details about what to require when negotiating the connection with the server; sslContext - Context containing details such as the trust and keystore
See Also:: Tcp.bind

bindTls$default$5
```
public int bindTls$default$5()
```

bindTls$default$6

public scala.collection.immutable.Iterable<Inet.SocketOption> bindTls$default$6()

bindTls$default$7

public scala.concurrent.duration.Duration bindTls$default$7()

bindWithTls

public Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>> bindWithTls(java.lang.String interface_,
                                                                                                   int port,
                                                                                                   scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine)

Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint where all incoming and outgoing bytes are passed through TLS.

You specify a factory to create an SSLEngine that must already be configured for server mode and with all the parameters for the first session.

See Also:: Tcp.bind

bindWithTls

public Source<Tcp.IncomingConnection,scala.concurrent.Future<Tcp.ServerBinding>> bindWithTls(java.lang.String interface_,
                                                                                                   int port,
                                                                                                   scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine,
                                                                                                   int backlog,
                                                                                                   scala.collection.immutable.Seq<Inet.SocketOption> options,
                                                                                                   scala.concurrent.duration.Duration idleTimeout,
                                                                                                   scala.Function1<javax.net.ssl.SSLSession,scala.util.Try<scala.runtime.BoxedUnit>> verifySession,
                                                                                                   TLSClosing closing)

Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint where all incoming and outgoing bytes are passed through TLS.

You specify a factory to create an SSLEngine that must already be configured for server mode and with all the parameters for the first session.

See Also:: Tcp.bind

bindAndHandleWithTls

public scala.concurrent.Future<Tcp.ServerBinding> bindAndHandleWithTls(Flow<ByteString,ByteString,?> handler,
                                                                       java.lang.String interface_,
                                                                       int port,
                                                                       scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine,
                                                                       Materializer m)

Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint all incoming and outgoing bytes are passed through TLS and handling the incoming connections using the provided Flow.

You specify a factory to create an SSLEngine that must already be configured for server mode and with all the parameters for the first session.

See Also:: Tcp.bindAndHandle

bindAndHandleWithTls

public scala.concurrent.Future<Tcp.ServerBinding> bindAndHandleWithTls(Flow<ByteString,ByteString,?> handler,
                                                                       java.lang.String interface_,
                                                                       int port,
                                                                       scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine,
                                                                       int backlog,
                                                                       scala.collection.immutable.Seq<Inet.SocketOption> options,
                                                                       scala.concurrent.duration.Duration idleTimeout,
                                                                       scala.Function1<javax.net.ssl.SSLSession,scala.util.Try<scala.runtime.BoxedUnit>> verifySession,
                                                                       TLSClosing closing,
                                                                       Materializer m)

Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint all incoming and outgoing bytes are passed through TLS and handling the incoming connections using the provided Flow.

You specify a factory to create an SSLEngine that must already be configured for server mode and with all the parameters for the first session.

See Also:: Tcp.bindAndHandle

bindAndHandleTls

public scala.concurrent.Future<Tcp.ServerBinding> bindAndHandleTls(Flow<ByteString,ByteString,?> handler,
                                                                   java.lang.String interface_,
                                                                   int port,
                                                                   javax.net.ssl.SSLContext sslContext,
                                                                   TLSProtocol.NegotiateNewSession negotiateNewSession,
                                                                   int backlog,
                                                                   scala.collection.immutable.Iterable<Inet.SocketOption> options,
                                                                   scala.concurrent.duration.Duration idleTimeout,
                                                                   Materializer m)

Deprecated.

Use bindAndHandleWithTls that takes a SSLEngine factory instead. Setup the SSLEngine with needed parameters. Since 2.6.0.

Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given endpoint handling the incoming connections through TLS and then run using the provided Flow.

Parameters:: negotiateNewSession - Details about what to require when negotiating the connection with the server; sslContext - Context containing details such as the trust and keystore
See Also:: Marked API-may-change to leave room for an improvement around the very long parameter list.

bindAndHandleTls$default$6

public int bindAndHandleTls$default$6()

bindAndHandleTls$default$7

public scala.collection.immutable.Iterable<Inet.SocketOption> bindAndHandleTls$default$7()

bindAndHandleTls$default$8

public scala.concurrent.duration.Duration bindAndHandleTls$default$8()

Class Tcp

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Tcp

Method Detail

apply

get

get

lookup

createExtension

hashCode

equals

bindShutdownTimeout

bind

bind$default$3

bind$default$4

bind$default$5

bind$default$6

bindAndHandle

bindAndHandle$default$4

bindAndHandle$default$5

bindAndHandle$default$6

bindAndHandle$default$7

outgoingConnection

outgoingConnection

outgoingConnection$default$2

outgoingConnection$default$3

outgoingConnection$default$4

outgoingConnection$default$5

outgoingConnection$default$6

outgoingTlsConnection

outgoingTlsConnection

outgoingTlsConnection$default$4

outgoingTlsConnection$default$5

outgoingTlsConnection$default$6

outgoingTlsConnection$default$7

outgoingConnectionWithTls

outgoingConnectionWithTls

bindTls

bindTls$default$5

bindTls$default$6

bindTls$default$7

bindWithTls

bindWithTls

bindAndHandleWithTls

bindAndHandleWithTls

bindAndHandleTls

bindAndHandleTls$default$6

bindAndHandleTls$default$7

bindAndHandleTls$default$8