public void IfSeveralActorsRegisteredToHandleTheMessage_TheAreFoundInRoundRobinManner()
{
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
var registrations = EnumerableExtensions.Produce(Randomizer.Int32(6, 16),
() => new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
DestinationSocket = new LocalSocket <IMessage>(),
MessageContracts = new[] { new MessageContract {
Message = messageIdentifier
} }
});
registrations.ForEach(r => internalRoutingTable.AddMessageRoute(r));
//
foreach (var registration in registrations)
{
var socket = internalRoutingTable.FindRoutes(new InternalRouteLookupRequest
{
Message = messageIdentifier
})
.First();
var localSocket = registration.DestinationSocket;
//
Assert.AreEqual(localSocket, socket);
}
}
public void FindRoutesByActorReceiverIdentifier_ReturnsActorHostSocket()
{
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
var registrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 6),
() => new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
DestinationSocket = new LocalSocket <IMessage>(),
MessageContracts = new[] { new MessageContract {
Message = messageIdentifier
} }
});
registrations.ForEach(r => internalRoutingTable.AddMessageRoute(r));
var lookupRoute = registrations.First();
var actor = lookupRoute.ReceiverIdentifier;
var localSocket = lookupRoute.DestinationSocket;
//
var socket = internalRoutingTable.FindRoutes(new InternalRouteLookupRequest
{
Message = messageIdentifier,
ReceiverIdentity = actor
})
.First();
//
Assert.AreEqual(localSocket, socket);
}
public void OnlyGlobalyRegisteredMessageRoutes_AreRegisteredInLocalRoutingTableButAndCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
MessageContracts = Randomizer.Int32(5, 15)
.Produce(i => new MessageContract
{
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
Randomizer.UInt16(),
Guid.NewGuid().ToByteArray()),
KeepRegistrationLocal = i % 2 == 0
}),
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
Func <IEnumerable <MessageRoute>, bool> areGlobalMessageRoutes = mrs =>
{
routeRegistration.MessageContracts
.Where(mc => !mc.KeepRegistrationLocal)
.Select(mc => mc.Message)
.Should()
.BeEquivalentTo(mrs.Select(mr => mr.Message));
return(true);
};
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => areGlobalMessageRoutes(mrs)), domain), Times.Once);
}
public void IfSameMessageRouteRequestedMultipleTimes_MessageForThatRouteIsSentOnlyOnce()
{
var receiverIdentifier = ReceiverIdentities.CreateForActor();
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
//
for (var i = 0; i < Randomizer.Int32(5, 15); i++)
{
routeDiscovery.RequestRouteDiscovery(new MessageRoute
{
Message = messageIdentifier,
Receiver = receiverIdentifier
});
}
routeDiscovery.Start();
AsyncOp.Sleep();
routeDiscovery.Stop();
//
Func <IMessage, bool> isDiscoveryMessage = msg =>
{
var payload = msg.GetPayload <DiscoverMessageRouteMessage>();
Assert.IsNull(payload.ReceiverIdentity);
Assert.IsTrue(Unsafe.ArraysEqual(payload.MessageContract.Identity, messageIdentifier.Identity));
Assert.IsTrue(Unsafe.ArraysEqual(payload.MessageContract.Partition, messageIdentifier.Partition));
Assert.AreEqual(payload.MessageContract.Version, messageIdentifier.Version);
Assert.IsTrue(Unsafe.ArraysEqual(payload.RequestorNodeIdentity, scaleOutAddress.Identity));
Assert.AreEqual(payload.RequestorUri, scaleOutAddress.Uri.ToSocketAddress());
return(true);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => isDiscoveryMessage(msg))), Times.Once);
}
public void IfSecurityExceptionThrownForOneMessageRoute_OthersAreStillSent()
{
var messageHub = ReceiverIdentities.CreateForMessageHub();
var allowedDomains = EnumerableExtensions.Produce(Randomizer.Int32(2, 5),
() => Guid.NewGuid().ToString());
securityProvider.Setup(m => m.GetAllowedDomains()).Returns(allowedDomains);
securityProvider.Setup(m => m.GetDomain(It.IsAny <byte[]>())).Throws <SecurityException>();
//
routeDiscovery.RequestRouteDiscovery(new MessageRoute {
Receiver = messageHub
});
routeDiscovery.RequestRouteDiscovery(new MessageRoute
{
Receiver = ReceiverIdentities.CreateForActor(),
Message = MessageIdentifier.Create <SimpleMessage>()
});
routeDiscovery.Start();
AsyncOp.Sleep();
routeDiscovery.Stop();
//
Func <IMessage, bool> isDiscoveryMessage = msg =>
{
var payload = msg.GetPayload <DiscoverMessageRouteMessage>();
CollectionAssert.Contains(allowedDomains, msg.Domain);
Assert.IsTrue(Unsafe.ArraysEqual(messageHub.Identity, payload.ReceiverIdentity));
Assert.IsNull(payload.MessageContract);
Assert.IsTrue(Unsafe.ArraysEqual(payload.RequestorNodeIdentity, scaleOutAddress.Identity));
Assert.AreEqual(payload.RequestorUri, scaleOutAddress.Uri.ToSocketAddress());
return(true);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => isDiscoveryMessage(msg))), Times.Exactly(allowedDomains.Count()));
logger.Verify(m => m.Error(It.Is <object>(exc => exc is SecurityException)), Times.Once);
}
public void AddMessageRoute_AddsLocalOrExternalActorRoute(bool keepLocal)
{
var actor = ReceiverIdentities.CreateForActor();
var localSocket = new LocalSocket <IMessage>();
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = actor,
DestinationSocket = localSocket,
MessageContracts = new[]
{
new MessageContract
{
Message = messageIdentifier,
KeepRegistrationLocal = keepLocal
}
}
};
//
internalRoutingTable.AddMessageRoute(registration);
//
var route = internalRoutingTable.GetAllRoutes().Actors.First().Actors.First();
Assert.AreEqual(keepLocal, route.LocalRegistration);
Assert.IsTrue(Unsafe.ArraysEqual(actor.Identity, route.Identity));
}
public void MessageHubRouteDiscovery_IsSentForAllAllowedDomains()
{
var receiverIdentifier = ReceiverIdentities.CreateForMessageHub();
var allowedDomains = EnumerableExtensions.Produce(Randomizer.Int32(2, 5),
() => Guid.NewGuid().ToString());
securityProvider.Setup(m => m.GetAllowedDomains()).Returns(allowedDomains);
//
routeDiscovery.RequestRouteDiscovery(new MessageRoute {
Receiver = receiverIdentifier
});
routeDiscovery.Start();
AsyncOp.Sleep();
routeDiscovery.Stop();
//
Func <IMessage, bool> isDiscoveryMessage = msg =>
{
var payload = msg.GetPayload <DiscoverMessageRouteMessage>();
CollectionAssert.Contains(allowedDomains, msg.Domain);
Assert.IsTrue(Unsafe.ArraysEqual(receiverIdentifier.Identity, payload.ReceiverIdentity));
Assert.IsNull(payload.MessageContract);
Assert.IsTrue(Unsafe.ArraysEqual(payload.RequestorNodeIdentity, scaleOutAddress.Identity));
Assert.AreEqual(payload.RequestorUri, scaleOutAddress.Uri.ToSocketAddress());
return(true);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => isDiscoveryMessage(msg))), Times.Exactly(allowedDomains.Count()));
}
public void GetStalePeers_ReturnsPeersWichAreNotConnectedAndLastKnownHeartBeatFromNowGreaterThanPeerIsStaleAfterTime()
{
var deadPeers = EnumerableExtensions.Produce(Randomizer.Int32(4, 8),
() => new KVP(ReceiverIdentities.CreateForActor(),
new ClusterMemberMeta
{
ConnectionEstablished = true,
LastKnownHeartBeat = DateTime.UtcNow
- config.PeerIsStaleAfter.MultiplyBy(2)
}));
var stalePeers = EnumerableExtensions.Produce(Randomizer.Int32(4, 8),
() => new KVP(ReceiverIdentities.CreateForActor(),
new ClusterMemberMeta
{
ConnectionEstablished = false,
LastKnownHeartBeat = DateTime.UtcNow
- config.PeerIsStaleAfter.MultiplyBy(2)
}));
var activePeers = EnumerableExtensions.Produce(Randomizer.Int32(4, 8),
() => new KVP(ReceiverIdentities.CreateForActor(),
new ClusterMemberMeta
{
ConnectionEstablished = false,
LastKnownHeartBeat = DateTime.UtcNow
}));
foreach (var peer in stalePeers.Concat(activePeers).Concat(deadPeers))
{
peerRegistry.FindOrAdd(peer.Key, peer.Value);
}
//
CollectionAssert.AreEquivalent(stalePeers.Select(p => p.Key), peerRegistry.GetStalePeers().Select(p => p.Key));
}
public void RegisterSelf_SendsOneRegistrationMessageForSpecifiedDomainButNotMessageDomain()
{
var actorIdentifier = ReceiverIdentities.CreateForActor();
var registrations = new[]
{
new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Message = MessageIdentifier.Create <ExceptionMessage>(),
Receiver = actorIdentifier
}
};
var simpleMessageDomain = Guid.NewGuid().ToString();
var exceptionMessageDomain = Guid.NewGuid().ToString();
var allowedDomains = new[] { exceptionMessageDomain, simpleMessageDomain, Guid.NewGuid().ToString() };
securityProvider.Setup(m => m.GetDomain(MessageIdentifier.Create <SimpleMessage>().Identity)).Returns(simpleMessageDomain);
securityProvider.Setup(m => m.GetDomain(MessageIdentifier.Create <ExceptionMessage>().Identity)).Returns(exceptionMessageDomain);
securityProvider.Setup(m => m.GetAllowedDomains()).Returns(allowedDomains);
//
clusterMonitor.RegisterSelf(registrations, domain);
//
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => msg.Domain == domain)), Times.Once);
}
public void AddMessageRoute_AddsActorRoute()
{
var actor = ReceiverIdentities.CreateForActor();
var localSocket = new LocalSocket <IMessage>();
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = actor,
DestinationSocket = localSocket,
MessageContracts = new[] { new MessageContract {
Message = messageIdentifier
} }
};
//
internalRoutingTable.AddMessageRoute(registration);
//
var lookupRequest = new InternalRouteLookupRequest
{
ReceiverIdentity = actor,
Message = messageIdentifier
};
var socket = internalRoutingTable.FindRoutes(lookupRequest).First();
Assert.AreEqual(localSocket, socket);
}
public void RegisterOwnGlobalRoutes_RegisteresOnlyGlobalyRegisteredActors()
{
var actors = Randomizer.Int32(5, 15)
.Produce(i => new ReceiverIdentifierRegistration(ReceiverIdentities.CreateForActor(), i % 2 == 0));
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
var internalRoutes = new InternalRouting
{
Actors = new[]
{
new MessageActorRoute
{
Message = messageIdentifier,
Actors = actors
}
},
MessageHubs = Enumerable.Empty <MessageHubRoute>()
};
internalRoutingTable.Setup(m => m.GetAllRoutes()).Returns(internalRoutes);
var globalActors = internalRoutes.Actors
.SelectMany(r => r.Actors.Where(a => !a.LocalRegistration))
.Select(a => new ReceiverIdentifier(a.Identity));
//
registrar.RegisterOwnGlobalRoutes(domain);
//
Func <IEnumerable <MessageRoute>, bool> isGlobalMessageRoute = mrs =>
{
Assert.True(mrs.All(mr => mr.Message == messageIdentifier));
globalActors.Should().BeEquivalentTo(mrs.Select(mr => mr.Receiver));
return(true);
};
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => isGlobalMessageRoute(mrs)), domain), Times.Once);
}
public void AddMessageRoute_AddsMessageHub()
{
var routeRegistration = new ExternalRouteRegistration
{
Peer = new Node("tcp://127.0.0.2:8080", Guid.NewGuid().ToByteArray()),
Health = new Health
{
Uri = "tcp://192.168.0.1:9090",
HeartBeatInterval = TimeSpan.FromSeconds(4)
},
Route = new MessageRoute
{
Receiver = ReceiverIdentities.CreateForMessageHub()
}
};
//
externalRoutingTable.AddMessageRoute(routeRegistration);
var route = externalRoutingTable.FindRoutes(new ExternalRouteLookupRequest
{
ReceiverIdentity = routeRegistration.Route.Receiver,
ReceiverNodeIdentity = new ReceiverIdentifier(routeRegistration.Peer.SocketIdentity)
})
.First();
//
Assert.AreEqual(routeRegistration.Peer, route.Node);
Assert.AreEqual(routeRegistration.Health.Uri, route.Health.Uri);
Assert.AreEqual(routeRegistration.Health.HeartBeatInterval, route.Health.HeartBeatInterval);
Assert.IsFalse(route.Connected);
}
private static RegisterExternalMessageRouteMessage CreateRegisterExternalMessageRoutePayload()
=> new RegisterExternalMessageRouteMessage
{
Uri = "tcp://127.0.0.1:80",
NodeIdentity = Guid.NewGuid().ToByteArray(),
Health = new Health
{
Uri = "tcp://127.0.0.1:812",
HeartBeatInterval = TimeSpan.FromSeconds(4)
},
Routes = new[]
{
new RouteRegistration
{
ReceiverIdentity = ReceiverIdentities.CreateForActor().Identity,
MessageContracts = EnumerableExtensions.Produce(Randomizer.UInt16(2, 5),
() => new MessageContract
{
Identity = Guid.NewGuid().ToByteArray(),
Version = Randomizer.UInt16()
})
.ToArray()
},
new RouteRegistration
{
ReceiverIdentity = ReceiverIdentities.CreateForMessageHub().Identity,
}
}
};
private void IfNodeIdentifierIsNotProvidedOrNotFound_PeerRemovalResultIsNotFound(byte[] removeNodeIdentity)
{
var nodeIdentity = Guid.NewGuid().ToByteArray();
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
var routeRegistration = CreateActorRouteRegistration(messageIdentifier,
ReceiverIdentities.CreateForActor(),
nodeIdentity);
externalRoutingTable.AddMessageRoute(routeRegistration);
//
var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
{
Route = new MessageRoute {
Message = messageIdentifier
},
NodeIdentifier = removeNodeIdentity
});
//
Assert.AreEqual(PeerConnectionAction.NotFound, res.ConnectionAction);
var externalRouteLookupRequest = new ExternalRouteLookupRequest
{
ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
};
CollectionAssert.IsNotEmpty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
}
public void RemoveNodeRoute_RemovesAllNodeRoutes()
{
var nodeIdentity = Guid.NewGuid().ToByteArray();
var routeRegistrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 10),
() =>
{
var messageIdentifier = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
Randomizer.UInt16(),
Guid.NewGuid().ToByteArray());
return(CreateActorRouteRegistration(messageIdentifier,
ReceiverIdentities.CreateForActor(),
nodeIdentity));
});
routeRegistrations.ForEach(r => externalRoutingTable.AddMessageRoute(r));
//
externalRoutingTable.RemoveNodeRoute(new ReceiverIdentifier(nodeIdentity));
//
var externalRouteLookupRequest = new ExternalRouteLookupRequest
{
ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
};
CollectionAssert.IsEmpty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
}
public void RemoveMessageRouteForNode_RemovesAllActorRegistrationsForThisMessageForThisNode()
{
var nodeIdentity = Guid.NewGuid().ToByteArray();
var messageIdentifier = MessageIdentifier.Create <SimpleMessage>();
Randomizer.Int32(3, 10)
.Produce(() => CreateActorRouteRegistration(messageIdentifier,
ReceiverIdentities.CreateForActor(),
nodeIdentity))
.ForEach(r => externalRoutingTable.AddMessageRoute(r))
.ToList();
//
var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
{
Route = new MessageRoute {
Message = messageIdentifier
},
NodeIdentifier = nodeIdentity
});
//
Assert.Equal(PeerConnectionAction.Disconnect, res.ConnectionAction);
var externalRouteLookupRequest = new ExternalRouteLookupRequest
{
ReceiverNodeIdentity = new ReceiverIdentifier(nodeIdentity)
};
Assert.Empty(externalRoutingTable.FindRoutes(externalRouteLookupRequest));
}
public void RegisterOwnGlobalRoutes_RegisteresOnlyGlobalyRegisteredMessageHubs()
{
var internalRoutes = new InternalRouting
{
Actors = Enumerable.Empty <MessageActorRoute>(),
MessageHubs = EnumerableExtensions.Produce(Randomizer.Int32(5, 15),
i => new MessageHubRoute
{
MessageHub = ReceiverIdentities.CreateForMessageHub(),
LocalRegistration = i % 2 == 0
})
};
internalRoutingTable.Setup(m => m.GetAllRoutes()).Returns(internalRoutes);
var globalMessageHubs = internalRoutes.MessageHubs.Where(mh => !mh.LocalRegistration);
//
registrar.RegisterOwnGlobalRoutes(domain);
//
Func <IEnumerable <MessageRoute>, bool> isGlobalMessageHub = mrs =>
{
CollectionAssert.AreEquivalent(globalMessageHubs.Select(mh => mh.MessageHub),
mrs.Select(mr => mr.Receiver));
return(true);
};
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => isGlobalMessageHub(mrs)), domain), Times.Once);
}
public void MessageRouteRegistrations_AreGroupedByDomainWhenRegisteredAtCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
MessageContracts = EnumerableExtensions.Produce(Randomizer.Int32(5, 15),
i => new MessageContract
{
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
Randomizer.UInt16(),
Guid.NewGuid().ToByteArray())
}),
DestinationSocket = destinationSocket.Object
};
var secondDomain = Guid.NewGuid().ToString();
securityProvider.Setup(m => m.GetDomain(routeRegistration.MessageContracts.First().Message.Identity)).Returns(secondDomain);
var allowedDomains = new[] { domain, secondDomain };
//
handler.Handle(routeRegistration);
//
Func <IEnumerable <MessageRoute>, bool> areGlobalMessageRoutes = mrs =>
{
CollectionAssert.IsSupersetOf(routeRegistration.MessageContracts
.Select(mc => mc.Message),
mrs.Select(mr => mr.Message));
return(true);
};
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => areGlobalMessageRoutes(mrs)),
It.Is <string>(d => allowedDomains.Contains(d))),
Times.Exactly(allowedDomains.Length));
}
public void FindOrAdd_AddsReceiverIdentityIfItDoesntExistsAndReturnsClusterMemberData()
{
var peer = ReceiverIdentities.CreateForActor();
var clusterMemberMeta = new ClusterMemberMeta();
//
Assert.AreEqual(clusterMemberMeta, peerRegistry.FindOrAdd(peer, clusterMemberMeta));
}
public void IfReceiverIdentifierDoesntExist_FundReturnsNull()
{
var onePeer = ReceiverIdentities.CreateForActor();
var anotherPeer = ReceiverIdentities.CreateForActor();
peerRegistry.FindOrAdd(onePeer, new ClusterMemberMeta());
//
Assert.IsNull(peerRegistry.Find(anotherPeer));
}
public void DuplicatedReceiverIdentities_CanNotBeAdded()
{
var peer = ReceiverIdentities.CreateForActor();
var clusterMemberMeta = new ClusterMemberMeta();
//
peerRegistry.FindOrAdd(peer, clusterMemberMeta);
peerRegistry.FindOrAdd(peer, clusterMemberMeta);
//
Assert.AreEqual(1, peerRegistry.Count());
}
public void RegisterSelf_SendsRegistrationMessageForEachReceiver()
{
var actorIdentifier = ReceiverIdentities.CreateForActor();
var messageHubIdentifier = ReceiverIdentities.CreateForMessageHub();
var registrations = new[]
{
new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Message = MessageIdentifier.Create <ExceptionMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Receiver = messageHubIdentifier
}
};
//
clusterMonitor.RegisterSelf(registrations, domain);
//
Func <IMessage, bool> messageIsConsistent = msg =>
{
if (msg.Equals(MessageIdentifier.Create <RegisterExternalMessageRouteMessage>()))
{
var payload = msg.GetPayload <RegisterExternalMessageRouteMessage>();
Assert.Equal(payload.Uri, scaleOutAddress.Uri.ToSocketAddress());
Assert.True(Unsafe.ArraysEqual(payload.NodeIdentity, scaleOutAddress.Identity));
Assert.Equal(payload.Health.Uri, heartBeatUri.ToSocketAddress());
Assert.Equal(payload.Health.HeartBeatInterval, heartBeatInterval);
var actorRoutes = payload.Routes
.First(r => Unsafe.ArraysEqual(r.ReceiverIdentity, actorIdentifier.Identity));
foreach (var registration in registrations.Where(r => r.Receiver == actorIdentifier))
{
Assert.True(actorRoutes.MessageContracts.Any(mc => Unsafe.ArraysEqual(mc.Identity, registration.Message.Identity) &&
Unsafe.ArraysEqual(mc.Partition, registration.Message.Partition) &&
mc.Version == registration.Message.Version));
}
var messageHub = payload.Routes
.First(r => Unsafe.ArraysEqual(r.ReceiverIdentity, messageHubIdentifier.Identity));
Assert.Null(messageHub.MessageContracts);
return(true);
}
return(false);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => messageIsConsistent(msg))), Times.Once);
}
public void IfDiscoveryMessageRouteIsForNotRegisteredMessageHub_RegisterSelfIsNotCalled()
{
var payload = new DiscoverMessageRouteMessage {
ReceiverIdentity = ReceiverIdentities.CreateForMessageHub().Identity
};
var message = Message.Create(payload).As <Message>();
message.SetDomain(domain);
//
handler.Handle(message, null);
//
internalRoutingTable.Verify(m => m.GetAllRoutes(), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.IsAny <IEnumerable <MessageRoute> >(), It.IsAny <string>()), Times.Never);
}
public void IfLastMessageHubRouteIsRemoved_PeerWillBeDisconnected()
{
var node = new Node("tcp://127.0.0.2:8080", Guid.NewGuid().ToByteArray());
var health = new Health
{
Uri = "tcp://192.168.0.1:9090",
HeartBeatInterval = TimeSpan.FromSeconds(4)
};
var messageHubRegistrations = Randomizer.Int32(2, 5)
.Produce(() => new ExternalRouteRegistration
{
Peer = node,
Health = health,
Route = new MessageRoute
{
Receiver = ReceiverIdentities.CreateForMessageHub()
}
})
.ForEach(r => externalRoutingTable.AddMessageRoute(r))
.ToList();
//
for (var i = 0; i < messageHubRegistrations.Count(); i++)
{
var messageHubToRemove = messageHubRegistrations.ElementAt(i).Route.Receiver;
var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
{
NodeIdentifier = node.SocketIdentity,
Route = new MessageRoute {
Receiver = messageHubToRemove
}
});
if (LastMessageHubRemoved(i, messageHubRegistrations.Count()))
{
Assert.Equal(PeerConnectionAction.Disconnect, res.ConnectionAction);
}
else
{
Assert.Equal(PeerConnectionAction.KeepConnection, res.ConnectionAction);
}
}
//
var peers = externalRoutingTable.FindRoutes(new ExternalRouteLookupRequest
{
ReceiverNodeIdentity = new ReceiverIdentifier(node.SocketIdentity)
});
Assert.Empty(peers);
}
public void Remove_DeletesOnlyCorrespondingReceiverIdentifier()
{
var onePeer = ReceiverIdentities.CreateForActor();
var anotherPeer = ReceiverIdentities.CreateForActor();
peerRegistry.FindOrAdd(onePeer, new ClusterMemberMeta());
peerRegistry.FindOrAdd(anotherPeer, new ClusterMemberMeta());
Assert.AreEqual(2, peerRegistry.Count());
//
peerRegistry.Remove(anotherPeer);
//
Assert.IsNull(peerRegistry.Find(anotherPeer));
Assert.IsNotNull(peerRegistry.Find(onePeer));
Assert.AreEqual(1, peerRegistry.Count());
}
public void LocalyRegisteredMessageHub_IsRegisteredInLocalRoutingTableButNotInCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
KeepRegistrationLocal = true,
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.IsAny <IEnumerable <MessageRoute> >(), It.IsAny <string>()),
Times.Never);
}
public void RemoveReceiverRoute_RemoveAllMessageHubRegistrations()
{
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
DestinationSocket = new LocalSocket <IMessage>()
};
internalRoutingTable.AddMessageRoute(registration);
//
var route = internalRoutingTable.RemoveReceiverRoute(registration.DestinationSocket)
.First();
//
Assert.AreEqual(registration.ReceiverIdentifier, route.Receiver);
}
public void UnregisterSelf_SendsOneUnregisterMessageRouteMessagePerDomain()
{
var actorIdentifier = ReceiverIdentities.CreateForActor();
var messageHubIdentifier = ReceiverIdentities.CreateForMessageHub();
var routes = new[]
{
new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Message = MessageIdentifier.Create <ExceptionMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Receiver = messageHubIdentifier
}
};
var simpleMessageDomain = Guid.NewGuid().ToString();
var exceptionMessageDomain = Guid.NewGuid().ToString();
var allowedDomains = new[] { exceptionMessageDomain, simpleMessageDomain, Guid.NewGuid().ToString() };
securityProvider.Setup(m => m.GetDomain(MessageIdentifier.Create <SimpleMessage>().Identity)).Returns(simpleMessageDomain);
securityProvider.Setup(m => m.GetDomain(MessageIdentifier.Create <ExceptionMessage>().Identity)).Returns(exceptionMessageDomain);
securityProvider.Setup(m => m.GetAllowedDomains()).Returns(allowedDomains);
//
clusterMonitor.UnregisterSelf(routes);
//
Func <IMessage, bool> messageIsConsistent = msg =>
{
if (msg.Equals(MessageIdentifier.Create <UnregisterMessageRouteMessage>()))
{
var payload = msg.GetPayload <UnregisterMessageRouteMessage>();
Assert.Equal(payload.Uri, scaleOutAddress.Uri.ToSocketAddress());
Assert.True(Unsafe.ArraysEqual(payload.ReceiverNodeIdentity, scaleOutAddress.Identity));
Assert.True(allowedDomains.Contains(msg.Domain));
return(true);
}
return(false);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => messageIsConsistent(msg))), Times.Exactly(allowedDomains.Length));
}
public void GlobalyRegisteredMessageHub_IsRegisteredInLocalRoutingTableAndCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
KeepRegistrationLocal = false,
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(routes => routes.Any(r => r.Receiver == routeRegistration.ReceiverIdentifier)),
domain),
Times.Once);
}
private InternalRouting GetInternalRoutes()
=> new InternalRouting
{
Actors = EnumerableExtensions.Produce(Randomizer.Int32(2, 5),
() => new MessageActorRoute
{
Actors = EnumerableExtensions.Produce(Randomizer.Int32(5, 15),
i => new ReceiverIdentifierRegistration(ReceiverIdentities.CreateForActor(), i % 2 == 0)),
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(), Randomizer.UInt16(), Guid.NewGuid().ToByteArray())
}),
MessageHubs = EnumerableExtensions.Produce(Randomizer.Int32(2, 5),
i => new MessageHubRoute
{
MessageHub = ReceiverIdentities.CreateForMessageHub(),
LocalRegistration = i % 2 == 0
})
};
