final class Tcp extends Extension
- Alphabetic
- By Inheritance
- Tcp
- Extension
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new Tcp(system: ExtendedActorSystem)
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (Tcp, B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bind(interface: String, port: Int, backlog: Int = defaultBacklog, options: Traversable[SocketOption] = Nil, halfClose: Boolean = false, idleTimeout: Duration = Duration.Inf): Source[IncomingConnection, Future[ServerBinding]]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpoint.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 akka.stream.scaladsl.RunnableGraph the server is not immediately available. Only after the materialized future completes is the server ready to accept client connections.
- 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 akka.io.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.
-
def
bindAndHandle(handler: Flow[ByteString, ByteString, _], interface: String, port: Int, backlog: Int = defaultBacklog, options: Traversable[SocketOption] = Nil, halfClose: Boolean = false, idleTimeout: Duration = Duration.Inf)(implicit m: Materializer): Future[ServerBinding]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointhandling the incoming connections using the provided Flow.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointhandling the incoming connections using the provided Flow.Please note that the startup of the server is asynchronous, i.e. after materializing the enclosing akka.stream.scaladsl.RunnableGraph the server is not immediately available. Only after the returned future completes is the server ready to accept client connections.
- 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 akka.io.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.
-
def
bindAndHandleWithTls(handler: Flow[ByteString, ByteString, _], interface: String, port: Int, createSSLEngine: () ⇒ SSLEngine, backlog: Int, options: Seq[SocketOption], idleTimeout: Duration, verifySession: (SSLSession) ⇒ Try[Unit], closing: TLSClosing)(implicit m: Materializer): Future[ServerBinding]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointall incoming and outgoing bytes are passed through TLS and handling the incoming connections using the provided Flow.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointall 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 client server and with all the parameters for the first session.
- See also
-
def
bindAndHandleWithTls(handler: Flow[ByteString, ByteString, _], interface: String, port: Int, createSSLEngine: () ⇒ SSLEngine)(implicit m: Materializer): Future[ServerBinding]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointall incoming and outgoing bytes are passed through TLS and handling the incoming connections using the provided Flow.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointall 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 client server and with all the parameters for the first session.
- See also
- val bindShutdownTimeout: FiniteDuration
-
def
bindWithTls(interface: String, port: Int, createSSLEngine: () ⇒ SSLEngine, backlog: Int, options: Seq[SocketOption], idleTimeout: Duration, verifySession: (SSLSession) ⇒ Try[Unit], closing: TLSClosing): Source[IncomingConnection, Future[ServerBinding]]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointwhere all incoming and outgoing bytes are passed through TLS.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointwhere all incoming and outgoing bytes are passed 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
-
def
bindWithTls(interface: String, port: Int, createSSLEngine: () ⇒ SSLEngine): Source[IncomingConnection, Future[ServerBinding]]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointwhere all incoming and outgoing bytes are passed through TLS.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointwhere all incoming and outgoing bytes are passed 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
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @HotSpotIntrinsicCandidate()
- def ensuring(cond: (Tcp) ⇒ Boolean, msg: ⇒ Any): Tcp
- def ensuring(cond: (Tcp) ⇒ Boolean): Tcp
- def ensuring(cond: Boolean, msg: ⇒ Any): Tcp
- def ensuring(cond: Boolean): Tcp
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
outgoingConnection(host: String, port: Int): Flow[ByteString, ByteString, Future[OutgoingConnection]]
Creates an Tcp.OutgoingConnection without specifying options.
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.
-
def
outgoingConnection(remoteAddress: InetSocketAddress, localAddress: Option[InetSocketAddress] = None, options: Traversable[SocketOption] = Nil, halfClose: Boolean = true, connectTimeout: Duration = Duration.Inf, idleTimeout: Duration = Duration.Inf): Flow[ByteString, ByteString, Future[OutgoingConnection]]
Creates an Tcp.OutgoingConnection instance representing a prospective TCP client connection to the given endpoint.
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.
- remoteAddress
The remote address to connect to
- localAddress
Optional local address for the connection
- options
TCP options for the connections, see akka.io.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.
-
def
outgoingConnectionWithTls(remoteAddress: InetSocketAddress, createSSLEngine: () ⇒ SSLEngine, localAddress: Option[InetSocketAddress], options: Seq[SocketOption], connectTimeout: Duration, idleTimeout: Duration, verifySession: (SSLSession) ⇒ Try[Unit], closing: TLSClosing): Flow[ByteString, ByteString, Future[OutgoingConnection]]
Creates an Tcp.OutgoingConnection with TLS.
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
-
def
outgoingConnectionWithTls(remoteAddress: InetSocketAddress, createSSLEngine: () ⇒ SSLEngine): Flow[ByteString, ByteString, Future[OutgoingConnection]]
Creates an Tcp.OutgoingConnection with TLS.
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
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- def →[B](y: B): (Tcp, B)
Deprecated Value Members
-
def
bindAndHandleTls(handler: Flow[ByteString, ByteString, _], interface: String, port: Int, sslContext: SSLContext, negotiateNewSession: NegotiateNewSession, backlog: Int = defaultBacklog, options: Traversable[SocketOption] = Nil, idleTimeout: Duration = Duration.Inf)(implicit m: Materializer): Future[ServerBinding]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointhandling the incoming connections through TLS and then run using the provided Flow.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointhandling the incoming connections through TLS and then run using the provided Flow.- sslContext
Context containing details such as the trust and keystore
- negotiateNewSession
Details about what to require when negotiating the connection with the server
- Annotations
- @deprecated
- Deprecated
(Since version 2.6.0)
- See also
Tcp.bindAndHandle Marked API-may-change to leave room for an improvement around the very long parameter list.
-
def
bindTls(interface: String, port: Int, sslContext: SSLContext, negotiateNewSession: NegotiateNewSession, backlog: Int = defaultBacklog, options: Traversable[SocketOption] = Nil, idleTimeout: Duration = Duration.Inf): Source[IncomingConnection, Future[ServerBinding]]
Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointwhere all incoming and outgoing bytes are passed through TLS.Creates a Tcp.ServerBinding instance which represents a prospective TCP server binding on the given
endpointwhere all incoming and outgoing bytes are passed through TLS.- sslContext
Context containing details such as the trust and keystore
- negotiateNewSession
Details about what to require when negotiating the connection with the server
- Annotations
- @deprecated
- Deprecated
(Since version 2.6.0)
- See also
Tcp.bind Marked API-may-change to leave room for an improvement around the very long parameter list.
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] ) @Deprecated @deprecated
- Deprecated
(Since version ) see corresponding Javadoc for more information.
-
def
outgoingTlsConnection(remoteAddress: InetSocketAddress, sslContext: SSLContext, negotiateNewSession: NegotiateNewSession, localAddress: Option[InetSocketAddress] = None, options: Traversable[SocketOption] = Nil, connectTimeout: Duration = Duration.Inf, idleTimeout: Duration = Duration.Inf): Flow[ByteString, ByteString, Future[OutgoingConnection]]
Creates an Tcp.OutgoingConnection with TLS.
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.
- sslContext
Context containing details such as the trust and keystore Marked API-may-change to leave room for an improvement around the very long parameter list.
- negotiateNewSession
Details about what to require when negotiating the connection with the server
- Annotations
- @deprecated
- Deprecated
(Since version 2.6.0)
- See also
-
def
outgoingTlsConnection(host: String, port: Int, sslContext: SSLContext, negotiateNewSession: NegotiateNewSession): Flow[ByteString, ByteString, Future[OutgoingConnection]]
Creates an Tcp.OutgoingConnection with TLS.
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
- sslContext
Context containing details such as the trust and keystore
- negotiateNewSession
Details about what to require when negotiating the connection with the server
- Annotations
- @deprecated
- Deprecated
(Since version 2.6.0)
- See also