Package akka.stream.scaladsl

Class Tcp

  • All Implemented Interfaces:
    Extension
    public final class Tcp
extends java.lang.Object
implements Extension
    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.

    param: interface The interface to listen on param: port The port to listen on param: backlog Controls the size of the connection backlog param: options TCP options for the connections, see Tcp for details param: 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.

    • Method Detail

      • lookup

        public static Tcp$ lookup()

      • 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.Traversable<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.
        interface_ - (undocumented)
        idleTimeout - (undocumented)
        Returns:
        (undocumented)

      • bind$default$3

        public int bind$default$3()

      • bind$default$4

        public scala.collection.immutable.Traversable<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.Traversable<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.
        interface_ - (undocumented)
        idleTimeout - (undocumented)
        m - (undocumented)
        Returns:
        (undocumented)

      • bindAndHandle$default$4

        public int bindAndHandle$default$4()

      • bindAndHandle$default$5

        public scala.collection.immutable.Traversable<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.Traversable<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.
        connectTimeout - (undocumented)
        idleTimeout - (undocumented)
        Returns:
        (undocumented)

      • 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.

        Parameters:
        host - (undocumented)
        port - (undocumented)
        Returns:
        (undocumented)

      • outgoingConnection$default$2

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

      • outgoingConnection$default$3

        public scala.collection.immutable.Traversable<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)
        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 {@link 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

        host - (undocumented)
        port - (undocumented)
        Returns:
        (undocumented)

      • 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.Traversable<Inet.SocketOption> options,
                                                                                                                     scala.concurrent.duration.Duration connectTimeout,
                                                                                                                     scala.concurrent.duration.Duration idleTimeout)
        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

        Marked API-may-change to leave room for an improvement around the very long parameter list.

        remoteAddress - (undocumented)
        localAddress - (undocumented)
        options - (undocumented)
        connectTimeout - (undocumented)
        idleTimeout - (undocumented)
        Returns:
        (undocumented)

      • outgoingTlsConnection$default$4

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

      • outgoingTlsConnection$default$5

        public scala.collection.immutable.Traversable<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()

      • outgoingTlsConnectionWithSSLEngine

        public Flow<ByteString,​ByteString,​scala.concurrent.Future<Tcp.OutgoingConnection>> outgoingTlsConnectionWithSSLEngine​(java.net.InetSocketAddress remoteAddress,
                                                                                                                                  scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine,
                                                                                                                                  scala.Option<java.net.InetSocketAddress> localAddress,
                                                                                                                                  scala.collection.immutable.Traversable<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)
        INTERNAL API: for raw SSLEngine
        Parameters:
        remoteAddress - (undocumented)
        createSSLEngine - (undocumented)
        localAddress - (undocumented)
        options - (undocumented)
        connectTimeout - (undocumented)
        idleTimeout - (undocumented)
        verifySession - (undocumented)
        closing - (undocumented)
        Returns:
        (undocumented)

      • outgoingTlsConnectionWithSSLEngine$default$3

        public scala.Option<java.net.InetSocketAddress> outgoingTlsConnectionWithSSLEngine$default$3()

      • outgoingTlsConnectionWithSSLEngine$default$4

        public scala.collection.immutable.Traversable<Inet.SocketOption> outgoingTlsConnectionWithSSLEngine$default$4()

      • outgoingTlsConnectionWithSSLEngine$default$5

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

      • outgoingTlsConnectionWithSSLEngine$default$6

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

      • outgoingTlsConnectionWithSSLEngine$default$8

        public TLSClosing outgoingTlsConnectionWithSSLEngine$default$8()

      • 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.Traversable<Inet.SocketOption> options,
                                                                                               scala.concurrent.duration.Duration idleTimeout)
        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
        interface_ - (undocumented)
        port - (undocumented)
        backlog - (undocumented)
        options - (undocumented)
        idleTimeout - (undocumented)
        Returns:
        (undocumented)
        See Also:
        Marked API-may-change to leave room for an improvement around the very long parameter list.

      • bindTls$default$5

        public int bindTls$default$5()

      • bindTls$default$6

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

      • bindTls$default$7

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

      • bindTlsWithSSLEngine

        public Source<Tcp.IncomingConnection,​scala.concurrent.Future<Tcp.ServerBinding>> bindTlsWithSSLEngine​(java.lang.String interface_,
                                                                                                            int port,
                                                                                                            scala.Function0<javax.net.ssl.SSLEngine> createSSLEngine,
                                                                                                            int backlog,
                                                                                                            scala.collection.immutable.Traversable<Inet.SocketOption> options,
                                                                                                            scala.concurrent.duration.Duration idleTimeout,
                                                                                                            scala.Function1<javax.net.ssl.SSLSession,​scala.util.Try<scala.runtime.BoxedUnit>> verifySession,
                                                                                                            TLSClosing closing)
        INTERNAL API
        Parameters:
        interface_ - (undocumented)
        port - (undocumented)
        createSSLEngine - (undocumented)
        backlog - (undocumented)
        options - (undocumented)
        idleTimeout - (undocumented)
        verifySession - (undocumented)
        closing - (undocumented)
        Returns:
        (undocumented)

      • bindTlsWithSSLEngine$default$4

        public int bindTlsWithSSLEngine$default$4()

      • bindTlsWithSSLEngine$default$5

        public scala.collection.immutable.Traversable<Inet.SocketOption> bindTlsWithSSLEngine$default$5()

      • bindTlsWithSSLEngine$default$6

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

      • bindTlsWithSSLEngine$default$8

        public TLSClosing bindTlsWithSSLEngine$default$8()

      • 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.Traversable<Inet.SocketOption> options,
                                                                   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 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
        handler - (undocumented)
        interface_ - (undocumented)
        port - (undocumented)
        backlog - (undocumented)
        options - (undocumented)
        idleTimeout - (undocumented)
        m - (undocumented)
        Returns:
        (undocumented)

      • bindAndHandleTls$default$6

        public int bindAndHandleTls$default$6()

      • bindAndHandleTls$default$7

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

      • bindAndHandleTls$default$8

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