classReliableProxy extends Actor with FSM[State, Vector[Message]]
A ReliableProxy is a means to wrap a remote actor reference in order to
obtain certain improved delivery guarantees:
as long as none of the JVMs crashes and the proxy and its remote-deployed
peer are not forcefully terminated or restarted, 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. 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:
val proxy = context.actorOf(Props(new ReliableProxy(target)))
or in Java:
final ActorRef proxy = getContext().actorOf(new Props(new UntypedActorFactory() {
public Actor create() {
returnnew ReliableProxy(target);
}
}));
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.
Any other message type sent to this actor will be delivered via a remote-deployed
child actor to the designated target. Message types declared in the companion
object are for internal use only and not to be sent from the outside.
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
target is the akka.actor.ActorRef to which all messages will be
forwarded which are sent to this actor. It can be any type of actor reference,
but the “remote” tunnel endpoint will be deployed on the node where the target
ref points to.
retryAfter is the ACK timeout after which all outstanding messages
will be resent. There is not limit on the queue size or the number of retries.
A ReliableProxy is a means to wrap a remote actor reference in order to obtain certain improved delivery guarantees:
These guarantees are valid for the communication between the two end-points of the reliable “tunnel”, which usually spans an unreliable network. 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:
or in Java:
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
SubscribeTransitionCallBackUnsubscribeTransitionCallBackFailure 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
target is the akka.actor.ActorRef to which all messages will be forwarded which are sent to this actor. It can be any type of actor reference, but the “remote” tunnel endpoint will be deployed on the node where the target ref points to.
retryAfter is the ACK timeout after which all outstanding messages will be resent. There is not limit on the queue size or the number of retries.