akka.io

Class TcpConnection

java.lang.Object

akka.io.TcpConnection

All Implemented Interfaces:

Actor, ActorLogging, RequiresMessageQueue<UnboundedMessageQueueSemantics>

Direct Known Subclasses:

TcpIncomingConnection, TcpOutgoingConnection

public abstract class TcpConnection
extends java.lang.Object
implements Actor, ActorLogging, RequiresMessageQueue<UnboundedMessageQueueSemantics>

Base class for TcpIncomingConnection and TcpOutgoingConnection.

INTERNAL API

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	TcpConnection.AllRead$
static class	TcpConnection.CloseInformation Used to transport information to the postStop method to notify interested party about a connection close.
static class	TcpConnection.CloseInformation$
static class	TcpConnection.ConnectionInfo Groups required connection-related data that are only available once the connection has been fully established.
static class	TcpConnection.ConnectionInfo$
static class	TcpConnection.EmptyPendingWrite$
static class	TcpConnection.EndOfStream$
static class	TcpConnection.MoreDataWaiting$
class	TcpConnection.PendingBufferWrite
static class	TcpConnection.PendingWrite
class	TcpConnection.PendingWriteFile
static interface	TcpConnection.ReadResult
static class	TcpConnection.UpdatePendingWriteAndThen
static class	TcpConnection.UpdatePendingWriteAndThen$
static class	TcpConnection.WriteFileFailed
static class	TcpConnection.WriteFileFailed$

Nested classes/interfaces inherited from interface akka.actor.Actor

Actor.emptyBehavior$, Actor.ignoringBehavior$

Constructor Summary

Constructors

Constructor and Description
TcpConnection(TcpExt tcp, java.nio.channels.SocketChannel channel, boolean pullMode)

Method Summary

Modifier and Type	Method and Description
void	abort()
protected abstract static void	akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)
protected abstract static void	akka$actor$Actor$_setter_$self_$eq(ActorRef x$1)
static void	akka$actor$ActorLogging$$_log_$eq(LoggingAdapter x$1)
static LoggingAdapter	akka$actor$ActorLogging$$_log()
protected static void	aroundPostRestart(java.lang.Throwable reason)
protected static void	aroundPostStop()
protected static void	aroundPreRestart(java.lang.Throwable reason, scala.Option<java.lang.Object> message)
protected static void	aroundPreStart()
protected static void	aroundReceive(scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive, java.lang.Object msg)
java.nio.channels.SocketChannel	channel()
TcpConnection.CloseInformation	closedMessage()
Tcp.ConnectionClosed	closeReason()
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	closing(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander) connection is closed on our side and we're waiting from confirmation from the other side
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	closingWithPendingWrite(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander, Tcp.ConnectionClosed closedEvent) connection is closing but a write has to be finished first
void	completeConnect(ChannelRegistration registration, ActorRef commander, scala.collection.immutable.Traversable<Inet.SocketOption> options) used in subclasses to start the common machinery above once a channel is connected
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	connected(TcpConnection.ConnectionInfo info) normal connected state
ActorContext	context() Stores the context for this actor, including self, and sender.
void	doCloseConnection(ActorRef handler, scala.Option<ActorRef> closeCommander, Tcp.ConnectionClosed closedEvent)
static scala.Function0<scala.runtime.BoxedUnit>	doNothing()
void	doRead(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander)
void	doWrite(TcpConnection.ConnectionInfo info)
static java.io.IOException	DroppingWriteBecauseQueueIsFullException()
static java.io.IOException	DroppingWriteBecauseWritingIsSuspendedException()
void	handleClose(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander, Tcp.ConnectionClosed closedEvent)
void	handleError(ActorRef handler, java.io.IOException exception)
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	handleWriteMessages(TcpConnection.ConnectionInfo info)
static LoggingAdapter	log()
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	peerSentEOF(TcpConnection.ConnectionInfo info) the peer sent EOF first, but we may still want to send
TcpConnection.PendingBufferWrite	PendingBufferWrite(ActorRef commander, ByteString data, Tcp.Event ack, Tcp.WriteCommand tail)
TcpConnection.PendingWrite	PendingWrite(ActorRef commander, Tcp.WriteCommand write)
TcpConnection.PendingWriteFile	PendingWriteFile(ActorRef commander, java.lang.String filePath, long offset, long count, Tcp.Event ack, Tcp.WriteCommand tail)
void	postRestart(java.lang.Throwable reason) User overridable callback: By default it calls preStart().
void	postStop() User overridable callback.
static void	preRestart(java.lang.Throwable reason, scala.Option<java.lang.Object> message)
static void	preStart()
boolean	pullMode()
abstract static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	receive()
void	resumeReading(TcpConnection.ConnectionInfo info)
boolean	safeShutdownOutput()
ActorRef	self() The 'self' field holds the ActorRef for this actor.
static ActorRef	sender()
void	signDeathPact(ActorRef actor)
void	stopWith(TcpConnection.CloseInformation closeInfo)
static SupervisorStrategy	supervisorStrategy()
void	suspendReading(TcpConnection.ConnectionInfo info)
TcpExt	tcp()
static void	unhandled(java.lang.Object message)
void	unsignDeathPact()
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	waitingForRegistration(ChannelRegistration registration, ActorRef commander) connection established, waiting for registration from user handler
boolean	writePending()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface akka.actor.Actor

