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); }