public void WhenCusterMonitorStops_UnregisterNodeMessageIsSent() { Func <Barrier, bool> setBarrier = (b) => { b.SignalAndWait(); return(true); }; autoDiscoveryListener.Setup(m => m.StartBlockingListenMessages(It.IsAny <Action>(), It.IsAny <CancellationToken>(), It.Is <Barrier>(b => setBarrier(b)))); autoDiscoverySender.Setup(m => m.StartBlockingSendMessages(It.IsAny <CancellationToken>(), It.Is <Barrier>(b => setBarrier(b)))); // clusterMonitor.Start(); AsyncOp.Sleep(); clusterMonitor.Stop(); // Func <IMessage, bool> isUnregistrationMessage = msg => { if (msg.Equals(MessageIdentifier.Create <UnregisterNodeMessage>())) { var payload = msg.GetPayload <UnregisterNodeMessage>(); Assert.IsTrue(Unsafe.ArraysEqual(scaleOutAddress.Identity, payload.ReceiverNodeIdentity)); Assert.AreEqual(scaleOutAddress.Uri.ToSocketAddress(), payload.Uri); return(true); } return(false); }; autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => isUnregistrationMessage(msg))), Times.Once); }
public void IfExceptionIsThrownFromFrontEndSocketReceiveMessageMethod_ExceptionMessageIsForwardedToLocalRouterSocket() { var message = Message.Create(new SimpleMessage()).As <Message>(); message.RegisterCallbackPoint(Guid.NewGuid().ToByteArray(), Guid.NewGuid().ToByteArray(), new[] { KinoMessages.Ping, KinoMessages.Pong }, Randomizer.Int64()); message.PushRouterAddress(new SocketEndpoint("tcp://127.0.0.4:7878")); message.PushRouterAddress(new SocketEndpoint("tcp://127.0.0.5:5464")); message.SetCorrelationId(Guid.NewGuid().ToByteArray()); frontEndSocket.Setup(m => m.ReceiveMessage(It.IsAny <CancellationToken>())).Throws <Exception>(); // scaleOutListener.Start(); AsyncOp.Sleep(); scaleOutListener.Stop(); // Func <IMessage, bool> isExceptionMessage = msg => { var exception = msg.As <Message>(); Assert.Equal(KinoMessages.Exception, exception); Assert.Null(exception.CallbackReceiverNodeIdentity); Assert.Null(exception.CallbackReceiverIdentity); Assert.Empty(exception.CallbackPoint); Assert.Empty(exception.GetMessageRouting()); Assert.Equal(0, exception.CallbackKey); Assert.True(Unsafe.ArraysEqual(Guid.Empty.ToString().GetBytes(), exception.CorrelationId)); return(true); }; localRouterSocket.Verify(m => m.Send(It.Is <IMessage>(msg => isExceptionMessage(msg))), Times.AtLeastOnce); }
public void StartPeerMonitoring_SendsStartPeerMonitoringMessage() { var peer = new Node("tcp://127.0.0.1:8080", Guid.NewGuid().ToByteArray()); var health = new Health { Uri = "tcp://127.0.0.2:9090", HeartBeatInterval = TimeSpan.FromSeconds(3) }; // clusterHealthMonitor.StartPeerMonitoring(peer, health); // Func <IMessage, bool> isStartMonitoringMessage = msg => { if (msg.Equals(KinoMessages.StartPeerMonitoring)) { var payload = msg.GetPayload <StartPeerMonitoringMessage>(); Assert.IsTrue(Unsafe.ArraysEqual(peer.SocketIdentity, payload.SocketIdentity)); Assert.AreEqual(peer.Uri.ToSocketAddress(), payload.Uri); Assert.AreEqual(health.Uri, payload.Health.Uri); Assert.AreEqual(health.HeartBeatInterval, payload.Health.HeartBeatInterval); return(true); } return(false); }; multiplexingSocket.Verify(m => m.Send(It.Is <IMessage>(msg => isStartMonitoringMessage(msg))), Times.Once); }
public void WhenClusterMonitorStarts_ClusterRoutesAreRequested() { Func <Barrier, bool> setBarrier = (b) => { b.SignalAndWait(); return(true); }; autoDiscoveryListener.Setup(m => m.StartBlockingListenMessages(It.IsAny <Action>(), It.IsAny <CancellationToken>(), It.Is <Barrier>(b => setBarrier(b)))); autoDiscoverySender.Setup(m => m.StartBlockingSendMessages(It.IsAny <CancellationToken>(), It.Is <Barrier>(b => setBarrier(b)))); // clusterMonitor.Start(); // Func <Message, bool> isRequestClusterRoutesMessage = (msg) => { if (msg.Equals(MessageIdentifier.Create <RequestClusterMessageRoutesMessage>())) { var payload = msg.GetPayload <RequestClusterMessageRoutesMessage>(); Assert.IsTrue(Unsafe.ArraysEqual(scaleOutAddress.Identity, payload.RequestorNodeIdentity)); Assert.AreEqual(scaleOutAddress.Uri.ToSocketAddress(), payload.RequestorUri); return(true); } return(false); }; autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => isRequestClusterRoutesMessage(msg.As <Message>()))), Times.Once); }
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 IfDomainIsAllowed_AllRoutesAreAdded() { var payload = CreateRegisterExternalMessageRoutePayload(); var message = Message.Create(payload).As <Message>(); message.SetDomain(domain); var actorRoutes = payload.Routes.First(r => r.ReceiverIdentity.IsActor()); var messageHub = payload.Routes.First(r => r.ReceiverIdentity.IsMessageHub()); // handler.Handle(message, socket.Object); // Func <ExternalRouteRegistration, MessageIdentifier, bool> allActorRoutes = (er, messageIdentifer) => er.Route.Receiver.IsActor() && Unsafe.ArraysEqual(er.Route.Receiver.Identity, actorRoutes.ReceiverIdentity) && er.Route.Message == messageIdentifer; Func <ExternalRouteRegistration, bool> thisMessageHub = er => Unsafe.ArraysEqual(er.Route.Receiver.Identity, messageHub.ReceiverIdentity); foreach (var messageIdentifier in actorRoutes.MessageContracts .Select(mc => new MessageIdentifier(mc.Identity, mc.Version, mc.Partition))) { externalRoutingTable.Verify(m => m.AddMessageRoute(It.Is <ExternalRouteRegistration>(er => allActorRoutes(er, messageIdentifier))), Times.Once); } externalRoutingTable.Verify(m => m.AddMessageRoute(It.Is <ExternalRouteRegistration>(er => thisMessageHub(er))), Times.Once); }
public void IfCallbackIsRegistered_SyncExceptionMessageIsDeliveredToCallbackReceiver() { try { actorHost.AssignActor(new ExceptionActor()); var messageIn = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); var callbackReceiver = Guid.NewGuid().ToByteArray(); var callbackReceiverNode = Guid.NewGuid().ToByteArray(); var callbackPoints = new[] { MessageIdentifier.Create <SimpleMessage>(), KinoMessages.Exception }; messageIn.RegisterCallbackPoint(callbackReceiverNode, callbackReceiver, callbackPoints, Randomizer.Int32()); receivingSocket.SetupMessageReceived(messageIn); // StartActorHost(actorHost); // Func <Message, bool> assertCallbackPropertiesCopied = messageOut => messageOut.Equals(KinoMessages.Exception) && messageIn.CallbackPoint.SequenceEqual(messageOut.CallbackPoint) && Unsafe.ArraysEqual(messageIn.CallbackReceiverIdentity, messageOut.CallbackReceiverIdentity) && Unsafe.ArraysEqual(messageIn.CallbackReceiverNodeIdentity, messageOut.CallbackReceiverNodeIdentity); localRouterSocket.WaitUntilMessageSent(assertCallbackPropertiesCopied); } finally { actorHost.Stop(); } }
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 CallbackReceiverIdentities_AreCopiedFromIncomingMessageProcessedSync() { try { actorHost.AssignActor(new EchoActor()); var messageIn = Message.CreateFlowStartMessage(new SimpleMessage()).As <Message>(); var callbackReceiver = Guid.NewGuid().ToByteArray(); var callbackReceiverNode = Guid.NewGuid().ToByteArray(); messageIn.RegisterCallbackPoint(callbackReceiverNode, callbackReceiver, MessageIdentifier.Create <SimpleMessage>(), Randomizer.Int32()); receivingSocket.SetupMessageReceived(messageIn); // StartActorHost(actorHost); // Func <Message, bool> assertCallbackPropertiesCopied = messageOut => messageIn.CallbackPoint.SequenceEqual(messageOut.CallbackPoint) && Unsafe.ArraysEqual(messageIn.CallbackReceiverIdentity, messageOut.CallbackReceiverIdentity) && Unsafe.ArraysEqual(messageIn.CallbackReceiverNodeIdentity, messageOut.CallbackReceiverNodeIdentity); localRouterSocket.WaitUntilMessageSent(assertCallbackPropertiesCopied); } finally { actorHost.Stop(); } }
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 IfRouteReceiverIsMessageHub_MessageDominIsNotChecked() { securityProvider.Setup(m => m.GetDomain(It.IsAny <byte[]>())).Returns(Guid.NewGuid().ToString); var receiverNodeIdentity = Guid.NewGuid().ToByteArray(); var payload = CreateUnregisterMessageRoutePayload(receiverNodeIdentity, ReceiverIdentities.CreateForMessageHub().Identity); var message = Message.Create(payload).As <Message>(); var callsCount = payload.Routes.SelectMany(r => r.MessageContracts).Count(); message.SetDomain(domain); var peerRemoveResult = new PeerRemoveResult { ConnectionAction = PeerConnectionAction.KeepConnection }; externalRoutingTable.Setup(m => m.RemoveMessageRoute(It.IsAny <ExternalRouteRemoval>())).Returns(peerRemoveResult); // handler.Handle(message, backEndSocket.Object); // Func <ExternalRouteRemoval, bool> isRouteToRemove = route => { Assert.True(Unsafe.ArraysEqual(receiverNodeIdentity, route.NodeIdentifier)); Assert.True(payload.Routes .SelectMany(r => r.MessageContracts) .Select(mc => new MessageIdentifier(mc.Identity, mc.Version, mc.Partition)) .Any(m => m.Equals(route.Route.Message))); Assert.True(payload.Routes .Select(mc => new ReceiverIdentifier(mc.ReceiverIdentity)) .Any(receiver => receiver == route.Route.Receiver)); return(true); }; externalRoutingTable.Verify(m => m.RemoveMessageRoute(It.Is <ExternalRouteRemoval>(rt => isRouteToRemove(rt))), Times.Exactly(callsCount)); securityProvider.Verify(m => m.GetDomain(It.IsAny <byte[]>()), Times.Never()); }
public void ReadCommitsWithNonEmptyLease_IfWriteCommittedLeaseWithBallotLessThanCurrent() { using (CreateRoundBasedRegister(GetSynodMembers(), GetSynodMembers().First())) { using (CreateRoundBasedRegister(GetSynodMembers(), GetSynodMembers().Second())) { using (var testSetup = CreateRoundBasedRegister(GetSynodMembers(), GetSynodMembers().Third())) { testSetup.WaitUntilStarted(); var ballotGenerator = testSetup.BallotGenerator; var localNode = testSetup.LocalNode; var roundBasedRegister = testSetup.RoundBasedRegister; var ballot0 = ballotGenerator.New(localNode.SocketIdentity); var lease = new Lease(localNode.SocketIdentity, DateTime.UtcNow, ownerPayload); var txResult = roundBasedRegister.Write(ballot0, lease); Assert.AreEqual(TxOutcome.Commit, txResult.TxOutcome); var ballot1 = ballotGenerator.New(localNode.SocketIdentity); Assert.IsTrue(ballot0 < ballot1); txResult = roundBasedRegister.Read(ballot1); Assert.AreEqual(TxOutcome.Commit, txResult.TxOutcome); Assert.AreEqual(lease.ExpiresAt, txResult.Lease.ExpiresAt); CollectionAssert.AreEqual(lease.OwnerPayload, txResult.Lease.OwnerPayload); Assert.IsTrue(Unsafe.ArraysEqual(lease.OwnerIdentity, txResult.Lease.OwnerIdentity)); } } } }
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 bool Match(IMessage message) { var messagePayload = payload(message); return(synodConfig.BelongsToSynod(new Uri(messagePayload.SenderUri)) && Unsafe.ArraysEqual(messagePayload.Ballot.Identity, ballot.Identity) && messagePayload.Ballot.Timestamp == ballot.Timestamp.Ticks && messagePayload.Ballot.MessageNumber == ballot.MessageNumber); }
private void MatchMessageAgainstCallbackPoint() { if (CallbackPoint.Any(identifier => Unsafe.ArraysEqual(Identity, identifier.Identity) && Version == identifier.Version && Unsafe.ArraysEqual(Partition, identifier.Partition))) { ReceiverIdentity = CallbackReceiverIdentity; ReceiverNodeIdentity = CallbackReceiverNodeIdentity; } }
private bool IsLeaseNackReadMessage(IMessage message) { if (message.Equals(ConsensusMessages.LeaseNackRead)) { var payload = message.GetPayload <LeaseNackReadMessage>(); return(Unsafe.ArraysEqual(payload.Ballot.Identity, instance.Identity)); } return(false); }
private bool SendToExactReceiver(Message message, ISocket scaleOutBackend, ExternalRouteLookupRequest lookupRequest) { if (Unsafe.ArraysEqual(message.ReceiverNodeIdentity, thisNodeIdentity)) { var localDestinations = internalRoutingTable.FindRoutes(lookupRequest); return(SendMessageLocally(localDestinations, message)); } var remoteDestinations = externalRoutingTable.FindRoutes(lookupRequest); return(SendMessageAway(remoteDestinations, message, scaleOutBackend)); }
public bool Equals(Instance other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(Unsafe.ArraysEqual(other.Identity, Identity)); }
internal void VerifySignature(ISignatureProvider signatureProvider) { if (signatureProvider.ShouldSignMessage(Domain, Identity)) { var mac = signatureProvider.CreateSignature(Domain, GetSignatureFields()); if (!Unsafe.ArraysEqual(Signature, mac)) { throw new WrongMessageSignatureException(); } } }
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 PeerAddedToClusterHealthMonitor_OnlyOnce() { var payload = CreateRegisterExternalMessageRoutePayload(); var message = Message.Create(payload).As <Message>(); message.SetDomain(domain); // handler.Handle(message, socket.Object); // Func <Node, bool> isThisPeer = p => p.Uri.ToSocketAddress() == payload.Uri && Unsafe.ArraysEqual(p.SocketIdentity, payload.NodeIdentity); clusterHealthMonitor.Verify(m => m.AddPeer(It.Is <Node>(p => isThisPeer(p)), It.IsAny <global::kino.Cluster.Health>()), Times.Once); }
public void MessagePartition_IsConsistentlyTransferredViaMultipartMessage() { var message = (Message)Message.CreateFlowStartMessage(new SimpleMessage { Partition = Guid.NewGuid().ToByteArray() }); var partition = message.Partition; var multipart = new MultipartMessage(message); message = Message.FromMultipartMessage(multipart); Assert.IsTrue(Unsafe.ArraysEqual(partition, message.Partition)); }
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 IfMessageDomainIsNotEqualToRegistrationDomain_MessageRouteIsNotAdded() { var payload = CreateRegisterExternalMessageRoutePayload(); var message = Message.Create(payload).As <Message>(); var notAllowedMessage = payload.Routes.First(r => r.ReceiverIdentity.IsActor()).MessageContracts.First(); securityProvider.Setup(m => m.GetDomain(notAllowedMessage.Identity)).Returns(Guid.NewGuid().ToString); message.SetDomain(domain); // handler.Handle(message, socket.Object); // Func <ExternalRouteRegistration, bool> isNotAllowedMessage = er => er.Route.Receiver.IsActor() && Unsafe.ArraysEqual(er.Route.Message.Identity, notAllowedMessage.Identity) && er.Route.Message.Version == notAllowedMessage.Version && Unsafe.ArraysEqual(er.Route.Message.Partition, notAllowedMessage.Partition); externalRoutingTable.Verify(m => m.AddMessageRoute(It.Is <ExternalRouteRegistration>(er => isNotAllowedMessage(er))), Times.Never); }
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 UnregisterSelfForMessagesWithoutReceiver_GroupsMessagesForSendingWithoutException() { var unregRoutes = new[] { new MessageRoute { Message = MessageIdentifier.Create <SimpleMessage>(), Receiver = null }, new MessageRoute { Message = MessageIdentifier.Create <ExceptionMessage>(), Receiver = null }, new MessageRoute { Message = MessageIdentifier.Create <AsyncExceptionMessage>(), Receiver = null } }; // clusterMonitor.UnregisterSelf(unregRoutes); // 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.Equal(domain, msg.Domain); Assert.Equal(1, payload.Routes.Length); Assert.Equal(payload.Routes.First().MessageContracts.Length, unregRoutes.Length); Assert.True(payload.Routes.All(r => r.ReceiverIdentity == null)); return(true); } return(false); }; autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => messageIsConsistent(msg))), Times.Once); }
public void EnqueueRequest_SendsMessageWithCallbackSetToThisMessageHub() { try { messageHub.Start(); var message = Message.CreateFlowStartMessage(new SimpleMessage()); var callback = CallbackPoint.Create <SimpleMessage>(); // messageHub.EnqueueRequest(message, callback); AsyncOpCompletionDelay.Sleep(); // Func <IMessage, bool> routerSocketIsReceiver = msg => Unsafe.ArraysEqual(msg.As <Message>().ReceiverNodeIdentity, scaleOutAddress.Identity) && Unsafe.ArraysEqual(msg.As <Message>().ReceiverIdentity, messageHub.ReceiverIdentifier.Identity); routerSocket.WaitUntilMessageSent(routerSocketIsReceiver); } finally { messageHub.Stop(); } }
public void HeartBeatMessageIsSent_EveryHeartBeatInterval() { var heartBeatsToSend = 2; var asyncOp = heartBeatInterval.MultiplyBy(heartBeatsToSend + 1); // heartBeatSender.Start(); asyncOp.Sleep(); heartBeatSender.Stop(); // Func <IMessage, bool> isHeartBeatMessage = msg => { var payload = msg.GetPayload <HeartBeatMessage>(); Assert.IsTrue(Unsafe.ArraysEqual(scaleOutAddress.Identity, payload.SocketIdentity)); Assert.AreEqual(heartBeatInterval, payload.HeartBeatInterval); return(true); }; socket.Verify(m => m.SendMessage(It.Is <IMessage>(msg => isHeartBeatMessage(msg))), Times.AtLeast(heartBeatsToSend)); }
private bool HandleOperationMessage(Message message, ISocket scaleOutBackend) { var lookupRequest = new ExternalRouteLookupRequest { ReceiverIdentity = new ReceiverIdentifier(message.ReceiverIdentity), Message = new MessageIdentifier(message), Distribution = message.Distribution, ReceiverNodeIdentity = new ReceiverIdentifier(message.ReceiverNodeIdentity ?? IdentityExtensions.Empty) }; var handleMessageLocally = !message.ReceiverNodeIdentity.IsSet() || Unsafe.ArraysEqual(message.ReceiverNodeIdentity, thisNodeIdentity); var handled = handleMessageLocally && HandleMessageLocally(lookupRequest, message); if (!handled || message.Distribution == DistributionPattern.Broadcast) { handled = ForwardMessageAway(lookupRequest, message, scaleOutBackend) || handled; } return(handled || ProcessUnhandledMessage(message, lookupRequest)); }
public void DeletePeer_SendsDeletePeerMessage() { var receiverIdentifier = new ReceiverIdentifier(Guid.NewGuid().ToByteArray()); // clusterHealthMonitor.DeletePeer(receiverIdentifier); // Func <IMessage, bool> isDeletePeerMessage = msg => { if (msg.Equals(KinoMessages.DeletePeer)) { var payload = msg.GetPayload <DeletePeerMessage>(); Assert.IsTrue(Unsafe.ArraysEqual(receiverIdentifier.Identity, payload.NodeIdentity)); return(true); } return(false); }; multiplexingSocket.Verify(m => m.Send(It.Is <IMessage>(msg => isDeletePeerMessage(msg))), Times.Once); }