aroundPostRestart, aroundPostStop, aroundPreRestart, aroundPreStart, aroundReceive, preRestart, preStart, receive, sender, supervisorStrategy, unhandled

Methods inherited from interface akka.actor.ActorLogging

log

Constructor Detail

TcpConnection

public TcpConnection(TcpExt tcp,
                     java.nio.channels.SocketChannel channel,
                     boolean pullMode)

Method Detail

doNothing

public static scala.Function0<scala.runtime.BoxedUnit> doNothing()

DroppingWriteBecauseWritingIsSuspendedException

public static java.io.IOException DroppingWriteBecauseWritingIsSuspendedException()

DroppingWriteBecauseQueueIsFullException

public static java.io.IOException DroppingWriteBecauseQueueIsFullException()

sender

public static final ActorRef sender()

receive

public abstract static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive()

aroundReceive

protected static void aroundReceive(scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive,
                                    java.lang.Object msg)

aroundPreStart

protected static void aroundPreStart()

aroundPostStop

protected static void aroundPostStop()

aroundPreRestart

protected static void aroundPreRestart(java.lang.Throwable reason,
                                       scala.Option<java.lang.Object> message)

aroundPostRestart

protected static void aroundPostRestart(java.lang.Throwable reason)

supervisorStrategy

public static SupervisorStrategy supervisorStrategy()

preStart

public static void preStart()
                     throws java.lang.Exception

Throws:

java.lang.Exception

preRestart

public static void preRestart(java.lang.Throwable reason,
                              scala.Option<java.lang.Object> message)
                       throws java.lang.Exception

Throws:

java.lang.Exception

unhandled

public static void unhandled(java.lang.Object message)

akka$actor$Actor$_setter_$context_$eq

protected abstract static void akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)

akka$actor$Actor$_setter_$self_$eq

protected abstract static void akka$actor$Actor$_setter_$self_$eq(ActorRef x$1)

akka$actor$ActorLogging$$_log

public static LoggingAdapter akka$actor$ActorLogging$$_log()

akka$actor$ActorLogging$$_log_$eq

public static void akka$actor$ActorLogging$$_log_$eq(LoggingAdapter x$1)

log

public static LoggingAdapter log()

context

public ActorContext context()

Description copied from interface: Actor

Stores the context for this actor, including self, and sender. It is implicit to support operations such as forward.

WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!

ActorContext is the Scala API. getContext returns a UntypedActorContext, which is the Java API of the actor context.

