akka.io

Class TcpOutgoingConnection

java.lang.Object

akka.io.TcpConnection

akka.io.TcpOutgoingConnection

All Implemented Interfaces:

Actor, ActorLogging, RequiresMessageQueue<UnboundedMessageQueueSemantics>

public class TcpOutgoingConnection
extends TcpConnection

An actor handling the connection state machine for an outgoing connection to be established.

INTERNAL API

Nested Class Summary

Nested classes/interfaces inherited from class akka.io.TcpConnection

TcpConnection.AllRead$, TcpConnection.CloseInformation, TcpConnection.CloseInformation$, TcpConnection.ConnectionInfo, TcpConnection.ConnectionInfo$, TcpConnection.EmptyPendingWrite$, TcpConnection.EndOfStream$, TcpConnection.MoreDataWaiting$, TcpConnection.PendingBufferWrite, TcpConnection.PendingWrite, TcpConnection.PendingWriteFile, TcpConnection.ReadResult, TcpConnection.UpdatePendingWriteAndThen, TcpConnection.UpdatePendingWriteAndThen$, TcpConnection.WriteFileFailed, TcpConnection.WriteFileFailed$

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

Actor.emptyBehavior$, Actor.ignoringBehavior$

Constructor Summary

Constructors

Constructor and Description
TcpOutgoingConnection(TcpExt _tcp, ChannelRegistry channelRegistry, ActorRef commander, Tcp.Connect connect)

Method Summary

Modifier and Type	Method and Description
static void	abort()
protected static void	akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)
protected 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)
static java.nio.channels.SocketChannel	channel()
static void	closedMessage_$eq(TcpConnection.CloseInformation x$1)
static TcpConnection.CloseInformation	closedMessage()
static Tcp.ConnectionClosed	closeReason()
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	closing(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander)
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	closingWithPendingWrite(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander, Tcp.ConnectionClosed closedEvent)
static void	completeConnect(ChannelRegistration registration, ActorRef commander, scala.collection.immutable.Traversable<Inet.SocketOption> options)
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	connected(TcpConnection.ConnectionInfo info)
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	connecting(ChannelRegistration registration, int remainingFinishConnectRetries)
static java.net.ConnectException	connectTimeoutExpired(scala.Option<scala.concurrent.duration.FiniteDuration> timeout)
static ActorContext	context()
static void	doCloseConnection(ActorRef handler, scala.Option<ActorRef> closeCommander, Tcp.ConnectionClosed closedEvent)
static void	doRead(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander)
static void	doWrite(TcpConnection.ConnectionInfo info)
static java.net.ConnectException	FinishConnectNeverReturnedTrueException()
static void	handleClose(TcpConnection.ConnectionInfo info, scala.Option<ActorRef> closeCommander, Tcp.ConnectionClosed closedEvent)
static void	handleError(ActorRef handler, java.io.IOException exception)
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	handleWriteMessages(TcpConnection.ConnectionInfo info)
static LoggingAdapter	log()
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	peerSentEOF(TcpConnection.ConnectionInfo info)
static TcpConnection.PendingBufferWrite	PendingBufferWrite(ActorRef commander, ByteString data, Tcp.Event ack, Tcp.WriteCommand tail)
static TcpConnection.PendingWrite	PendingWrite(ActorRef commander, Tcp.WriteCommand write)
static TcpConnection.PendingWriteFile	PendingWriteFile(ActorRef commander, java.lang.String filePath, long offset, long count, Tcp.Event ack, Tcp.WriteCommand tail)
static void	postRestart(java.lang.Throwable reason)
static void	postStop()
static void	preRestart(java.lang.Throwable reason, scala.Option<java.lang.Object> message)
static void	preStart()
static boolean	pullMode()
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	receive() This defines the initial actor behavior, it must return a partial function with the actor logic.
void	register(java.net.InetSocketAddress address, ChannelRegistration registration)
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	resolving(ChannelRegistration registration)
static void	resumeReading(TcpConnection.ConnectionInfo info)
static boolean	safeShutdownOutput()
static ActorRef	self()
static ActorRef	sender()
static void	signDeathPact(ActorRef actor)
static void	stopWith(TcpConnection.CloseInformation closeInfo)
static SupervisorStrategy	supervisorStrategy()
static void	suspendReading(TcpConnection.ConnectionInfo info)
static TcpExt	tcp()
static void	unhandled(java.lang.Object message)
static void	unsignDeathPact()
static scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit>	waitingForRegistration(ChannelRegistration registration, ActorRef commander)
static boolean	writePending()

