public ThrottledAssociation(IActorRef manager, IAssociationEventListener associationHandler, AssociationHandle originalHandle, bool inbound)
{
Manager = manager;
AssociationHandler = associationHandler;
OriginalHandle = originalHandle;
Inbound = inbound;
InitializeFSM();
}
public static Props InboundProps(HandshakeInfo handshakeInfo, AssociationHandle wrappedHandle,
IAssociationEventListener associationEventListener, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector)
{
return
(Props.Create(
() =>
new ProtocolStateActor(handshakeInfo, wrappedHandle, associationEventListener, settings, codec, failureDetector)));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="originalLocalAddress">TBD</param>
/// <param name="originalRemoteAddress">TBD</param>
/// <param name="wrappedHandle">TBD</param>
/// <param name="addedSchemeIdentifier">TBD</param>
protected AbstractTransportAdapterHandle(Address originalLocalAddress, Address originalRemoteAddress, AssociationHandle wrappedHandle, string addedSchemeIdentifier) : base(originalLocalAddress, originalRemoteAddress)
{
WrappedHandle = wrappedHandle;
OriginalRemoteAddress = originalRemoteAddress;
OriginalLocalAddress = originalLocalAddress;
SchemeAugmenter = new SchemeAugmenter(addedSchemeIdentifier);
RemoteAddress = SchemeAugmenter.AugmentScheme(OriginalRemoteAddress);
LocalAddress = SchemeAugmenter.AugmentScheme(OriginalLocalAddress);
}
private ThrottlerHandle WrapHandle(AssociationHandle originalHandle, IAssociationEventListener listener,
bool inbound)
{
var managerRef = Self;
return(new ThrottlerHandle(originalHandle, Context.ActorOf(
RARP.For(Context.System).ConfigureDispatcher(
Props.Create(() => new ThrottledAssociation(managerRef, listener, originalHandle, inbound)).WithDeploy(Deploy.Local)),
"throttler" + nextId())));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="wrappedHandle">TBD</param>
/// <param name="gremlinAdapter">TBD</param>
public FailureInjectorHandle(AssociationHandle wrappedHandle, FailureInjectorTransportAdapter gremlinAdapter)
: base(wrappedHandle, FailureInjectorTransportAdapter.FailureInjectorSchemeIdentifier)
{
_gremlinAdapter = gremlinAdapter;
ReadHandlerSource.Task.ContinueWith(tr =>
{
_upstreamListener = tr.Result;
WrappedHandle.ReadHandlerSource.SetResult(this);
}, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion);
}
private void SendDisassociate(AssociationHandle wrappedHandle, DisassociateInfo info)
{
try
{
wrappedHandle.Write(_codec.ConstructDisassociate(info));
}
catch (Exception ex)
{
throw new AkkaProtocolException("Error writing DISASSOCIATE to transport", ex);
}
}
private bool SendAssociate(AssociationHandle wrappedHandle, HandshakeInfo info)
{
try
{
return(wrappedHandle.Write(_codec.ConstructAssociate(info)));
}
catch (Exception ex)
{
throw new AkkaProtocolException("Error writing ASSOCIATE to transport", ex);
}
}
private Task <IHandleEventListener> NotifyOutboundHandler(AssociationHandle wrappedHandle,
HandshakeInfo handshakeInfo, TaskCompletionSource <AssociationHandle> statusPromise)
{
var readHandlerPromise = new TaskCompletionSource <IHandleEventListener>();
ListenForListenerRegistration(readHandlerPromise);
statusPromise.SetResult(new AkkaProtocolHandle(_localAddress, wrappedHandle.RemoteAddress, readHandlerPromise, wrappedHandle, handshakeInfo, Self, _codec));
return(readHandlerPromise.Task);
}
private void SendHeartBeat(AssociationHandle wrappedHandle)
{
try
{
wrappedHandle.Write(_codec.ConstructHeartbeat());
}
catch (Exception ex)
{
throw new AkkaProtocolException("Error writing HEARTBEAT to transport", ex);
}
}
private Task <IHandleEventListener> NotifyInboundHandler(AssociationHandle wrappedHandle,
HandshakeInfo handshakeInfo, IAssociationEventListener associationEventListener)
{
var readHandlerPromise = new TaskCompletionSource <IHandleEventListener>();
ListenForListenerRegistration(readHandlerPromise);
associationEventListener.Notify(
new InboundAssociation(
new AkkaProtocolHandle(_localAddress, handshakeInfo.Origin, readHandlerPromise, wrappedHandle, handshakeInfo, Self, _codec)));
return(readHandlerPromise.Task);
}
private State <AssociationState, ProtocolStateData> HandleTimers(AssociationHandle wrappedHandle)
{
if (_failureDetector.IsAvailable)
{
SendHeartBeat(wrappedHandle);
return(Stay());
}
else
{
SendDisassociate(wrappedHandle, DisassociateInfo.Unknown);
return(Stop(new Failure(new TimeoutReason())));
}
}
private State <AssociationState, ProtocolStateData> HandleTimers(AssociationHandle wrappedHandle)
{
if (_failureDetector.IsAvailable)
{
SendHeartBeat(wrappedHandle);
return(Stay());
}
else
{
//send disassociate just to be sure
SendDisassociate(wrappedHandle, DisassociateInfo.Unknown);
return(Stop(new Failure(new TimeoutReason("No response from remote. Handshake timed out or transport failure detector triggered."))));
}
}
public OutboundUnderlyingAssociated(TaskCompletionSource <AssociationHandle> statusCompletionSource, AssociationHandle wrappedHandle)
{
WrappedHandle = wrappedHandle;
StatusCompletionSource = statusCompletionSource;
}
private void InitializeFSM()
{
When(AssociationState.Closed, fsmEvent =>
{
State <AssociationState, ProtocolStateData> nextState = null;
//Transport layer events for outbound associations
fsmEvent.FsmEvent.Match()
.With <Status.Failure>(f => fsmEvent.StateData.Match()
.With <OutboundUnassociated>(ou =>
{
ou.StatusCompletionSource.SetException(f.Cause);
nextState = Stop();
}))
.With <AssociationHandle>(h => fsmEvent.StateData.Match()
.With <OutboundUnassociated>(ou =>
{
var wrappedHandle = h;
var statusPromise = ou.StatusCompletionSource;
wrappedHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));
if (SendAssociate(wrappedHandle, _localHandshakeInfo))
{
_failureDetector.HeartBeat();
InitTimers();
nextState =
GoTo(AssociationState.WaitHandshake)
.Using(new OutboundUnderlyingAssociated(statusPromise, wrappedHandle));
}
else
{
SetTimer("associate-retry", wrappedHandle,
Context.System.Provider.AsInstanceOf <RemoteActorRefProvider>()
.RemoteSettings.BackoffPeriod, repeat: false);
nextState = Stay();
}
}))
.With <DisassociateUnderlying>(d =>
{
nextState = Stop();
})
.Default(m => { nextState = Stay(); });
return(nextState);
});
//Transport layer events for outbound associations
When(AssociationState.WaitHandshake, @event =>
{
State <AssociationState, ProtocolStateData> nextState = null;
@event.FsmEvent.Match()
.With <UnderlyingTransportError>(e =>
{
PublishError(e);
nextState = Stay();
})
.With <Disassociated>(d =>
{
nextState = Stop(new Failure(d.Info));
})
.With <InboundPayload>(m =>
{
var pdu = DecodePdu(m.Payload);
@event.StateData.Match()
.With <OutboundUnderlyingAssociated>(ola =>
{
var wrappedHandle = ola.WrappedHandle;
var statusCompletionSource = ola.StatusCompletionSource;
pdu.Match()
.With <Associate>(a =>
{
var handshakeInfo = a.Info;
if (_refuseUid.HasValue && _refuseUid == handshakeInfo.Uid) //refused UID
{
SendDisassociate(wrappedHandle, DisassociateInfo.Quarantined);
nextState = Stop(new Failure(new ForbiddenUidReason()));
}
else //accepted UID
{
_failureDetector.HeartBeat();
nextState =
GoTo(AssociationState.Open)
.Using(
new AssociatedWaitHandler(
NotifyOutboundHandler(wrappedHandle, handshakeInfo,
statusCompletionSource), wrappedHandle,
new Queue <ByteString>()));
}
})
.With <Disassociate>(d =>
{
//After receiving Disassociate we MUST NOT send back a Disassociate (loop)
nextState = Stop(new Failure(d.Reason));
})
.Default(d =>
{
_log.Debug(string.Format("Exepcted message of type Associate; instead received {0}", d));
//Expect handshake to be finished, dropping connection
SendDisassociate(wrappedHandle, DisassociateInfo.Unknown);
nextState = Stop();
});
})
.With <InboundUnassociated>(iu =>
{
var associationHandler = iu.AssociationEventListener;
var wrappedHandle = iu.WrappedHandle;
pdu.Match()
.With <Disassociate>(d => nextState = Stop(new Failure(d.Reason)))
.With <Associate>(a =>
{
SendAssociate(wrappedHandle, _localHandshakeInfo);
_failureDetector.HeartBeat();
InitTimers();
nextState =
GoTo(AssociationState.Open)
.Using(
new AssociatedWaitHandler(
NotifyInboundHandler(wrappedHandle, a.Info, associationHandler),
wrappedHandle, new Queue <ByteString>()));
})
.Default(d =>
{
SendDisassociate(wrappedHandle, DisassociateInfo.Unknown);
nextState = Stop();
});
});
})
.With <HeartbeatTimer>(h => @event.StateData.Match()
.With <OutboundUnderlyingAssociated>(ou => nextState = HandleTimers(ou.WrappedHandle)));
return(nextState);
});
When(AssociationState.Open, @event =>
{
State <AssociationState, ProtocolStateData> nextState = null;
@event.FsmEvent.Match()
.With <UnderlyingTransportError>(e =>
{
PublishError(e);
nextState = Stay();
})
.With <Disassociated>(d =>
{
nextState = Stop(new Failure(d.Info));
})
.With <InboundPayload>(ip =>
{
var pdu = DecodePdu(ip.Payload);
pdu.Match()
.With <Disassociate>(d => nextState = Stop(new Failure(d.Reason)))
.With <Heartbeat>(h =>
{
_failureDetector.HeartBeat();
nextState = Stay();
})
.With <Payload>(p => @event.StateData.Match()
.With <AssociatedWaitHandler>(awh =>
{
var nQueue = new Queue <ByteString>(awh.Queue);
nQueue.Enqueue(p.Bytes);
nextState =
Stay()
.Using(new AssociatedWaitHandler(awh.HandlerListener, awh.WrappedHandle,
nQueue));
})
.With <ListenerReady>(lr =>
{
lr.Listener.Notify(new InboundPayload(p.Bytes));
nextState = Stay();
})
.Default(msg =>
{
throw new AkkaProtocolException(
string.Format("Unhandled message in state Open(InboundPayload) with type {0}",
msg));
}))
.Default(d =>
{
nextState = Stay();
});
})
.With <HeartbeatTimer>(hrt => @event.StateData.Match()
.With <AssociatedWaitHandler>(awh => nextState = HandleTimers(awh.WrappedHandle))
.With <ListenerReady>(lr => nextState = HandleTimers(lr.WrappedHandle)))
.With <DisassociateUnderlying>(du =>
{
AssociationHandle handle = null;
@event.StateData.Match()
.With <ListenerReady>(lr => handle = lr.WrappedHandle)
.With <AssociatedWaitHandler>(awh => handle = awh.WrappedHandle)
.Default(
msg =>
{
throw new AkkaProtocolException(
string.Format(
"unhandled message in state Open(DisassociateUnderlying) with type {0}", msg));
});
SendDisassociate(handle, du.Info);
nextState = Stop();
})
.With <HandleListenerRegistered>(hlr => @event.StateData.Match()
.With <AssociatedWaitHandler>(awh =>
{
foreach (var msg in awh.Queue)
{
hlr.Listener.Notify(new InboundPayload(msg));
}
nextState = Stay().Using(new ListenerReady(hlr.Listener, awh.WrappedHandle));
}));
return(nextState);
});
OnTermination(@event => @event.StateData.Match()
.With <OutboundUnassociated>(ou => ou.StatusCompletionSource.TrySetException(@event.Reason is Failure
? new AkkaProtocolException(@event.Reason.ToString())
: new AkkaProtocolException("Transport disassociated before handshake finished")))
.With <OutboundUnderlyingAssociated>(oua =>
{
Exception associationFailure = null;
@event.Reason.Match()
.With <Failure>(f => f.Cause.Match()
.With <TimeoutReason>(
timeout =>
associationFailure =
new AkkaProtocolException("No reponse from remote. Handshake timed out."))
.With <ForbiddenUidReason>(
forbidden =>
associationFailure =
new AkkaProtocolException(
"The remote system has a UID that has been quarantined. Association aborted."))
.With <DisassociateInfo>(info => associationFailure = DisassociateException(info))
.Default(
msg =>
associationFailure =
new AkkaProtocolException(
"Transport disassociated before handshake finished")));
oua.StatusCompletionSource.TrySetException(associationFailure);
oua.WrappedHandle.Disassociate();
})
.With <AssociatedWaitHandler>(awh =>
{
Disassociated disassociateNotification = null;
if (@event.Reason is Failure && ((Failure)@event.Reason).Cause is DisassociateInfo)
{
disassociateNotification =
new Disassociated(((Failure)@event.Reason).Cause.AsInstanceOf <DisassociateInfo>());
}
else
{
disassociateNotification = new Disassociated(DisassociateInfo.Unknown);
}
awh.HandlerListener.ContinueWith(result => result.Result.Notify(disassociateNotification),
TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.AttachedToParent);
})
.With <ListenerReady>(lr =>
{
Disassociated disassociateNotification = null;
if (@event.Reason is Failure && ((Failure)@event.Reason).Cause is DisassociateInfo)
{
disassociateNotification =
new Disassociated(((Failure)@event.Reason).Cause.AsInstanceOf <DisassociateInfo>());
}
else
{
disassociateNotification = new Disassociated(DisassociateInfo.Unknown);
}
lr.Listener.Notify(disassociateNotification);
lr.WrappedHandle.Disassociate();
})
.With <InboundUnassociated>(iu =>
iu.WrappedHandle.Disassociate()));
_initialData.Match()
.With <OutboundUnassociated>(d =>
{
d.Transport.Associate(d.RemoteAddress).PipeTo(Self);
StartWith(AssociationState.Closed, d);
})
.With <InboundUnassociated>(d =>
{
d.WrappedHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));
StartWith(AssociationState.WaitHandshake, d);
});
}
protected bool Equals(AssociationHandle other)
{
return Equals(LocalAddress, other.LocalAddress) && Equals(RemoteAddress, other.RemoteAddress);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="other">TBD</param>
/// <returns>TBD</returns>
protected bool Equals(AssociationHandle other)
{
return(Equals(LocalAddress, other.LocalAddress) && Equals(RemoteAddress, other.RemoteAddress));
}
public FailureInjectorHandle(AssociationHandle wrappedHandle, FailureInjectorTransportAdapter gremlinAdapter)
: base(wrappedHandle, FailureInjectorTransportAdapter.FailureInjectorSchemeIdentifier)
{
_gremlinAdapter = gremlinAdapter;
ReadHandlerSource.Task.ContinueWith(tr =>
{
_upstreamListener = tr.Result;
WrappedHandle.ReadHandlerSource.SetResult(this);
}, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion);
}
public HandleMsg(AssociationHandle handle)
{
Handle = handle;
}
public AkkaProtocolHandle(Address originalLocalAddress, Address originalRemoteAddress,
TaskCompletionSource <IHandleEventListener> readHandlerCompletionSource, AssociationHandle wrappedHandle,
HandshakeInfo handshakeInfo, ActorRef stateActor, AkkaPduCodec codec)
: base(originalLocalAddress, originalRemoteAddress, wrappedHandle, RemoteSettings.AkkaScheme)
{
HandshakeInfo = handshakeInfo;
StateActor = stateActor;
ReadHandlerSource = readHandlerCompletionSource;
Codec = codec;
}
public ThrottlerHandle(AssociationHandle wrappedHandle, IActorRef throttlerActor) : base(wrappedHandle, ThrottleTransportAdapter.Scheme)
{
ThrottlerActor = throttlerActor;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="wrappedHandle">TBD</param>
/// <param name="addedSchemeIdentifier">TBD</param>
protected AbstractTransportAdapterHandle(AssociationHandle wrappedHandle, string addedSchemeIdentifier)
: this(wrappedHandle.LocalAddress, wrappedHandle.RemoteAddress, wrappedHandle, addedSchemeIdentifier)
{
}
public InboundUnassociated(IAssociationEventListener associationEventListener, AssociationHandle wrappedHandle)
{
WrappedHandle = wrappedHandle;
AssociationEventListener = associationEventListener;
}
public AssociatedWaitHandler(Task <IHandleEventListener> handlerListener, AssociationHandle wrappedHandle, Queue <ByteString> queue)
{
Queue = queue;
WrappedHandle = wrappedHandle;
HandlerListener = handlerListener;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="association">TBD</param>
public InboundAssociation(AssociationHandle association)
{
Association = association;
}
public ListenerReady(IHandleEventListener listener, AssociationHandle wrappedHandle)
{
WrappedHandle = wrappedHandle;
Listener = listener;
}
public InboundAssociation(AssociationHandle association)
{
Association = association;
}
/// <summary>
/// Constructor for inbound ProtocolStateActors
/// </summary>
public ProtocolStateActor(HandshakeInfo handshakeInfo, AssociationHandle wrappedHandle, IAssociationEventListener associationEventListener, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector)
: this(new InboundUnassociated(associationEventListener, wrappedHandle), handshakeInfo, settings, codec, failureDetector, refuseUid : null)
{
}
/// <summary>
/// TBD
/// </summary>
/// <param name="associationHandle">TBD</param>
/// <param name="statusPromise">TBD</param>
public AssociateResult(AssociationHandle associationHandle, TaskCompletionSource <AssociationHandle> statusPromise)
{
StatusPromise = statusPromise;
AssociationHandle = associationHandle;
}
private void InitializeFSM()
{
When(AssociationState.Closed, fsmEvent =>
{
State <AssociationState, ProtocolStateData> nextState = null;
//Transport layer events for outbound associations
fsmEvent.FsmEvent.Match()
.With <Status.Failure>(f => fsmEvent.StateData.Match()
.With <OutboundUnassociated>(ou =>
{
ou.StatusCompletionSource.SetException(f.Cause);
nextState = Stop();
}))
.With <AssociationHandle>(h => fsmEvent.StateData.Match()
.With <OutboundUnassociated>(ou =>
{
/*
* Association has been established, but handshake is not yet complete.
* This actor, the outbound ProtocolStateActor, can now set itself as
* the read handler for the remainder of the handshake process.
*/
AssociationHandle wrappedHandle = h;
var statusPromise = ou.StatusCompletionSource;
wrappedHandle.ReadHandlerSource.TrySetResult(new ActorHandleEventListener(Self));
if (SendAssociate(wrappedHandle, _localHandshakeInfo))
{
_failureDetector.HeartBeat();
InitTimers();
// wait for reply from the inbound side of the connection (WaitHandshake)
nextState =
GoTo(AssociationState.WaitHandshake)
.Using(new OutboundUnderlyingAssociated(statusPromise, wrappedHandle));
}
else
{
//Otherwise, retry
SetTimer("associate-retry", wrappedHandle,
((RemoteActorRefProvider)((ActorSystemImpl)Context.System).Provider) //TODO: rewrite using RARP ActorSystem Extension
.RemoteSettings.BackoffPeriod, repeat: false);
nextState = Stay();
}
}))
.With <DisassociateUnderlying>(d =>
{
nextState = Stop();
})
.Default(m => { nextState = Stay(); });
return(nextState);
});
//Transport layer events for outbound associations
When(AssociationState.WaitHandshake, @event =>
{
State <AssociationState, ProtocolStateData> nextState = null;
@event.FsmEvent.Match()
.With <UnderlyingTransportError>(e =>
{
PublishError(e);
nextState = Stay();
})
.With <Disassociated>(d =>
{
nextState = Stop(new Failure(d.Info));
})
.With <InboundPayload>(m =>
{
var pdu = DecodePdu(m.Payload);
@event.StateData.Match()
.With <OutboundUnderlyingAssociated>(ola =>
{
/*
* This state is used for OutboundProtocolState actors when they receive
* a reply back from the inbound end of the association.
*/
var wrappedHandle = ola.WrappedHandle;
var statusCompletionSource = ola.StatusCompletionSource;
pdu.Match()
.With <Associate>(a =>
{
var handshakeInfo = a.Info;
if (_refuseUid.HasValue && _refuseUid == handshakeInfo.Uid) //refused UID
{
SendDisassociate(wrappedHandle, DisassociateInfo.Quarantined);
nextState = Stop(new Failure(new ForbiddenUidReason()));
}
else //accepted UID
{
_failureDetector.HeartBeat();
nextState =
GoTo(AssociationState.Open)
.Using(
new AssociatedWaitHandler(
NotifyOutboundHandler(wrappedHandle, handshakeInfo,
statusCompletionSource), wrappedHandle,
new Queue <ByteString>()));
}
})
.With <Disassociate>(d =>
{
//After receiving Disassociate we MUST NOT send back a Disassociate (loop)
nextState = Stop(new Failure(d.Reason));
})
.Default(d =>
{
_log.Debug(string.Format("Expected message of type Associate; instead received {0}", d));
//Expect handshake to be finished, dropping connection
SendDisassociate(wrappedHandle, DisassociateInfo.Unknown);
nextState = Stop();
});
})
.With <InboundUnassociated>(iu =>
{
/*
* This state is used by inbound protocol state actors
* when they receive an association attempt from the
* outbound side of the association.
*/
var associationHandler = iu.AssociationEventListener;
var wrappedHandle = iu.WrappedHandle;
pdu.Match()
.With <Disassociate>(d =>
{
nextState = Stop(new Failure(d.Reason));
})
.With <Associate>(a =>
{
SendAssociate(wrappedHandle, _localHandshakeInfo);
_failureDetector.HeartBeat();
InitTimers();
nextState =
GoTo(AssociationState.Open)
.Using(
new AssociatedWaitHandler(
NotifyInboundHandler(wrappedHandle, a.Info, associationHandler),
wrappedHandle, new Queue <ByteString>()));
})
.Default(d =>
{
SendDisassociate(wrappedHandle, DisassociateInfo.Unknown);
nextState = Stop();
});
});
})
.With <HeartbeatTimer>(h => @event.StateData.Match()
.With <OutboundUnderlyingAssociated>(ou => nextState = HandleTimers(ou.WrappedHandle)));
return(nextState);
});
When(AssociationState.Open, @event =>
{
State <AssociationState, ProtocolStateData> nextState = null;
@event.FsmEvent.Match()
.With <UnderlyingTransportError>(e =>
{
PublishError(e);
nextState = Stay();
})
.With <Disassociated>(d =>
{
nextState = Stop(new Failure(d.Info));
})
.With <InboundPayload>(ip =>
{
var pdu = DecodePdu(ip.Payload);
pdu.Match()
.With <Disassociate>(d =>
{
nextState = Stop(new Failure(d.Reason));
})
.With <Heartbeat>(h =>
{
_failureDetector.HeartBeat();
nextState = Stay();
})
.With <Payload>(p =>
{
_failureDetector.HeartBeat();
@event.StateData.Match()
.With <AssociatedWaitHandler>(awh =>
{
var nQueue = new Queue <ByteString>(awh.Queue);
nQueue.Enqueue(p.Bytes);
nextState =
Stay()
.Using(new AssociatedWaitHandler(awh.HandlerListener, awh.WrappedHandle,
nQueue));
})
.With <ListenerReady>(lr =>
{
lr.Listener.Notify(new InboundPayload(p.Bytes));
nextState = Stay();
})
.Default(msg =>
{
throw new AkkaProtocolException(
string.Format(
"Unhandled message in state Open(InboundPayload) with type {0}",
msg));
});
})
.Default(d =>
{
nextState = Stay();
});
})
.With <HeartbeatTimer>(hrt => @event.StateData.Match()
.With <AssociatedWaitHandler>(awh => nextState = HandleTimers(awh.WrappedHandle))
.With <ListenerReady>(lr => nextState = HandleTimers(lr.WrappedHandle)))
.With <DisassociateUnderlying>(du =>
{
AssociationHandle handle = null;
@event.StateData.Match()
.With <ListenerReady>(lr => handle = lr.WrappedHandle)
.With <AssociatedWaitHandler>(awh => handle = awh.WrappedHandle)
.Default(
msg =>
{
throw new AkkaProtocolException(
string.Format(
"unhandled message in state Open(DisassociateUnderlying) with type {0}", msg));
});
SendDisassociate(handle, du.Info);
nextState = Stop();
})
.With <HandleListenerRegistered>(hlr => @event.StateData.Match()
.With <AssociatedWaitHandler>(awh =>
{
foreach (var msg in awh.Queue)
{
hlr.Listener.Notify(new InboundPayload(msg));
}
nextState = Stay().Using(new ListenerReady(hlr.Listener, awh.WrappedHandle));
}));
return(nextState);
});
OnTermination(@event => @event.StateData.Match()
.With <OutboundUnassociated>(ou => ou.StatusCompletionSource.TrySetException(@event.Reason is Failure
? new AkkaProtocolException(@event.Reason.ToString())
: new AkkaProtocolException("Transport disassociated before handshake finished")))
.With <OutboundUnderlyingAssociated>(oua =>
{
Exception associationFailure = null;
@event.Reason.Match()
.With <Failure>(f => f.Cause.Match()
.With <TimeoutReason>(
timeout =>
associationFailure =
new AkkaProtocolException(timeout.ErrorMessage))
.With <ForbiddenUidReason>(
forbidden =>
associationFailure =
new AkkaProtocolException(
"The remote system has a UID that has been quarantined. Association aborted."))
.With <DisassociateInfo>(info => associationFailure = DisassociateException(info)))
.Default(
msg =>
associationFailure =
new AkkaProtocolException(
"Transport disassociated before handshake finished"));
oua.StatusCompletionSource.TrySetException(associationFailure);
oua.WrappedHandle.Disassociate();
})
.With <AssociatedWaitHandler>(awh =>
{
Disassociated disassociateNotification = null;
if (@event.Reason is Failure && @event.Reason.AsInstanceOf <Failure>().Cause is DisassociateInfo)
{
disassociateNotification =
new Disassociated(@event.Reason.AsInstanceOf <Failure>().Cause.AsInstanceOf <DisassociateInfo>());
}
else
{
disassociateNotification = new Disassociated(DisassociateInfo.Unknown);
}
awh.HandlerListener.ContinueWith(result => result.Result.Notify(disassociateNotification),
TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.AttachedToParent);
})
.With <ListenerReady>(lr =>
{
Disassociated disassociateNotification = null;
if (@event.Reason is Failure && ((Failure)@event.Reason).Cause is DisassociateInfo)
{
disassociateNotification =
new Disassociated(((Failure)@event.Reason).Cause.AsInstanceOf <DisassociateInfo>());
}
else
{
disassociateNotification = new Disassociated(DisassociateInfo.Unknown);
}
lr.Listener.Notify(disassociateNotification);
lr.WrappedHandle.Disassociate();
})
.With <InboundUnassociated>(iu =>
iu.WrappedHandle.Disassociate()));
/*
* Set the initial ProtocolStateActor state to CLOSED if OUTBOUND
* Set the initial ProtocolStateActor state to WAITHANDSHAKE if INBOUND
* */
_initialData.Match()
.With <OutboundUnassociated>(d =>
{
// attempt to open underlying transport to the remote address
// if using Helios, this is where the socket connection is opened.
d.Transport.Associate(d.RemoteAddress).PipeTo(Self);
StartWith(AssociationState.Closed, d);
})
.With <InboundUnassociated>(d =>
{
// inbound transport is opened already inside the ProtocolStateManager
// therefore we just have to set ourselves as listener and wait for
// incoming handshake attempts from the client.
d.WrappedHandle.ReadHandlerSource.SetResult(new ActorHandleEventListener(Self));
StartWith(AssociationState.WaitHandshake, d);
});
}