Specified by:

context in interface Actor

Returns:

(undocumented)

self

public final ActorRef self()

Description copied from interface: Actor

The 'self' field holds the ActorRef for this actor.

Can be used to send messages to itself:

 self ! message
 

Specified by:

self in interface Actor

Returns:

(undocumented)

tcp

public TcpExt tcp()

channel

public java.nio.channels.SocketChannel channel()

pullMode

public boolean pullMode()

closedMessage

public TcpConnection.CloseInformation closedMessage()

signDeathPact

public void signDeathPact(ActorRef actor)

unsignDeathPact

public void unsignDeathPact()

writePending

public boolean writePending()

waitingForRegistration

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> waitingForRegistration(ChannelRegistration registration,
                                                                                              ActorRef commander)

connection established, waiting for registration from user handler

connected

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> connected(TcpConnection.ConnectionInfo info)

normal connected state

peerSentEOF

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> peerSentEOF(TcpConnection.ConnectionInfo info)

the peer sent EOF first, but we may still want to send

closingWithPendingWrite

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> closingWithPendingWrite(TcpConnection.ConnectionInfo info,
                                                                                               scala.Option<ActorRef> closeCommander,
                                                                                               Tcp.ConnectionClosed closedEvent)

connection is closing but a write has to be finished first

closing

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> closing(TcpConnection.ConnectionInfo info,
                                                                               scala.Option<ActorRef> closeCommander)

connection is closed on our side and we're waiting from confirmation from the other side

handleWriteMessages

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> handleWriteMessages(TcpConnection.ConnectionInfo info)

completeConnect

public void completeConnect(ChannelRegistration registration,
                            ActorRef commander,
                            scala.collection.immutable.Traversable<Inet.SocketOption> options)

used in subclasses to start the common machinery above once a channel is connected

suspendReading

public void suspendReading(TcpConnection.ConnectionInfo info)

resumeReading

public void resumeReading(TcpConnection.ConnectionInfo info)

doRead

public void doRead(TcpConnection.ConnectionInfo info,
                   scala.Option<ActorRef> closeCommander)

doWrite

public void doWrite(TcpConnection.ConnectionInfo info)

closeReason

public Tcp.ConnectionClosed closeReason()

handleClose

public void handleClose(TcpConnection.ConnectionInfo info,
                        scala.Option<ActorRef> closeCommander,
                        Tcp.ConnectionClosed closedEvent)

doCloseConnection

public void doCloseConnection(ActorRef handler,
                              scala.Option<ActorRef> closeCommander,
                              Tcp.ConnectionClosed closedEvent)

handleError

public void handleError(ActorRef handler,
                        java.io.IOException exception)

safeShutdownOutput

public boolean safeShutdownOutput()

abort

public void abort()

stopWith

public void stopWith(TcpConnection.CloseInformation closeInfo)

postStop

public void postStop()

Description copied from interface: Actor

User overridable callback.

Is called asynchronously after 'actor.stop()' is invoked. Empty default implementation.

Specified by:

postStop in interface Actor

postRestart

public void postRestart(java.lang.Throwable reason)

Description copied from interface: Actor

User overridable callback: By default it calls preStart().

Specified by:

postRestart in interface Actor

Parameters:

reason - the Throwable that caused the restart to happen

Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.

PendingWrite

public TcpConnection.PendingWrite PendingWrite(ActorRef commander,
                                               Tcp.WriteCommand write)

PendingBufferWrite

public TcpConnection.PendingBufferWrite PendingBufferWrite(ActorRef commander,
                                                           ByteString data,
                                                           Tcp.Event ack,
                                                           Tcp.WriteCommand tail)

PendingWriteFile

public TcpConnection.PendingWriteFile PendingWriteFile(ActorRef commander,
                                                       java.lang.String filePath,
                                                       long offset,
                                                       long count,
                                                       Tcp.Event ack,
                                                       Tcp.WriteCommand tail)