ReliableProxy

A ReliableProxy is a means to wrap a remote actor reference in order to obtain certain improved delivery guarantees:

as long as the proxy is not terminated before it sends all of its queued messages then no messages will be lost
messages re-sent due to the first point will not be delivered out-of-order, message ordering is preserved

These guarantees are valid for the communication between the two end-points of the reliable “tunnel”, which usually spans an unreliable network.

Note that the ReliableProxy guarantees at-least-once, not exactly-once, delivery.

Delivery from the remote end-point to the target actor is still subject to in-JVM delivery semantics (i.e. not strictly guaranteed due to possible OutOfMemory situations or other VM errors).

You can create a reliable connection like this:

In Scala:

val proxy = context.actorOf(ReliableProxy.props(target, 100.millis, 120.seconds)

or in Java:

final ActorRef proxy = getContext().actorOf(ReliableProxy.props(
  target, Duration.create(100, "millis"), Duration.create(120, "seconds")));

Please note: the tunnel is uni-directional, and original sender information is retained, hence replies by the wrapped target reference will go back in the normal “unreliable” way unless also secured by a ReliableProxy from the remote end.

Message Types

This actor is an akka.actor.FSM, hence it offers the service of transition callbacks to those actors which subscribe using the SubscribeTransitionCallBack and UnsubscribeTransitionCallBack messages; see akka.actor.FSM for more documentation. The proxy will transition into ReliableProxy.Active state when ACKs are outstanding and return to the ReliableProxy.Idle state when every message send so far has been confirmed by the peer end-point.

The initial state of the proxy is ReliableProxy.Connecting. In this state the proxy will repeatedly send akka.actor.Identify messages to ActorSelection(targetPath) in order to obtain a new ActorRef for the target. When an akka.actor.ActorIdentity for the target is received a new tunnel will be created, a ReliableProxy.TargetChanged message containing the target ActorRef will be sent to the proxy's transition subscribers and the proxy will transition into either the ReliableProxy.Idle or ReliableProxy.Active state, depending if there are any outstanding messages that need to be delivered. If maxConnectAttempts is defined this actor will stop itself after Identify is sent maxConnectAttempts times.

While in the Idle or Active states, if a communication failure causes the tunnel to terminate via Remote Deathwatch the proxy will transition into the ReliableProxy.Connecting state as described above. After reconnecting TargetChanged will be sent only if the target ActorRef has changed.

If this actor is stopped and it still has outstanding messages a ReliableProxy.ProxyTerminated message will be sent to the transition subscribers. It contains an Unsent object with the outstanding messages.

If an ReliableProxy.Unsent message is sent to this actor the messages contained within it will be relayed through the tunnel to the target.

Any other message type sent to this actor will be delivered via a remote-deployed child actor to the designated target.

Failure Cases

All failures of either the local or the remote end-point are escalated to the parent of this actor; there are no specific error cases which are predefined.

Arguments

See the constructor below for the arguments for this actor. However, prefer using akka.contrib.pattern.ReliableProxy#props to this actor's constructor.

Annotations: @deprecated
Deprecated: (Since version 2.5.0) Use AtLeastOnceDelivery instead
Source: ReliableProxy.scala

Linear Supertypes

ReliableProxyDebugLogging, LoggingFSM[ReliableProxy.State, Vector[Message]], FSM[ReliableProxy.State, Vector[Message]], ActorLogging, Listeners, Actor, AnyRef, Any

Type Hierarchy

Instance Constructors

new ReliableProxy(targetPath: ActorPath, retryAfter: FiniteDuration, reconnectAfter: Option[FiniteDuration], maxConnectAttempts: Option[Int])

targetPath
is the ActorPath to the actor to which all messages will be forwarded. targetPath can point to a local or remote actor, but the tunnel endpoint will be deployed remotely on the node where the target actor lives.
retryAfter
is the ACK timeout after which all outstanding messages will be resent. There is no limit on the queue size or the number of retries.
reconnectAfter
is an optional interval between connection attempts. It is also used as the interval between receiving a Terminated for the tunnel and attempting to reconnect to the target actor. The minimum recommended value for this is the value of the configuration setting akka.remote.retry-gate-closed-for. Use None to never reconnect after a disconnection.
maxConnectAttempts
is an optional maximum number of attempts to connect to the target actor. Use None for no limit. If reconnectAfter is None this value is ignored.

Type Members

type Event = actor.FSM.Event[Vector[Message]]

Definition Classes
FSM
type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor
type State = actor.FSM.State[ReliableProxy.State, Vector[Message]]

Definition Classes
FSM
type StateFunction = PartialFunction[Event, State]

Definition Classes
FSM
type StopEvent = actor.FSM.StopEvent[ReliableProxy.State, Vector[Message]]

Definition Classes
FSM
type Timeout = Option[FiniteDuration]

Definition Classes
FSM
final class TransformHelper extends AnyRef

Definition Classes
FSM
type TransitionHandler = PartialFunction[(ReliableProxy.State, ReliableProxy.State), Unit]

Definition Classes
FSM

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from ReliableProxy to any2stringadd[ReliableProxy] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
val ->: actor.FSM.->.type

Definition Classes
FSM
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val Event: actor.FSM.Event.type

Definition Classes
FSM
val StateTimeout: actor.FSM.StateTimeout.type

Definition Classes
FSM
val StopEvent: actor.FSM.StopEvent.type

Definition Classes
FSM
def addSelf(template: String): String

Definition Classes
ReliableProxyDebugLogging
def aroundPostRestart(reason: Throwable): Unit

Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPostStop(): Unit

Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundPreStart(): Unit

Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
def aroundReceive(receive: actor.Actor.Receive, msg: Any): Unit

Attributes
protected[akka]
Definition Classes
Actor
Annotations
@InternalApi()
final def asInstanceOf[T0]: T0

Definition Classes
Any
var attemptedReconnects: Int
final def cancelTimer(name: String): Unit

Definition Classes
FSM
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit val context: ActorContext

Definition Classes
Actor
def createTunnel(target: ActorRef): Unit
var currentSerial: Int
var currentTarget: ActorRef
val debug: Boolean

Definition Classes
ReliableProxyDebugLogging
val defaultConnectInterval: FiniteDuration
def enabled: Boolean

Definition Classes
ReliableProxyDebugLogging
def ensuring(cond: (ReliableProxy) ⇒ Boolean, msg: ⇒ Any): ReliableProxy

Implicit information
This member is added by an implicit conversion from ReliableProxy to Ensuring[ReliableProxy] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (ReliableProxy) ⇒ Boolean): ReliableProxy

