public void IfScaleOutBackendSocketSendMessageThrowsHostUnreachableException_UnreachableNodeIsUnregistered()
{
messageRouter = CreateMessageRouter(null, externalRoutingTable.Object);
var message = Message.Create(new SimpleMessage()).As <Message>();
var otherNode = new ReceiverIdentifier(Guid.NewGuid().ToByteArray());
message.SetReceiverNode(otherNode);
var peerConnection = new PeerConnection {
Node = new Node("tcp://127.0.0.1:9009", otherNode.Identity)
};
externalRoutingTable.Setup(m => m.FindRoutes(It.IsAny <ExternalRouteLookupRequest>())).Returns(new[] { peerConnection });
localRouterSocket.SetupMessageReceived(message, ReceiveMessageDelay);
scaleOutSocket.Setup(m => m.SendMessage(It.IsAny <IMessage>())).Throws <HostUnreachableException>();
var unregPayload = new UnregisterUnreachableNodeMessage {
ReceiverNodeIdentity = peerConnection.Node.SocketIdentity
};
var unregMessage = Message.Create(unregPayload);
var serviceMessageHandler = new Mock <IServiceMessageHandler>();
serviceMessageHandlerRegistry.Setup(m => m.GetMessageHandler(It.Is <MessageIdentifier>(msg => msg.Equals(unregMessage)))).Returns(serviceMessageHandler.Object);
//
messageRouter.Start();
ReceiveMessageCompletionDelay.Sleep();
messageRouter.Stop();
//
serviceMessageHandlerRegistry.Verify(m => m.GetMessageHandler(It.Is <MessageIdentifier>(msg => msg.Equals(unregMessage))), Times.Once);
serviceMessageHandler.Verify(m => m.Handle(unregMessage, scaleOutSocket.Object));
}
private bool ForwardMessageAway(ExternalRouteLookupRequest lookupRequest, Message message, ISocket scaleOutBackend)
{
var routes = message.Distribution == DistributionPattern.Broadcast && !MessageCameFromLocalActor(message)
? Enumerable.Empty <PeerConnection>()
: externalRoutingTable.FindRoutes(lookupRequest);
foreach (var route in routes)
{
try
{
if (!route.Connected)
{
scaleOutBackend.Connect(route.Node.Uri, waitUntilConnected: true);
route.Connected = true;
clusterServices.GetClusterHealthMonitor()
.StartPeerMonitoring(new Node(route.Node.Uri, route.Node.SocketIdentity), route.Health);
}
message.SetSocketIdentity(route.Node.SocketIdentity);
message.AddHop();
message.PushRouterAddress(scaleOutConfigurationProvider.GetScaleOutAddress());
message.SignMessage(securityProvider);
scaleOutBackend.SendMessage(message);
ForwardedToOtherNode(message);
}
catch (TimeoutException err)
{
clusterServices.GetClusterHealthMonitor()
.ScheduleConnectivityCheck(new ReceiverIdentifier(route.Node.SocketIdentity));
logger.Error(err);
}
catch (HostUnreachableException err)
{
var unregMessage = new UnregisterUnreachableNodeMessage {
ReceiverNodeIdentity = route.Node.SocketIdentity
};
TryHandleServiceMessage(Message.Create(unregMessage).As <Message>(), scaleOutBackend);
logger.Error(err);
}
}
return(routes.Any());
}
private bool SendMessageAway(IEnumerable <PeerConnection> routes, Message message, ISocket scaleOutBackend)
{
foreach (var route in routes)
{
try
{
if (!route.Connected)
{
scaleOutBackend.Connect(route.Node.Uri, waitUntilConnected: true);
route.Connected = true;
clusterServices.GetClusterHealthMonitor()
.StartPeerMonitoring(new Node(route.Node.Uri, route.Node.SocketIdentity), route.Health);
}
message.SetSocketIdentity(route.Node.SocketIdentity);
message.AddHop();
message.PushRouterAddress(scaleOutConfigurationProvider.GetScaleOutAddress());
message.SignMessage(securityProvider);
scaleOutBackend.SendMessage(message);
ForwardedToOtherNode(message);
}
catch (TimeoutException err)
{
clusterServices.GetClusterHealthMonitor()
.ScheduleConnectivityCheck(new ReceiverIdentifier(route.Node.SocketIdentity));
logger.Error(err);
}
catch (HostUnreachableException err)
{
var unregMessage = new UnregisterUnreachableNodeMessage {
ReceiverNodeIdentity = route.Node.SocketIdentity
};
TryHandleServiceMessage(Message.Create(unregMessage).As <Message>(), scaleOutBackend);
logger.Error(err);
}
}
return(routes.Any());
}
public void PeerIsDisconnected_OnlyIfPeerConnectionActionIsDisconnect(PeerConnectionAction peerConnectionAction)
{
var receiverNodeIdentifier = new ReceiverIdentifier(Guid.NewGuid().ToByteArray());
var payload = new UnregisterUnreachableNodeMessage {
ReceiverNodeIdentity = receiverNodeIdentifier.Identity
};
var message = Message.Create(payload);
var peerRemoveResult = new PeerRemoveResult
{
ConnectionAction = peerConnectionAction,
Uri = new Uri("tcp://127.0.0.1:9009")
};
externalRoutingTable.Setup(m => m.RemoveNodeRoute(receiverNodeIdentifier)).Returns(peerRemoveResult);
//
handler.Handle(message, backendSocket.Object);
//
externalRoutingTable.Verify(m => m.RemoveNodeRoute(receiverNodeIdentifier), Times.Once);
backendSocket.Verify(m => m.Disconnect(peerRemoveResult.Uri), Times.Exactly(peerConnectionAction == PeerConnectionAction.Disconnect ? 1 : 0));
clusterHealthMonitor.Verify(m => m.DeletePeer(receiverNodeIdentifier), Times.Exactly(peerConnectionAction != PeerConnectionAction.KeepConnection ? 1 : 0));
}
