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 OnlyGlobalyRegisteredMessageRoutes_AreRegisteredInLocalRoutingTableButAndCluster()
{
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()),
KeepRegistrationLocal = i % 2 == 0
}),
DestinationSocket = destinationSocket.Object
};
//
handler.Handle(routeRegistration);
//
Func <IEnumerable <MessageRoute>, bool> areGlobalMessageRoutes = mrs =>
{
CollectionAssert.AreEquivalent(routeRegistration.MessageContracts
.Where(mc => !mc.KeepRegistrationLocal)
.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)), domain), Times.Once);
}
private void RegisterMessageHub()
{
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = ReceiverIdentifier,
KeepRegistrationLocal = keepRegistrationLocal,
DestinationSocket = receivingSocket
};
internalRegistrationsSender.Send(registration);
}
private IEnumerable <MessageRouteDomainMap> GetMessageHubs(InternalRouteRegistration routeRegistration)
=> routeRegistration.ToEnumerable()
.Where(r => !r.KeepRegistrationLocal && r.ReceiverIdentifier.IsMessageHub())
.SelectMany(r => securityProvider.GetAllowedDomains()
.Select(dom => new MessageRouteDomainMap
{
MessageRoute = new Cluster.MessageRoute
{
Receiver = r.ReceiverIdentifier
},
Domain = dom
}));
public void IfReceiverIdentifierIsNeitherActorNorMessageHub_MessageRouteIsNotAdded()
{
var routeRegistration = new InternalRouteRegistration
{
ReceiverIdentifier = new ReceiverIdentifier(Guid.NewGuid().ToByteArray())
};
//
handler.Handle(routeRegistration);
//
internalRoutingTable.Verify(m => m.AddMessageRoute(It.IsAny <InternalRouteRegistration>()), Times.Never);
}
public void IfReceiverIdentifierNeitherMessageHubNorActor_AddMessageRouteThrowsException()
{
var receiverIdentity = new ReceiverIdentifier(Guid.NewGuid().ToByteArray());
var localSocket = new LocalSocket <IMessage>();
var registration = new InternalRouteRegistration
{
ReceiverIdentifier = receiverIdentity,
DestinationSocket = localSocket
};
//
Assert.Throws <ArgumentException>(() => internalRoutingTable.AddMessageRoute(registration));
}
private IEnumerable <MessageRouteDomainMap> GetActors(InternalRouteRegistration routeRegistration)
=> routeRegistration.ToEnumerable()
.Where(r => r.ReceiverIdentifier.IsActor())
.SelectMany(a => a.MessageContracts
.Where(mc => !mc.KeepRegistrationLocal)
.Select(mc => new MessageRouteDomainMap
{
MessageRoute = new Cluster.MessageRoute
{
Receiver = a.ReceiverIdentifier,
Message = mc.Message
},
Domain = securityProvider.GetDomain(mc.Message.Identity)
}));
public void Handle(InternalRouteRegistration routeRegistration)
{
if (routeRegistration.ReceiverIdentifier.IsMessageHub() ||
routeRegistration.ReceiverIdentifier.IsActor() && routeRegistration.MessageContracts?.Any() == true)
{
internalRoutingTable.AddMessageRoute(routeRegistration);
var routesByDomain = GetActors(routeRegistration).Concat(GetMessageHubs(routeRegistration))
.GroupBy(mh => mh.Domain);
foreach (var route in routesByDomain)
{
clusterMonitor.RegisterSelf(route.Select(r => r.MessageRoute), route.Key);
}
}
}
public void IfInternalRegistrationMessageIsNull_InternalRegistrationHandlerIsNotCalled()
{
var internalRouteRegistration = new InternalRouteRegistration();
internalRegistrationsReceiver.Setup(m => m.TryReceive()).Returns(() =>
{
internalRegistrationsReceiverWaitHandle.Reset();
return(null);
});
messageRouter.Start();
//
internalRegistrationsReceiverWaitHandle.Set();
messageRouter.Stop();
//
internalRegistrationHandler.Verify(m => m.Handle(internalRouteRegistration), Times.Never);
}
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 IfInternalRegistrationMessageIsReceived_InternalRegistrationHandlerIsCalled()
{
var internalRouteRegistration = new InternalRouteRegistration();
internalRegistrationsReceiver.Setup(m => m.TryReceive()).Returns(() =>
{
internalRegistrationsReceiverWaitHandle.Reset();
return(internalRouteRegistration);
});
messageRouter.Start();
//
internalRegistrationsReceiverWaitHandle.Set();
AsyncOpCompletionDelay.Sleep();
messageRouter.Stop();
//
internalRegistrationHandler.Verify(m => m.Handle(internalRouteRegistration), Times.Once);
}
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 void SendActorRegistrationMessage(ActorRegistration registration)
{
var routeReg = new InternalRouteRegistration
{
ReceiverIdentifier = registration.ActorIdentifier,
MessageContracts = registration.MessageHandlers
.Select(mh => new MessageContract
{
Message = mh.Identifier,
KeepRegistrationLocal = mh.KeepRegistrationLocal
})
.ToArray(),
DestinationSocket = receivingSocket
};
internalRegistrationsSender.Send(routeReg);
}
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 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 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);
}