Implicit information
This member is added by an implicit conversion from ReliableProxy to Ensuring[ReliableProxy] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): ReliableProxy

Implicit information
This member is added by an implicit conversion from ReliableProxy to Ensuring[ReliableProxy] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): ReliableProxy

Implicit information
This member is added by an implicit conversion from ReliableProxy to Ensuring[ReliableProxy] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from ReliableProxy to StringFormat[ReliableProxy] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getLog: IndexedSeq[LogEntry[ReliableProxy.State, Vector[Message]]]

Attributes
protected
Definition Classes
LoggingFSM
def gossip(msg: Any)(implicit sender: ActorRef): Unit

Attributes
protected
Definition Classes
Listeners
final def goto(nextStateName: ReliableProxy.State): State

Definition Classes
FSM
def hashCode(): Int

Definition Classes
AnyRef → Any
val initialState: Connecting.type
final def initialize(): Unit

Definition Classes
FSM
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTimerActive(name: String): Boolean

Definition Classes
FSM
var lastAckSerial: Int
def listenerManagement: actor.Actor.Receive

Attributes
protected
Definition Classes
Listeners
val listeners: Set[ActorRef]

Attributes
protected
Definition Classes
Listeners
def log: LoggingAdapter

Definition Classes
ActorLogging
def logDebug(template: String, arg1: Any): Unit