Methods inherited from class akka.io.TcpConnection

abort, channel, closedMessage, closeReason, closing, closingWithPendingWrite, completeConnect, connected, context, doCloseConnection, doNothing, doRead, doWrite, DroppingWriteBecauseQueueIsFullException, DroppingWriteBecauseWritingIsSuspendedException, handleClose, handleError, handleWriteMessages, peerSentEOF, PendingBufferWrite, PendingWrite, PendingWriteFile, postRestart, postStop, pullMode, resumeReading, safeShutdownOutput, self, signDeathPact, stopWith, suspendReading, tcp, unsignDeathPact, waitingForRegistration, 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, sender, supervisorStrategy, unhandled

Methods inherited from interface akka.actor.ActorLogging

log

Constructor Detail

TcpOutgoingConnection

public TcpOutgoingConnection(TcpExt _tcp,
                             ChannelRegistry channelRegistry,
                             ActorRef commander,
                             Tcp.Connect connect)

Method Detail

FinishConnectNeverReturnedTrueException

public static java.net.ConnectException FinishConnectNeverReturnedTrueException()

connectTimeoutExpired

public static java.net.ConnectException connectTimeoutExpired(scala.Option<scala.concurrent.duration.FiniteDuration> timeout)

sender

public static final ActorRef sender()

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)

log

public static LoggingAdapter log()

tcp

public static TcpExt tcp()

channel

public static java.nio.channels.SocketChannel channel()

pullMode

public static boolean pullMode()

closedMessage

public static TcpConnection.CloseInformation closedMessage()

closedMessage_$eq

public static void closedMessage_$eq(TcpConnection.CloseInformation x$1)

signDeathPact

public static void signDeathPact(ActorRef actor)

unsignDeathPact

public static void unsignDeathPact()

writePending

public static boolean writePending()

waitingForRegistration

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

connected

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

peerSentEOF

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

closingWithPendingWrite

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

closing

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

handleWriteMessages

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

completeConnect

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

suspendReading

public static void suspendReading(TcpConnection.ConnectionInfo info)

resumeReading

public static void resumeReading(TcpConnection.ConnectionInfo info)

doRead

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

doWrite

public static void doWrite(TcpConnection.ConnectionInfo info)

closeReason

public static Tcp.ConnectionClosed closeReason()

handleClose

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

doCloseConnection

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

handleError

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

safeShutdownOutput

public static boolean safeShutdownOutput()

abort

public static void abort()

stopWith

public static void stopWith(TcpConnection.CloseInformation closeInfo)

postStop

public static void postStop()

postRestart

public static void postRestart(java.lang.Throwable reason)

PendingWrite

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

PendingBufferWrite

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

PendingWriteFile

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

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)

context

public static ActorContext context()

self

public static final ActorRef self()

akka$actor$Actor$_setter_$context_$eq

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

akka$actor$Actor$_setter_$self_$eq

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

receive

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

Description copied from interface: Actor

This defines the initial actor behavior, it must return a partial function with the actor logic.

Specified by:

receive in interface Actor

Specified by:

receive in class TcpConnection

Returns:

(undocumented)

resolving

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

register

public void register(java.net.InetSocketAddress address,
                     ChannelRegistration registration)

connecting

public scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> connecting(ChannelRegistration registration,
                                                                                  int remainingFinishConnectRetries)