public void ConsistentHashingRouterMustSelectDestinationWithDefinedHashMapping()
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is Msg2)
{
var m2 = msg as Msg2;
return(m2.Key);
}
return(null);
};
var router2 =
Sys.ActorOf(new ConsistentHashingPool(1, null, null, null, hashMapping: hashMapping).Props(Props.Create <Echo>()), "router2");
router2.Tell(new Msg2("a", "A"));
var destinationA = ExpectMsg <IActorRef>();
router2.Tell(new ConsistentHashableEnvelope("AA", "a"));
ExpectMsg(destinationA);
router2.Tell(new Msg2(17, "A"));
var destinationB = ExpectMsg <IActorRef>();
router2.Tell(new ConsistentHashableEnvelope("BB", 17));
ExpectMsg(destinationB);
router2.Tell(new Msg2(new MsgKey("c"), "C"));
var destinationC = ExpectMsg <IActorRef>();
router2.Tell(new ConsistentHashableEnvelope("CC", new MsgKey("c")));
ExpectMsg(destinationC);
}
AClusterRouterWithConsistentHashingPoolMustHandleCombinationOfConfiguredRouterAndProgramaticallyDefinedHashMappingAndClusterConfig
()
{
RunOn(() =>
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is string)
{
return(msg);
}
return(null);
};
var router4 =
Sys.ActorOf(
new ClusterRouterPool(local: new ConsistentHashingPool(0).WithHashMapping(hashMapping),
settings: new ClusterRouterPoolSettings(totalInstances: 10, maxInstancesPerNode: 2,
allowLocalRoutees: true, useRole: null)).Props(Props.Create <ConsistentHashingRouterMultiNodeConfig.Echo>()), "router4");
AssertHashMapping(router4);
}, _config.First);
EnterBarrier("after-7");
}
public ConsistentHashingGroup(IEnumerable <string> paths, int virtualNodesFactor = 0,
ConsistentHashMapping hashMapping = null)
: base(paths)
{
VirtualNodesFactor = virtualNodesFactor;
HashMapping = hashMapping;
}
protected void A_cluster_router_with_consistent_hashing_pool_must_handle_combination_of_configured_router_and_programatically_defined_hash_mapping_and_cluster_config()
{
RunOn(() =>
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is string)
{
return(msg);
}
return(null);
};
var router4 =
Sys.ActorOf(
new ClusterRouterPool(
local: new ConsistentHashingPool(0).WithHashMapping(hashMapping),
settings: new ClusterRouterPoolSettings(
10,
1,
allowLocalRoutees: true,
useRole: null)).Props(Props.Create <ConsistentHashingRouterMultiNodeConfig.Echo>()), "router4");
AssertHashMapping(router4);
}, _config.First);
EnterBarrier("after-6");
}
public void ConsistentHashingGroupRouterMustSelectDestinationWithDefinedHashMapping()
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is Msg2)
{
var m2 = msg as Msg2;
return(m2.Key);
}
return(null);
};
var router4 =
Sys.ActorOf(Props.Empty.WithRouter(new ConsistentHashingGroup(new[] { c }, hashMapping: hashMapping)), "router4");
router4.Tell(new Msg2("a", "A"));
var destinationA = ExpectMsg <IActorRef>();
router4.Tell(new ConsistentHashableEnvelope("AA", "a"));
ExpectMsg(destinationA);
router4.Tell(new Msg2(17, "A"));
var destinationB = ExpectMsg <IActorRef>();
router4.Tell(new ConsistentHashableEnvelope("BB", 17));
ExpectMsg(destinationB);
router4.Tell(new Msg2(new MsgKey("c"), "C"));
var destinationC = ExpectMsg <IActorRef>();
router4.Tell(new ConsistentHashableEnvelope("CC", new MsgKey("c")));
ExpectMsg(destinationC);
}
public ConsistentHashingGroup(IEnumerable <IActorRef> routees, int virtualNodesFactor = 0,
ConsistentHashMapping hashMapping = null)
: base(routees)
{
VirtualNodesFactor = virtualNodesFactor;
HashMapping = hashMapping;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingPool"/> class.
/// </summary>
/// <param name="nrOfInstances">The nr of instances.</param>
/// <param name="resizer">The resizer.</param>
/// <param name="supervisorStrategy">The supervisor strategy.</param>
/// <param name="routerDispatcher">The router dispatcher.</param>
/// <param name="usePoolDispatcher">if set to <c>true</c> [use pool dispatcher].</param>
/// <param name="virtualNodesFactor">The number of virtual nodes to use on the hash ring</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages</param>
public ConsistentHashingPool(int nrOfInstances, Resizer resizer, SupervisorStrategy supervisorStrategy,
string routerDispatcher, bool usePoolDispatcher = false, int virtualNodesFactor = 0,
ConsistentHashMapping hashMapping = null)
: base(nrOfInstances, resizer, supervisorStrategy, routerDispatcher, usePoolDispatcher)
{
VirtualNodesFactor = virtualNodesFactor;
_hashMapping = hashMapping;
}
public ConsistentHashingRoutingLogic(ActorSystem system, int virtualNodesFactor,
ConsistentHashMapping hashMapping)
{
_system = system;
_log = new Lazy <ILoggingAdapter>(() => Logging.GetLogger(_system, this), true);
_hashMapping = hashMapping;
_selfAddress = system.AsInstanceOf <ExtendedActorSystem>().Provider.DefaultAddress;
_vnodes = virtualNodesFactor == 0 ? system.Settings.DefaultVirtualNodesFactor : virtualNodesFactor;
}
public ConsistentHashingRoutingLogic WithHashMapping(ConsistentHashMapping mapping)
{
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
return(new ConsistentHashingRoutingLogic(_system, _vnodes, mapping));
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingGroup"/> class.
/// </summary>
/// <param name="paths">An enumeration of actor paths used by the group router.</param>
/// <param name="virtualNodesFactor">The number of virtual nodes to use on the hash ring.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
/// <param name="routerDispatcher">The dispatcher to use when passing messages to the routees.</param>
public ConsistentHashingGroup(
IEnumerable <string> paths,
int virtualNodesFactor,
ConsistentHashMapping hashMapping,
string routerDispatcher)
: base(paths, routerDispatcher)
{
VirtualNodesFactor = virtualNodesFactor;
_hashMapping = hashMapping;
}
public void AClusterRouterWithConsistentHashingGroupMustSendToSameDestinationsFromDifferentNodes()
{
Sys.ActorOf(Props.Create <ClusterConsistentHashingGroupSpecConfig.Destination>(), "dest");
AwaitClusterUp(_config.First, _config.Second, _config.Third);
EnterBarrier("after-1");
ConsistentHashMapping hashMapping = msg =>
{
if (msg is string)
{
return(msg);
}
return(null);
};
var paths = new List <string>()
{
"/user/dest"
};
var router =
Sys.ActorOf(
new ClusterRouterGroup(new ConsistentHashingGroup(paths).WithHashMapping(hashMapping),
new ClusterRouterGroupSettings(10, true, null, ImmutableHashSet.Create <string>(paths.ToArray())))
.Props(), "router");
// it may take some time until router receives cluster member events
AwaitAssert(() =>
{
var members = CurrentRoutees(router).Members;
members.Count().ShouldBe(3);
});
var keys = new[] { "A", "B", "C", "D", "E", "F", "G" };
foreach (var key in Enumerable.Range(1, 10).SelectMany(i => keys))
{
router.Tell(key, TestActor);
}
EnterBarrier("messages-sent");
router.Tell(new Broadcast(new Get()));
var a = ExpectMsg <ClusterConsistentHashingGroupSpecConfig.Collected>().Messages;
var b = ExpectMsg <ClusterConsistentHashingGroupSpecConfig.Collected>().Messages;
var c = ExpectMsg <ClusterConsistentHashingGroupSpecConfig.Collected>().Messages;
a.Intersect(b).Count().ShouldBe(0);
a.Intersect(c).Count().ShouldBe(0);
b.Intersect(c).Count().ShouldBe(0);
(a.Count + b.Count + c.Count).ShouldBe(keys.Length);
EnterBarrier("after-2");
}
public void A_cluster_router_with_consistent_hashing_group_must_send_to_same_destinations_from_different_nodes()
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is string)
{
return(msg);
}
return(null);
};
var paths = new List <string> {
"/user/dest"
};
var router =
Sys.ActorOf(
new ClusterRouterGroup(
local: new ConsistentHashingGroup(paths).WithHashMapping(hashMapping),
settings: new ClusterRouterGroupSettings(
10,
ImmutableHashSet.Create(paths.ToArray()),
allowLocalRoutees: true,
useRole: null))
.Props(), "router");
// it may take some time until router receives cluster member events
AwaitAssert(() =>
{
CurrentRoutees(router).Members.Should().HaveCount(3);
});
var keys = new[] { "A", "B", "C", "D", "E", "F", "G" };
foreach (var key in Enumerable.Range(1, 10).SelectMany(i => keys))
{
router.Tell(key, TestActor);
}
EnterBarrier("messages-sent");
router.Tell(new Broadcast(new ClusterConsistentHashingGroupSpecConfig.Get()));
var a = ExpectMsg <ClusterConsistentHashingGroupSpecConfig.Collected>().Messages;
var b = ExpectMsg <ClusterConsistentHashingGroupSpecConfig.Collected>().Messages;
var c = ExpectMsg <ClusterConsistentHashingGroupSpecConfig.Collected>().Messages;
a.Intersect(b).Count().Should().Be(0);
a.Intersect(c).Count().Should().Be(0);
b.Intersect(c).Count().Should().Be(0);
(a.Count + b.Count + c.Count).Should().Be(keys.Length);
EnterBarrier("after-2");
}
protected void A_cluster_router_with_consistent_hashing_pool_must_handle_combination_of_configured_router_and_programatically_defined_hash_mapping()
{
RunOn(() =>
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is string)
{
return(msg);
}
return(null);
};
var router3 = Sys.ActorOf(new ConsistentHashingPool(nrOfInstances: 0).WithHashMapping(hashMapping)
.Props(Props.Create <ConsistentHashingRouterMultiNodeConfig.Echo>()), "router3");
AssertHashMapping(router3);
}, _config.First);
EnterBarrier("after-5");
}
AClusterRouterWithConsistentHashingPoolMustHandleCombinationOfConfiguredRouterAndProgramaticallyDefinedHashMapping()
{
RunOn(() =>
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is string)
{
return(msg);
}
return(null);
};
var router3 =
Sys.ActorOf(new ConsistentHashingPool(0).WithHashMapping(hashMapping).Props(Props.Create <ConsistentHashingRouterMultiNodeConfig.Echo>()), "router3");
AssertHashMapping(router3);
}, _config.First);
EnterBarrier("after-6");
}
public void Consistent_hashing_group_router_must_select_destination_with_defined_hash_mapping()
{
ConsistentHashMapping hashMapping = msg =>
{
if (msg is Msg2)
{
var m2 = msg as Msg2;
return(m2.Key);
}
return(null);
};
var paths = new List <string> {
c.Path.ToString()
};
var router4 = Sys.ActorOf(new ConsistentHashingGroup(paths, hashMapping).Props(), "router4");
router4.Tell(new Msg2("a", "A"));
var destinationA = ExpectMsg <IActorRef>();
router4.Tell(new ConsistentHashableEnvelope("AA", "a"));
ExpectMsg(destinationA);
router4.Tell(new Msg2(17, "A"));
var destinationB = ExpectMsg <IActorRef>();
router4.Tell(new ConsistentHashableEnvelope("BB", 17));
ExpectMsg(destinationB);
router4.Tell(new Msg2(new MsgKey("c"), "C"));
var destinationC = ExpectMsg <IActorRef>();
router4.Tell(new ConsistentHashableEnvelope("CC", new MsgKey("c")));
ExpectMsg(destinationC);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingPool"/> class.
/// </summary>
/// <param name="nrOfInstances">The initial number of routees in the pool.</param>
/// <param name="resizer">The resizer to use when dynamically allocating routees to the pool.</param>
/// <param name="supervisorStrategy">The strategy to use when supervising the pool.</param>
/// <param name="routerDispatcher">The dispatcher to use when passing messages to the routees.</param>
/// <param name="usePoolDispatcher"><c>true</c> to use the pool dispatcher; otherwise <c>false</c>.</param>
/// <param name="virtualNodesFactor">The number of virtual nodes to use on the hash ring.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
public ConsistentHashingPool(
int nrOfInstances,
Resizer resizer,
SupervisorStrategy supervisorStrategy,
string routerDispatcher,
bool usePoolDispatcher = false,
int virtualNodesFactor = 0,
ConsistentHashMapping hashMapping = null)
: base(nrOfInstances, resizer, supervisorStrategy, routerDispatcher, usePoolDispatcher)
{
VirtualNodesFactor = virtualNodesFactor;
_hashMapping = hashMapping;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingPool"/> class.
/// </summary>
/// <param name="nrOfInstances">The initial number of routees in the pool.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
public ConsistentHashingPool(
int nrOfInstances,
ConsistentHashMapping hashMapping)
: this(nrOfInstances, null, Pool.DefaultSupervisorStrategy, Dispatchers.DefaultDispatcherId, false, 0, hashMapping)
{
}
/// <summary>
/// Creates a new <see cref="ConsistentHashingRoutingLogic"/> router logic with a given <see cref="ConsistentHashMapping"/>.
///
/// <note>
/// This method is immutable and returns a new instance of the router.
/// </note>
/// </summary>
/// <param name="mapping">The <see cref="ConsistentHashMapping"/> used to configure the new router.</param>
/// <exception cref="ArgumentNullException">
/// This exception is thrown if the given <paramref name="mapping"/> is undefined.
/// </exception>
/// <returns>A new router logic with the provided <paramref name="mapping"/>.</returns>
public ConsistentHashingRoutingLogic WithHashMapping(ConsistentHashMapping mapping)
{
if (mapping == null)
throw new ArgumentNullException(nameof(mapping), "The mapping cannot be null.");
return new ConsistentHashingRoutingLogic(_system, _vnodes, mapping);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingRoutingLogic"/> class.
/// </summary>
/// <param name="system">The actor system that owns the router with this logic.</param>
/// <param name="virtualNodesFactor">The number of virtual nodes to use on the hash ring.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
public ConsistentHashingRoutingLogic(ActorSystem system, int virtualNodesFactor,
ConsistentHashMapping hashMapping)
{
_system = system;
_log = new Lazy<ILoggingAdapter>(() => Logging.GetLogger(_system, this), true);
_hashMapping = hashMapping;
_selfAddress = system.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;
_vnodes = virtualNodesFactor == 0 ? system.Settings.DefaultVirtualNodesFactor : virtualNodesFactor;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingGroup"/> class.
/// </summary>
/// <param name="paths">An enumeration of actor paths used by the group router.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
public ConsistentHashingGroup(
IEnumerable <string> paths,
ConsistentHashMapping hashMapping)
: this(paths, 0, hashMapping, Dispatchers.DefaultDispatcherId)
{
}
public ConsistentHashingGroup(IEnumerable<IActorRef> routees, int virtualNodesFactor = 0,
ConsistentHashMapping hashMapping = null)
: base(routees)
{
VirtualNodesFactor = virtualNodesFactor;
HashMapping = hashMapping;
}
/// <summary>
/// Apply a <see cref="ConsistentHashMapping"/> to the <see cref="ConsistentHashingPool"/>.
///
/// Note: this method is immutable and will return a new instance.
/// </summary>
public ConsistentHashingPool WithHashMapping(ConsistentHashMapping mapping)
{
return(new ConsistentHashingPool(NrOfInstances, Resizer, SupervisorStrategy, RouterDispatcher,
UsePoolDispatcher, VirtualNodesFactor, mapping));
}
public ConsistentHashingRoutingLogic WithHashMapping(ConsistentHashMapping mapping)
{
if (mapping == null)
throw new ArgumentNullException("mapping");
return new ConsistentHashingRoutingLogic(_system, _vnodes, mapping);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingPool"/> class.
/// </summary>
/// <param name="nrOfInstances">The initial number of routees in the pool.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
public ConsistentHashingPool(
int nrOfInstances,
ConsistentHashMapping hashMapping)
: this(nrOfInstances, null, Pool.DefaultSupervisorStrategy, Dispatchers.DefaultDispatcherId, false, 0, hashMapping)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingGroup"/> class.
/// </summary>
/// <param name="paths">An enumeration of actor paths used by the group router.</param>
/// <param name="virtualNodesFactor">The number of virtual nodes to use on the hash ring.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
/// <param name="routerDispatcher">The dispatcher to use when passing messages to the routees.</param>
public ConsistentHashingGroup(
IEnumerable<string> paths,
int virtualNodesFactor,
ConsistentHashMapping hashMapping,
string routerDispatcher)
: base(paths, routerDispatcher)
{
VirtualNodesFactor = virtualNodesFactor;
_hashMapping = hashMapping;
}
public ConsistentHashingGroup(IEnumerable<string> paths, int virtualNodesFactor = 0,
ConsistentHashMapping hashMapping = null)
: base(paths)
{
VirtualNodesFactor = virtualNodesFactor;
HashMapping = hashMapping;
}
/// <summary>
/// Creates a new <see cref="ConsistentHashingPool"/> router with a given <see cref="ConsistentHashMapping"/>.
///
/// <note>
/// This method is immutable and returns a new instance of the router.
/// </note>
/// </summary>
/// <param name="mapping">The <see cref="ConsistentHashMapping"/> used to configure the new router.</param>
/// <returns>A new router with the provided <paramref name="mapping"/>.</returns>
public ConsistentHashingPool WithHashMapping(ConsistentHashMapping mapping)
{
return new ConsistentHashingPool(NrOfInstances, Resizer, SupervisorStrategy, RouterDispatcher,
UsePoolDispatcher, VirtualNodesFactor, mapping);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsistentHashingGroup"/> class.
/// </summary>
/// <param name="paths">An enumeration of actor paths used by the group router.</param>
/// <param name="hashMapping">The consistent hash mapping function to use on incoming messages.</param>
public ConsistentHashingGroup(
IEnumerable<string> paths,
ConsistentHashMapping hashMapping)
: this(paths, 0, hashMapping, Dispatchers.DefaultDispatcherId)
{
}
/// <summary>
/// Creates a new <see cref="ConsistentHashingGroup"/> router with a given <see cref="ConsistentHashMapping"/>.
///
/// <note>
/// This method is immutable and returns a new instance of the router.
/// </note>
/// </summary>
/// <param name="mapping">The <see cref="ConsistentHashMapping"/> used to configure the new router.</param>
/// <returns>A new router with the provided <paramref name="mapping"/>.</returns>
public ConsistentHashingGroup WithHashMapping(ConsistentHashMapping mapping)
{
return(new ConsistentHashingGroup(InternalPaths, VirtualNodesFactor, mapping, RouterDispatcher));
}
/// <summary>
/// Creates a new <see cref="ConsistentHashingGroup"/> router with a given <see cref="ConsistentHashMapping"/>.
///
/// <note>
/// This method is immutable and returns a new instance of the router.
/// </note>
/// </summary>
/// <param name="mapping">The <see cref="ConsistentHashMapping"/> used to configure the new router.</param>
/// <returns>A new router with the provided <paramref name="mapping"/>.</returns>
public ConsistentHashingGroup WithHashMapping(ConsistentHashMapping mapping)
{
return new ConsistentHashingGroup(Paths, VirtualNodesFactor, mapping, RouterDispatcher);
}
/// <summary>
/// Apply a <see cref="ConsistentHashMapping"/> to the <see cref="ConsistentHashingGroup"/>.
///
/// Note: this method is immutable and will return a new instance.
/// </summary>
public ConsistentHashingGroup WithHashMapping(ConsistentHashMapping mapping)
{
return(new ConsistentHashingGroup(Paths, VirtualNodesFactor, mapping));
}