Definition Classes
ReliableProxyDebugLogging
def logDebug(template: String, arg1: Any, arg2: Any): Unit

Definition Classes
ReliableProxyDebugLogging
def logDepth: Int

Definition Classes
LoggingFSM
def logResend(size: Int): Unit
def logTermination(reason: Reason): Unit

Attributes
protected
Definition Classes
FSM
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nextBackoff(): FiniteDuration

Returns the next retry interval duration.
Returns the next retry interval duration. By default each interval is the same, reconnectAfter.
def nextSerial(): Int
final def nextStateData: Vector[Message]

Definition Classes
FSM
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def onTermination(terminationHandler: PartialFunction[StopEvent, Unit]): Unit

Definition Classes
FSM
final def onTransition(transitionHandler: TransitionHandler): Unit

Definition Classes
FSM
def postRestart(reason: Throwable): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def postStop(): Unit

Definition Classes
ReliableProxy → FSM → Actor
def preRestart(reason: Throwable, message: Option[Any]): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def preStart(): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def receive: Receive

Definition Classes
FSM → Actor
val reconnectTimer: String
def resend(q: Vector[Message]): Vector[Message]
val resendTimer: String
def resetBackoff(): Unit

Reset backoff interval.
Reset backoff interval.
This and nextBackoff are meant to be implemented by subclasses.
val retryGateClosedFor: Long
def scheduleReconnectTick(): Unit
def scheduleTick(): Unit
implicit final val self: ActorRef

Definition Classes
Actor
def send(msg: Any, snd: ActorRef): Message
final def sender(): ActorRef

Definition Classes
Actor
final def setStateTimeout(state: ReliableProxy.State, timeout: Timeout): Unit

Definition Classes
FSM
final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean): Unit

Definition Classes
FSM
final def startWith(stateName: ReliableProxy.State, stateData: Vector[Message], timeout: Timeout): Unit

Definition Classes
FSM
final def stateData: Vector[Message]

Definition Classes
FSM
final def stateName: ReliableProxy.State

Definition Classes
FSM
final def stay(): State

Definition Classes
FSM
final def stop(reason: Reason, stateData: Vector[Message]): State

Definition Classes
FSM
final def stop(reason: Reason): State

Definition Classes
FSM
final def stop(): State

Definition Classes
FSM
def supervisorStrategy: OneForOneStrategy

Definition Classes
ReliableProxy → Actor
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def terminated(): State
def toParArray: ParArray[T]

Implicit information
This member is added by an implicit conversion from ReliableProxy to CollectionsHaveToParArray[ReliableProxy, T] performed by method CollectionsHaveToParArray in scala.collection.parallel. This conversion will take place only if an implicit value of type (ReliableProxy) ⇒ GenTraversableOnce[T] is in scope.
Definition Classes
CollectionsHaveToParArray
def toString(): String

Definition Classes
AnyRef → Any
implicit final def total2pf(transitionHandler: (ReliableProxy.State, ReliableProxy.State) ⇒ Unit): TransitionHandler

Definition Classes
FSM
final def transform(func: StateFunction): TransformHelper

Definition Classes
FSM
var tunnel: ActorRef
def unhandled(message: Any): Unit

Definition Classes
Actor
def updateSerial(q: Vector[Message]): Vector[Message]
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
final def when(stateName: ReliableProxy.State, stateTimeout: FiniteDuration)(stateFunction: StateFunction): Unit

Definition Classes
FSM
final def whenUnhandled(stateFunction: StateFunction): Unit

Definition Classes
FSM
def →[B](y: B): (ReliableProxy, B)

