akka.io

TcpMessage

object TcpMessage

Source
Tcp.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. TcpMessage
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. def abort: Command

    An abort operation will not flush pending writes and will issue a TCP ABORT command to the O/S kernel which should result in a TCP_RST packet being sent to the peer.

    An abort operation will not flush pending writes and will issue a TCP ABORT command to the O/S kernel which should result in a TCP_RST packet being sent to the peer. The sender of this command and the registered handler for incoming data will both be notified once the socket is closed using a Tcp.Aborted message.

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  8. def bind(handler: ActorRef, endpoint: InetSocketAddress, backlog: Int): Command

    Open a listening socket without specifying options.

  9. def bind(handler: ActorRef, endpoint: InetSocketAddress, backlog: Int, options: Iterable[SocketOption], pullMode: Boolean): Command

    The Bind message is send to the TCP manager actor, which is obtained via TcpExt#getManager in order to bind to a listening socket.

    The Bind message is send to the TCP manager actor, which is obtained via TcpExt#getManager in order to bind to a listening socket. The manager replies either with a Tcp.CommandFailed or the actor handling the listen socket replies with a Tcp.Bound message. If the local port is set to 0 in the Bind message, then the Tcp.Bound message should be inspected to find the actual port which was bound to.

    handler

    The actor which will receive all incoming connection requests in the form of Tcp.Connected messages.

    backlog

    This specifies the number of unaccepted connections the O/S kernel will hold for this port before refusing connections.

    options

    Please refer to TcpSO for a list of all supported options.

    pullMode

    enables pull based accepting and of connections and pull based reading from the accepted connections.

  10. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  11. def close: Command

    A normal close operation will first flush pending writes and then close the socket.

    A normal close operation will first flush pending writes and then close the socket. The sender of this command and the registered handler for incoming data will both be notified once the socket is closed using a Tcp.Closed message.

  12. def confirmedClose: Command

    A confirmed close operation will flush pending writes and half-close the connection, waiting for the peer to close the other half.

    A confirmed close operation will flush pending writes and half-close the connection, waiting for the peer to close the other half. The sender of this command and the registered handler for incoming data will both be notified once the socket is closed using a Tcp.ConfirmedClosed message.

  13. def connect(remoteAddress: InetSocketAddress): Command

    Connect to the given remoteAddress without binding to a local address and without specifying options.

  14. def connect(remoteAddress: InetSocketAddress, localAddress: InetSocketAddress, options: Iterable[SocketOption], timeout: FiniteDuration, pullMode: Boolean): Command

    The Connect message is sent to the TCP manager actor, which is obtained via TcpExt#getManager.

    The Connect message is sent to the TCP manager actor, which is obtained via TcpExt#getManager. Either the manager replies with a Tcp.CommandFailed or the actor handling the new connection replies with a Tcp.Connected message.

    remoteAddress

    is the address to connect to

    localAddress

    optionally specifies a specific address to bind to

    options

    Please refer to TcpSO for a list of all supported options.

    timeout

    is the desired connection timeout, null means "no timeout"

    pullMode

    enables pull based reading from the connection

  15. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  16. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  17. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  18. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  19. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  20. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  21. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  22. def noAck: NoAck

    Default Tcp.NoAck instance which is used when no acknowledgment information is explicitly provided.

    Default Tcp.NoAck instance which is used when no acknowledgment information is explicitly provided. Its “token” is null.

  23. def noAck(token: AnyRef): NoAck

    Each Tcp.WriteCommand can optionally request a positive acknowledgment to be sent to the commanding actor.

    Each Tcp.WriteCommand can optionally request a positive acknowledgment to be sent to the commanding actor. If such notification is not desired the Tcp.WriteCommand#ack must be set to an instance of this class. The token contained within can be used to recognize which write failed when receiving a Tcp.CommandFailed message.

  24. final def notify(): Unit

    Definition Classes
    AnyRef
  25. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  26. def register(handler: ActorRef): Command

    The same as register(handler, false, false).

  27. def register(handler: ActorRef, keepOpenOnPeerClosed: Boolean, useResumeWriting: Boolean): Command

    This message must be sent to a TCP connection actor after receiving the Tcp.Connected message.

    This message must be sent to a TCP connection actor after receiving the Tcp.Connected message. The connection will not read any data from the socket until this message is received, because this message defines the actor which will receive all inbound data.

    handler

    The actor which will receive all incoming data and which will be informed when the connection is closed.

    keepOpenOnPeerClosed

    If this is set to true then the connection is not automatically closed when the peer closes its half, requiring an explicit Tcp.Closed from our side when finished.

    useResumeWriting

    If this is set to true then the connection actor will refuse all further writes after issuing a Tcp.CommandFailed notification until Tcp.ResumeWriting is received. This can be used to implement NACK-based write backpressure.

  28. def resumeAccepting(batchSize: Int): Command

    This message enables the accepting of the next connection if pull reading is enabled for connection actors.

    This message enables the accepting of the next connection if pull reading is enabled for connection actors.

    batchSize

    The number of connections to accept before waiting for the next resume command

  29. def resumeReading: Command

    This command needs to be sent to the connection actor after a Tcp.SuspendReading command in order to resume reading from the socket.

  30. def resumeWriting: Command

    When useResumeWriting is in effect as was indicated in the Tcp.Register message then this command needs to be sent to the connection actor in order to re-enable writing after a Tcp.CommandFailed event.

    When useResumeWriting is in effect as was indicated in the Tcp.Register message then this command needs to be sent to the connection actor in order to re-enable writing after a Tcp.CommandFailed event. All Tcp.WriteCommand processed by the connection actor between the first Tcp.CommandFailed and subsequent reception of this message will also be rejected with Tcp.CommandFailed.

  31. def suspendReading: Command

    Sending this command to the connection actor will disable reading from the TCP socket.

    Sending this command to the connection actor will disable reading from the TCP socket. TCP flow-control will then propagate backpressure to the sender side as buffers fill up on either end. To re-enable reading send Tcp.ResumeReading.

  32. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  33. def toString(): String

    Definition Classes
    AnyRef → Any
  34. def unbind: Command

    In order to close down a listening socket, send this message to that socket’s actor (that is the actor which previously had sent the Tcp.Bound message).

    In order to close down a listening socket, send this message to that socket’s actor (that is the actor which previously had sent the Tcp.Bound message). The listener socket actor will reply with a Tcp.Unbound message.

  35. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  36. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  37. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  38. def write(data: ByteString): Command

    The same as write(data, noAck()).

  39. def write(data: ByteString, ack: Event): Command

    Write data to the TCP connection.

    Write data to the TCP connection. If no ack is needed use the special NoAck object. The connection actor will reply with a Tcp.CommandFailed message if the write could not be enqueued. If Tcp.WriteCommand#wantsAck returns true, the connection actor will reply with the supplied Tcp.WriteCommand#ack token once the write has been successfully enqueued to the O/S kernel. Note that this does not in any way guarantee that the data will be or have been sent! Unfortunately there is no way to determine whether a particular write has been sent by the O/S.

  40. def writeFile(filePath: String, position: Long, count: Long, ack: Event): Command

    Write count bytes starting at position from file at filePath to the connection.

    Write count bytes starting at position from file at filePath to the connection. The count must be > 0. The connection actor will reply with a Tcp.CommandFailed message if the write could not be enqueued. If Tcp.WriteCommand#wantsAck returns true, the connection actor will reply with the supplied Tcp.WriteCommand#ack token once the write has been successfully enqueued to the O/S kernel. Note that this does not in any way guarantee that the data will be or have been sent! Unfortunately there is no way to determine whether a particular write has been sent by the O/S.

Inherited from AnyRef

Inherited from Any

Ungrouped