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 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 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 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 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 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 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 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 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);
}
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,
}
}
};
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 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));
}
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 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 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 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 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 IfSameMessageRouteRequestedAfterOthersAreSentButBeforeSendingPeriodEnds_TheyAreDeletedAndNotSentAgain()
{
config.RouteDiscovery = new RouteDiscoveryConfiguration {
SendingPeriod = TimeSpan.FromSeconds(1)
};
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();
config.RouteDiscovery.SendingPeriod.DivideBy(2).Sleep();
for (var i = 0; i < Randomizer.Int32(5, 15); i++)
{
routeDiscovery.RequestRouteDiscovery(new MessageRoute
{
Message = messageIdentifier,
Receiver = receiverIdentifier
});
}
config.RouteDiscovery.SendingPeriod.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 TwoMessageRoutesAreNotEqual_IfTheirReceiverPropertiesAreNotEqual()
{
var first = new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = ReceiverIdentities.CreateForActor()
};
var second = new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = ReceiverIdentities.CreateForActor()
};
//
Assert.NotEqual(first, second);
Assert.False(first.Equals(second));
Assert.False(first.Equals((object)second));
Assert.True(first != second);
Assert.False(first == second);
}
public void RoutesFromNotFromRequestedDomain_AreNotRegistered()
{
var receiverIdentifierRegistration = new ReceiverIdentifierRegistration(ReceiverIdentities.CreateForActor(), false);
var min = 5;
var internalRoutes = new InternalRouting
{
Actors = Randomizer.Int32(min, 15)
.Produce(() => new MessageActorRoute
{
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
Randomizer.UInt16(),
Guid.NewGuid().ToByteArray()),
Actors = new[] { receiverIdentifierRegistration }
}),
MessageHubs = Enumerable.Empty <MessageHubRoute>()
};
internalRoutingTable.Setup(m => m.GetAllRoutes()).Returns(internalRoutes);
var otherDomainRoutes = internalRoutes.Actors.Take(min / 2).ToList();
var allowedDomainRoutes = internalRoutes.Actors.Except(otherDomainRoutes);
foreach (var route in otherDomainRoutes)
{
securityProvider.Setup(m => m.GetDomain(route.Message.Identity)).Returns(Guid.NewGuid().ToString);
}
//
registrar.RegisterOwnGlobalRoutes(domain);
//
Func <IEnumerable <MessageRoute>, bool> areAllowedMessageRoutes = mrs =>
{
allowedDomainRoutes.Select(r => r.Message)
.Should()
.BeEquivalentTo(mrs.Select(r => r.Message));
var receiverIdentifiers = allowedDomainRoutes.SelectMany(r => r.Actors.Select(a => new ReceiverIdentifier(a.Identity)));
receiverIdentifiers.Should()
.BeEquivalentTo(mrs.Select(r => r.Receiver));
return(true);
};
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => areAllowedMessageRoutes(mrs)), domain), Times.Once);
}
public void IfRouteReceiverIsActorAndMessageDomainIsNotEqualToUnregisterMessageRouteDomain_ExternalMessageRouteIsNotRemoved()
{
securityProvider.Setup(m => m.GetDomain(It.IsAny <byte[]>())).Returns(Guid.NewGuid().ToString);
var receiverNodeIdentity = Guid.NewGuid().ToByteArray();
var payload = CreateUnregisterMessageRoutePayload(receiverNodeIdentity, ReceiverIdentities.CreateForActor().Identity);
var message = Message.Create(payload).As <Message>();
message.SetDomain(domain);
var peerRemoveResult = new PeerRemoveResult {
ConnectionAction = PeerConnectionAction.KeepConnection
};
externalRoutingTable.Setup(m => m.RemoveMessageRoute(It.IsAny <ExternalRouteRemoval>())).Returns(peerRemoveResult);
var callsCount = payload.Routes.SelectMany(r => r.MessageContracts).Count();
//
handler.Handle(message, backEndSocket.Object);
//
externalRoutingTable.Verify(m => m.RemoveMessageRoute(It.IsAny <ExternalRouteRemoval>()), Times.Never);
securityProvider.Verify(m => m.GetDomain(It.IsAny <byte[]>()), Times.Exactly(callsCount));
}
public void GetPeersWithExpiredHeartBeat_ReturnsPeersWichAreConnectedAndLastKnownHeartBeatFromNowGreaterThanPeerHeartBeatIntervalTimesMissingHeartBeatsBeforeDeletion()
{
var heartBeatInterval = TimeSpan.FromSeconds(3);
var deadPeers = Randomizer.Int32(4, 8)
.Produce(() => new KVP(ReceiverIdentities.CreateForActor(),
new ClusterMemberMeta
{
ConnectionEstablished = true,
HeartBeatInterval = heartBeatInterval,
LastKnownHeartBeat = DateTime.UtcNow
- heartBeatInterval.MultiplyBy(config.MissingHeartBeatsBeforeDeletion + 2)
}));
var activePeers = Randomizer.Int32(4, 8)
.Produce(() => new KVP(ReceiverIdentities.CreateForActor(),
new ClusterMemberMeta
{
ConnectionEstablished = true,
HeartBeatInterval = heartBeatInterval,
LastKnownHeartBeat = DateTime.UtcNow
- heartBeatInterval.MultiplyBy(config.MissingHeartBeatsBeforeDeletion - 1)
}));
var stalePeers = Randomizer.Int32(4, 8)
.Produce(() => new KVP(ReceiverIdentities.CreateForActor(),
new ClusterMemberMeta
{
ConnectionEstablished = false,
HeartBeatInterval = heartBeatInterval,
LastKnownHeartBeat = DateTime.UtcNow
- heartBeatInterval.MultiplyBy(config.MissingHeartBeatsBeforeDeletion)
}));
foreach (var peer in stalePeers.Concat(activePeers).Concat(deadPeers))
{
peerRegistry.FindOrAdd(peer.Key, peer.Value);
}
//
deadPeers.Select(p => p.Key)
.Should()
.BeEquivalentTo(peerRegistry.GetPeersWithExpiredHeartBeat().Select(p => p.Key));
}
public void IfMessageRouteIsNotRegistered_NoActorsReturned()
{
var registrations = EnumerableExtensions.Produce(Randomizer.Int32(6, 16),
() => new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
DestinationSocket = new LocalSocket <IMessage>(),
MessageContracts = new[] { new MessageContract {
Message = MessageIdentifier.Create <SimpleMessage>()
} }
});
registrations.ForEach(r => internalRoutingTable.AddMessageRoute(r));
//
var sockets = internalRoutingTable.FindRoutes(new InternalRouteLookupRequest
{
Message = MessageIdentifier.Create <AsyncMessage>()
});
//
CollectionAssert.IsEmpty(sockets);
}
public void LocalyRegisteredMessageRoutes_AreRegisteredInLocalRoutingTableButNotInCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
MessageContracts = Randomizer.Int32(2, 5)
.Produce(() => new MessageContract
{
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
Randomizer.UInt16(),
Guid.NewGuid().ToByteArray()),
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_RemoveAllActorRegistrations()
{
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForActor(),
DestinationSocket = new LocalSocket <IMessage>(),
MessageContracts = EnumerableExtensions.Produce(Randomizer.Int32(4, 14),
() => new MessageContract
{
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(),
Randomizer.UInt16(),
Guid.NewGuid().ToByteArray())
})
};
internalRoutingTable.AddMessageRoute(registration);
//
var routes = internalRoutingTable.RemoveReceiverRoute(registration.DestinationSocket);
//
CollectionAssert.AreEquivalent(registration.MessageContracts.Select(mc => mc.Message), routes.Select(r => r.Message));
CollectionAssert.IsEmpty(internalRoutingTable.GetAllRoutes().Actors);
}
public void FindBroadcastMessage_ReturnsAllRegisteredActors()
{
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));
//
var sockets = internalRoutingTable.FindRoutes(new InternalRouteLookupRequest
{
Message = messageIdentifier,
Distribution = DistributionPattern.Broadcast
});
//
CollectionAssert.AreEquivalent(registrations.Select(r => r.DestinationSocket), sockets);
}