Implicit information
This member is added by an implicit conversion from ReliableProxy to ArrowAssoc[ReliableProxy] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implicit Value Members

def ->[B](y: B): (ReliableProxy, B)
Implicit information
This member is added by an implicit conversion from ReliableProxy to ArrowAssoc[ReliableProxy] performed by method ArrowAssoc in scala.Predef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(reliableProxy: ArrowAssoc[ReliableProxy]).->(y)
Definition Classes
ArrowAssoc
Annotations
@inline()

Related Docs: object ReliableProxy | package pattern

class ReliableProxy extends Actor with LoggingFSM[State, Vector[Message]] with ReliableProxyDebugLogging

Message Types

Failure Cases

Arguments

Instance Constructors

new ReliableProxy(targetPath: ActorPath, retryAfter: FiniteDuration, reconnectAfter: Option[FiniteDuration], maxConnectAttempts: Option[Int])

Type Members

type Event = actor.FSM.Event[Vector[Message]]

type Receive = PartialFunction[Any, Unit]

type State = actor.FSM.State[ReliableProxy.State, Vector[Message]]

type StateFunction = PartialFunction[Event, State]

type StopEvent = actor.FSM.StopEvent[ReliableProxy.State, Vector[Message]]

type Timeout = Option[FiniteDuration]

final class TransformHelper extends AnyRef

type TransitionHandler = PartialFunction[(ReliableProxy.State, ReliableProxy.State), Unit]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

val ->: actor.FSM.->.type

final def ==(arg0: Any): Boolean

val Event: actor.FSM.Event.type

val StateTimeout: actor.FSM.StateTimeout.type

val StopEvent: actor.FSM.StopEvent.type

def addSelf(template: String): String

def aroundPostRestart(reason: Throwable): Unit

def aroundPostStop(): Unit

def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

def aroundPreStart(): Unit

def aroundReceive(receive: actor.Actor.Receive, msg: Any): Unit

final def asInstanceOf[T0]: T0

var attemptedReconnects: Int

final def cancelTimer(name: String): Unit

def clone(): AnyRef

implicit val context: ActorContext

def createTunnel(target: ActorRef): Unit

var currentSerial: Int

var currentTarget: ActorRef

val debug: Boolean

val defaultConnectInterval: FiniteDuration

def enabled: Boolean

def ensuring(cond: (ReliableProxy) ⇒ Boolean, msg: ⇒ Any): ReliableProxy

def ensuring(cond: (ReliableProxy) ⇒ Boolean): ReliableProxy

def ensuring(cond: Boolean, msg: ⇒ Any): ReliableProxy

def ensuring(cond: Boolean): ReliableProxy

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def getLog: IndexedSeq[LogEntry[ReliableProxy.State, Vector[Message]]]

def gossip(msg: Any)(implicit sender: ActorRef): Unit

final def goto(nextStateName: ReliableProxy.State): State

def hashCode(): Int

val initialState: Connecting.type

final def initialize(): Unit

final def isInstanceOf[T0]: Boolean

final def isTimerActive(name: String): Boolean

var lastAckSerial: Int

def listenerManagement: actor.Actor.Receive

val listeners: Set[ActorRef]

def log: LoggingAdapter

def logDebug(template: String, arg1: Any): Unit

def logDebug(template: String, arg1: Any, arg2: Any): Unit

def logDepth: Int

def logResend(size: Int): Unit

def logTermination(reason: Reason): Unit

final def ne(arg0: AnyRef): Boolean

def nextBackoff(): FiniteDuration

def nextSerial(): Int

final def nextStateData: Vector[Message]

final def notify(): Unit

final def notifyAll(): Unit

final def onTermination(terminationHandler: PartialFunction[StopEvent, Unit]): Unit

final def onTransition(transitionHandler: TransitionHandler): Unit

def postRestart(reason: Throwable): Unit

def postStop(): Unit

def preRestart(reason: Throwable, message: Option[Any]): Unit