akka.stream.scaladsl

Class Tcp

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 and 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 and Description
Tcp(ExtendedActorSystem system)

Method Summary

Modifier and Type	Method and 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.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.
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.
scala.concurrent.duration.FiniteDuration	bindShutdownTimeout()
static Tcp	createExtension(ExtendedActorSystem system)
static Tcp	get(ActorSystem system)
static Tcp$	lookup()
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.
Flow<ByteString,ByteString,scala.concurrent.Future<Tcp.OutgoingConnection>>	outgoingConnection(java.lang.String host, int port) Creates an Tcp.OutgoingConnection without specifying options.

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)

lookup

public static Tcp$ lookup()

createExtension

public static Tcp createExtension(ExtendedActorSystem system)

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)

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)

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.

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.

Parameters:

host - (undocumented)

port - (undocumented)

Returns:

(undocumented)