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 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 RegisterOwnGlobalRoutes_RegisteresOnlyGlobalyRegisteredMessageHubs()
{
var internalRoutes = new InternalRouting
{
Actors = Enumerable.Empty <MessageActorRoute>(),
MessageHubs = EnumerableExtensions.Produce(Randomizer.Int32(5, 15),
i => new MessageHubRoute
{
MessageHub = ReceiverIdentities.CreateForMessageHub(),
LocalRegistration = i % 2 == 0
})
};
internalRoutingTable.Setup(m => m.GetAllRoutes()).Returns(internalRoutes);
var globalMessageHubs = internalRoutes.MessageHubs.Where(mh => !mh.LocalRegistration);
//
registrar.RegisterOwnGlobalRoutes(domain);
//
Func <IEnumerable <MessageRoute>, bool> isGlobalMessageHub = mrs =>
{
CollectionAssert.AreEquivalent(globalMessageHubs.Select(mh => mh.MessageHub),
mrs.Select(mr => mr.Receiver));
return(true);
};
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => isGlobalMessageHub(mrs)), domain), Times.Once);
}
public void AddMessageRoute_AddsMessageHub()
{
var routeRegistration = new ExternalRouteRegistration
{
Peer = new Node("tcp://127.0.0.2:8080", Guid.NewGuid().ToByteArray()),
Health = new Health
{
Uri = "tcp://192.168.0.1:9090",
HeartBeatInterval = TimeSpan.FromSeconds(4)
},
Route = new MessageRoute
{
Receiver = ReceiverIdentities.CreateForMessageHub()
}
};
//
externalRoutingTable.AddMessageRoute(routeRegistration);
var route = externalRoutingTable.FindRoutes(new ExternalRouteLookupRequest
{
ReceiverIdentity = routeRegistration.Route.Receiver,
ReceiverNodeIdentity = new ReceiverIdentifier(routeRegistration.Peer.SocketIdentity)
})
.First();
//
Assert.AreEqual(routeRegistration.Peer, route.Node);
Assert.AreEqual(routeRegistration.Health.Uri, route.Health.Uri);
Assert.AreEqual(routeRegistration.Health.HeartBeatInterval, route.Health.HeartBeatInterval);
Assert.IsFalse(route.Connected);
}
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 RegisterSelf_SendsRegistrationMessageForEachReceiver()
{
var actorIdentifier = ReceiverIdentities.CreateForActor();
var messageHubIdentifier = ReceiverIdentities.CreateForMessageHub();
var registrations = new[]
{
new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Message = MessageIdentifier.Create <ExceptionMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Receiver = messageHubIdentifier
}
};
//
clusterMonitor.RegisterSelf(registrations, domain);
//
Func <IMessage, bool> messageIsConsistent = msg =>
{
if (msg.Equals(MessageIdentifier.Create <RegisterExternalMessageRouteMessage>()))
{
var payload = msg.GetPayload <RegisterExternalMessageRouteMessage>();
Assert.Equal(payload.Uri, scaleOutAddress.Uri.ToSocketAddress());
Assert.True(Unsafe.ArraysEqual(payload.NodeIdentity, scaleOutAddress.Identity));
Assert.Equal(payload.Health.Uri, heartBeatUri.ToSocketAddress());
Assert.Equal(payload.Health.HeartBeatInterval, heartBeatInterval);
var actorRoutes = payload.Routes
.First(r => Unsafe.ArraysEqual(r.ReceiverIdentity, actorIdentifier.Identity));
foreach (var registration in registrations.Where(r => r.Receiver == actorIdentifier))
{
Assert.True(actorRoutes.MessageContracts.Any(mc => Unsafe.ArraysEqual(mc.Identity, registration.Message.Identity) &&
Unsafe.ArraysEqual(mc.Partition, registration.Message.Partition) &&
mc.Version == registration.Message.Version));
}
var messageHub = payload.Routes
.First(r => Unsafe.ArraysEqual(r.ReceiverIdentity, messageHubIdentifier.Identity));
Assert.Null(messageHub.MessageContracts);
return(true);
}
return(false);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => messageIsConsistent(msg))), Times.Once);
}
public void IfDiscoveryMessageRouteIsForNotRegisteredMessageHub_RegisterSelfIsNotCalled()
{
var payload = new DiscoverMessageRouteMessage {
ReceiverIdentity = ReceiverIdentities.CreateForMessageHub().Identity
};
var message = Message.Create(payload).As <Message>();
message.SetDomain(domain);
//
handler.Handle(message, null);
//
internalRoutingTable.Verify(m => m.GetAllRoutes(), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.IsAny <IEnumerable <MessageRoute> >(), It.IsAny <string>()), Times.Never);
}
public void IfLastMessageHubRouteIsRemoved_PeerWillBeDisconnected()
{
var node = new Node("tcp://127.0.0.2:8080", Guid.NewGuid().ToByteArray());
var health = new Health
{
Uri = "tcp://192.168.0.1:9090",
HeartBeatInterval = TimeSpan.FromSeconds(4)
};
var messageHubRegistrations = Randomizer.Int32(2, 5)
.Produce(() => new ExternalRouteRegistration
{
Peer = node,
Health = health,
Route = new MessageRoute
{
Receiver = ReceiverIdentities.CreateForMessageHub()
}
})
.ForEach(r => externalRoutingTable.AddMessageRoute(r))
.ToList();
//
for (var i = 0; i < messageHubRegistrations.Count(); i++)
{
var messageHubToRemove = messageHubRegistrations.ElementAt(i).Route.Receiver;
var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
{
NodeIdentifier = node.SocketIdentity,
Route = new MessageRoute {
Receiver = messageHubToRemove
}
});
if (LastMessageHubRemoved(i, messageHubRegistrations.Count()))
{
Assert.Equal(PeerConnectionAction.Disconnect, res.ConnectionAction);
}
else
{
Assert.Equal(PeerConnectionAction.KeepConnection, res.ConnectionAction);
}
}
//
var peers = externalRoutingTable.FindRoutes(new ExternalRouteLookupRequest
{
ReceiverNodeIdentity = new ReceiverIdentifier(node.SocketIdentity)
});
Assert.Empty(peers);
}
public void LocalyRegisteredMessageHub_IsRegisteredInLocalRoutingTableButNotInCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
KeepRegistrationLocal = true,
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.IsAny <IEnumerable <MessageRoute> >(), It.IsAny <string>()),
Times.Never);
}
public void RemoveReceiverRoute_RemoveAllMessageHubRegistrations()
{
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
DestinationSocket = new LocalSocket <IMessage>()
};
internalRoutingTable.AddMessageRoute(registration);
//
var route = internalRoutingTable.RemoveReceiverRoute(registration.DestinationSocket)
.First();
//
Assert.AreEqual(registration.ReceiverIdentifier, route.Receiver);
}
public void UnregisterSelf_SendsOneUnregisterMessageRouteMessagePerDomain()
{
var actorIdentifier = ReceiverIdentities.CreateForActor();
var messageHubIdentifier = ReceiverIdentities.CreateForMessageHub();
var routes = new[]
{
new MessageRoute
{
Message = MessageIdentifier.Create <SimpleMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Message = MessageIdentifier.Create <ExceptionMessage>(),
Receiver = actorIdentifier
},
new MessageRoute
{
Receiver = messageHubIdentifier
}
};
var simpleMessageDomain = Guid.NewGuid().ToString();
var exceptionMessageDomain = Guid.NewGuid().ToString();
var allowedDomains = new[] { exceptionMessageDomain, simpleMessageDomain, Guid.NewGuid().ToString() };
securityProvider.Setup(m => m.GetDomain(MessageIdentifier.Create <SimpleMessage>().Identity)).Returns(simpleMessageDomain);
securityProvider.Setup(m => m.GetDomain(MessageIdentifier.Create <ExceptionMessage>().Identity)).Returns(exceptionMessageDomain);
securityProvider.Setup(m => m.GetAllowedDomains()).Returns(allowedDomains);
//
clusterMonitor.UnregisterSelf(routes);
//
Func <IMessage, bool> messageIsConsistent = msg =>
{
if (msg.Equals(MessageIdentifier.Create <UnregisterMessageRouteMessage>()))
{
var payload = msg.GetPayload <UnregisterMessageRouteMessage>();
Assert.Equal(payload.Uri, scaleOutAddress.Uri.ToSocketAddress());
Assert.True(Unsafe.ArraysEqual(payload.ReceiverNodeIdentity, scaleOutAddress.Identity));
Assert.True(allowedDomains.Contains(msg.Domain));
return(true);
}
return(false);
};
autoDiscoverySender.Verify(m => m.EnqueueMessage(It.Is <IMessage>(msg => messageIsConsistent(msg))), Times.Exactly(allowedDomains.Length));
}
public void GlobalyRegisteredMessageHub_IsRegisteredInLocalRoutingTableAndCluster()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
KeepRegistrationLocal = false,
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(routes => routes.Any(r => r.Receiver == routeRegistration.ReceiverIdentifier)),
domain),
Times.Once);
}
private InternalRouting GetInternalRoutes()
=> new InternalRouting
{
Actors = EnumerableExtensions.Produce(Randomizer.Int32(2, 5),
() => new MessageActorRoute
{
Actors = EnumerableExtensions.Produce(Randomizer.Int32(5, 15),
i => new ReceiverIdentifierRegistration(ReceiverIdentities.CreateForActor(), i % 2 == 0)),
Message = new MessageIdentifier(Guid.NewGuid().ToByteArray(), Randomizer.UInt16(), Guid.NewGuid().ToByteArray())
}),
MessageHubs = EnumerableExtensions.Produce(Randomizer.Int32(2, 5),
i => new MessageHubRoute
{
MessageHub = ReceiverIdentities.CreateForMessageHub(),
LocalRegistration = i % 2 == 0
})
};
public void AddMessageRoute_AddsLocalOrExternalMessageHubRoute(bool keepLocal)
{
var messageHub = ReceiverIdentities.CreateForMessageHub();
var localSocket = new LocalSocket <IMessage>();
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = messageHub,
DestinationSocket = localSocket,
KeepRegistrationLocal = keepLocal
};
//
internalRoutingTable.AddMessageRoute(registration);
//
var route = internalRoutingTable.GetAllRoutes().MessageHubs.First();
Assert.AreEqual(keepLocal, route.LocalRegistration);
Assert.AreEqual(messageHub, route.MessageHub);
}
public void RegisterOwnGlobalRoutes_RegisteresOnlyGlobalyRegisteredMessageHubsAndActors()
{
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 = EnumerableExtensions.Produce(Randomizer.Int32(5, 15),
i => new MessageHubRoute
{
MessageHub = ReceiverIdentities.CreateForMessageHub(),
LocalRegistration = i % 2 == 0
})
};
internalRoutingTable.Setup(m => m.GetAllRoutes()).Returns(internalRoutes);
var globalMessageHubs = internalRoutes.MessageHubs.Where(mh => !mh.LocalRegistration);
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> isGlobalMessageHub = mrs =>
{
globalMessageHubs.Select(mh => mh.MessageHub)
.Concat(globalActors)
.Should()
.BeEquivalentTo(mrs.Select(mr => mr.Receiver));
return(true);
};
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(mrs => isGlobalMessageHub(mrs)), domain), Times.Once);
}
public MessageHub(ICallbackHandlerStack callbackHandlers,
ILocalSocket <IMessage> localRouterSocket,
ILocalSendingSocket <InternalRouteRegistration> internalRegistrationsSender,
ILocalSocketFactory localSocketFactory,
IScaleOutConfigurationProvider scaleOutConfigurationProvider,
ISecurityProvider securityProvider,
ILogger logger,
bool keepRegistrationLocal = false)
{
this.logger = logger;
this.localRouterSocket = localRouterSocket;
this.internalRegistrationsSender = internalRegistrationsSender;
this.scaleOutConfigurationProvider = scaleOutConfigurationProvider;
this.securityProvider = securityProvider;
this.keepRegistrationLocal = keepRegistrationLocal;
this.callbackHandlers = callbackHandlers;
registrationsQueue = new BlockingCollection <CallbackRegistration>(new ConcurrentQueue <CallbackRegistration>());
receivingSocket = localSocketFactory.Create <IMessage>();
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub();
}
public void GlobalyRegisteredMessageHub_IsRegisteredInClusterOncePerEachDomain()
{
var allowedDomains = Randomizer.Int32(2, 5)
.Produce(() => Guid.NewGuid().ToString());
securityProvider.Setup(m => m.GetAllowedDomains()).Returns(allowedDomains);
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
KeepRegistrationLocal = false,
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
internalRoutingTable.Verify(m => m.AddMessageRoute(routeRegistration), Times.Once);
clusterMonitor.Verify(m => m.RegisterSelf(It.Is <IEnumerable <MessageRoute> >(routes => routes.Any(r => r.Receiver == routeRegistration.ReceiverIdentifier)),
It.Is <string>(d => allowedDomains.Contains(d))),
Times.Exactly(allowedDomains.Count()));
}
public void AddMessageRoute_AddsMessageHubRoute()
{
var messageHub = ReceiverIdentities.CreateForMessageHub();
var localSocket = new LocalSocket <IMessage>();
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = messageHub,
DestinationSocket = localSocket
};
//
internalRoutingTable.AddMessageRoute(registration);
//
var lookupRequest = new InternalRouteLookupRequest
{
ReceiverIdentity = messageHub
};
var socket = internalRoutingTable.FindRoutes(lookupRequest).First();
Assert.AreEqual(localSocket, socket);
}
public void RemoveMessageRouteForMessageHub_RemovesOneMessageHubAndKeepsPeerConnection()
{
var node = new Node("tcp://127.0.0.2:8080", Guid.NewGuid().ToByteArray());
var health = new Health
{
Uri = "tcp://192.168.0.1:9090",
HeartBeatInterval = TimeSpan.FromSeconds(4)
};
var messageHubRegistrations = Randomizer.Int32(2, 5)
.Produce(() => new ExternalRouteRegistration
{
Peer = node,
Health = health,
Route = new MessageRoute
{
Receiver = ReceiverIdentities.CreateForMessageHub()
}
})
.ForEach(r => externalRoutingTable.AddMessageRoute(r))
.ToList();
var messageHubToRemove = messageHubRegistrations.First().Route.Receiver;
//
var res = externalRoutingTable.RemoveMessageRoute(new ExternalRouteRemoval
{
NodeIdentifier = node.SocketIdentity,
Route = new MessageRoute {
Receiver = messageHubToRemove
}
});
//
Assert.Equal(PeerConnectionAction.KeepConnection, res.ConnectionAction);
var peer = externalRoutingTable.FindRoutes(new ExternalRouteLookupRequest
{
ReceiverNodeIdentity = new ReceiverIdentifier(node.SocketIdentity)
})
.First();
Assert.Equal(node, peer.Node);
}
public void FindRoutesByMessageHubReceiverIdentity_ReturnsMessageHubSocket()
{
var registrations = EnumerableExtensions.Produce(Randomizer.Int32(3, 6),
() => new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentities.CreateForMessageHub(),
DestinationSocket = new LocalSocket <IMessage>()
});
registrations.ForEach(r => internalRoutingTable.AddMessageRoute(r));
var lookupRoute = registrations.First();
var messageHub = lookupRoute.ReceiverIdentifier;
var localSocket = lookupRoute.DestinationSocket;
//
var lookupRequest = new InternalRouteLookupRequest
{
ReceiverIdentity = messageHub
};
var socket = internalRoutingTable.FindRoutes(lookupRequest)
.First();
//
Assert.AreEqual(localSocket, socket);
}
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());
}
