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