public static IActorRef CategoryQueryAggregate(this IActorRefFactory system)
{
var nameOfQueryActor = SystemData.CategoryQueryActor.Name;
var queryProps = new ConsistentHashingPool(10).Props(Props.Create <CategoryQuery>());
return(system.ActorOf(queryProps, $"{nameOfQueryActor}"));
}
public static IActorRef CategoryCommanderAggregate(this IActorRefFactory system, Guid id,
int snapshotThreshold = 2)
{
var nameOfCommanderActor = SystemData.CategoryCommanderActor.Name;
var nameofProjectionActor = SystemData.CategoryProjectionsActor.Name;
// var nameOfProcessManagerActor = "category-process-manager";
// build up the category actor
var projectionsProps = new ConsistentHashingPool(10)
.Props(Props.Create <ReadModelProjections>());
var projections = system.ActorOf(projectionsProps, $"{nameofProjectionActor}-{nameOfCommanderActor}");
/*var processManagerProps = new ConsistentHashingPool(1)
* .Props(Props.Create(() => new CategoryProcessManager(id)));*/
// var processManager = system.ActorOf(Props.Create(() => new CategoryProcessManager(id)));
// var categoryStatusSaga = system.ActorSelection($"/user/{SystemData.CategoryStatusSagaActor.Name}-group");
var categoryStatusSagaActor = system.ActorOf(
Props.Empty.WithRouter(FromConfig.Instance), "category-status-broadcaster-group");
var creationParams = new AggregateRootCreationParameters(id, projections,
new HashSet <IActorRef>(new List <IActorRef> {
categoryStatusSagaActor
}), snapshotThreshold);
return(system.ActorOf(Props.Create <Category>(creationParams), nameOfCommanderActor));
}
public static IActorRef AccountAggregate(this ActorSystem system, Guid id, int snapshotThreshold = 250)
{
var projectionsProps = new ConsistentHashingPool(5).Props(Props.Create <ReadModelProjections>());
var projections = system.ActorOf(projectionsProps, SystemData.ProjectionsActor.Name);
var creationParams = new AggregateRootCreationParameters(id, projections, snapshotThreshold);
return(system.ActorOf(Props.Create <Account>(creationParams), "aggregates(account)"));
}
public void Can_serialize_ConsistentHashingPoolWithDispatcherAndResizer()
{
var defaultResizer = new DefaultResizer(2, 4, 1, 0.5D, 0.3D, 0.1D, 55);
var message = new ConsistentHashingPool(
nrOfInstances: 25,
routerDispatcher: "my-dispatcher",
usePoolDispatcher: true,
resizer: defaultResizer,
supervisorStrategy: SupervisorStrategy.DefaultStrategy);
AssertEqual(message);
}
public static IActorRef CategoryCommanderAggregate(this IActorRefFactory system, Guid id,
int snapshotThreshold = 10)
{
var nameOfCommanderActor = SystemData.CategoryCommanderActor.Name;
var nameofProjectionActor = SystemData.CategoryProjectionsActor.Name;
// build up the category actor
var projectionsProps = new ConsistentHashingPool(5).Props(Props.Create <ReadModelProjections>());
var projections = system.ActorOf(projectionsProps, nameofProjectionActor + $"-{nameOfCommanderActor}");
var creationParams = new AggregateRootCreationParameters(id, projections, snapshotThreshold);
return(system.ActorOf(Props.Create <Category>(creationParams), nameOfCommanderActor));
}
public void CanSerializeConsistentHashPool()
{
var decider = Decider.From(
Directive.Restart,
Directive.Stop.When<ArgumentException>(),
Directive.Stop.When<NullReferenceException>());
var supervisor = new OneForOneStrategy(decider);
var message = new ConsistentHashingPool(10, null, supervisor, "abc");
AssertEqual(message);
}
protected virtual RouterConfig CreateActorRouter(CreateActorRouteMessage msg)
{
switch (msg.PoolKind)
{
case PoolKind.Random:
Log.Debug("Created random pool router to pass messages to {actor} ", msg.ActorName);
return(new RandomPool(Environment.ProcessorCount));
case PoolKind.ConsistentHash:
Log.Debug("Created consistent hashing pool router to pass messages to {actor} ", msg.ActorName);
var routesMap = msg.Routes.ToDictionary(r => CreateHandlerRouteMessage.GetTypeWithoutMetadata(r.MessageType),
r => r.CorrelationField);
var pool = new ConsistentHashingPool(Environment.ProcessorCount,
message =>
{
var idContainer = (message as IMessageMetadataEnvelop)?.Message ?? message;
string prop = null;
foreach (var searchType in GetInterfacesAndBaseTypes(idContainer.GetType()))
{
if (!routesMap.TryGetValue(searchType, out prop))
{
continue;
}
var value = idContainer.GetType()
.GetProperty(prop)
.GetValue(idContainer);
return(value);
}
throw new ArgumentException($"Cannot find route for {message.GetType()}");
}
);
return(pool);
case PoolKind.None:
Log.Debug("Intentionally use {actor} without router", msg.ActorName);
return(NoRouter.Instance);
default:
Log.Debug("{actor} defaulted to no router", msg.ActorName);
return(NoRouter.Instance);
}
}
public Props Configurate(Props mutator)
{
var router = new ConsistentHashingPool(_instances)
.WithSupervisorStrategy(_supervisorStrategy);
if (_resizer != null)
{
router = router.WithResizer(_resizer);
}
if (!string.IsNullOrWhiteSpace(_dispatcher))
{
router = router.WithDispatcher(_dispatcher);
}
if (_vNotes != null)
{
router = router.WithVirtualNodesFactor(_vNotes.Value);
}
mutator = mutator.WithRouter(router);
return(_custom != null?_custom(mutator) : mutator);
}
public bool Start(HostControl hostControl)
{
GlobalActorSystem = ActorSystem.Create("magazine-system");
var categorySagaProps =
new ConsistentHashingPool(2).Props(
Props.Create(() => new CategoryStatusWorkflow(
new Guid("8f88d4f42e3c4a868b4667dfe5f97bea"))));
CategoryStatusSagaActor = GlobalActorSystem.ActorOf(
categorySagaProps,
"category-status-broadcaster");
if (!BsonClassMap.IsClassMapRegistered(typeof(PersistentFSMBase <, ,> .StateChangeEvent)))
{
BsonClassMap.RegisterClassMap <PersistentFSMBase <Status, List <CategoryData>, Event> .StateChangeEvent>();
}
if (!BsonClassMap.IsClassMapRegistered(typeof(CategoryStatusUpdated)))
{
BsonClassMap.RegisterClassMap <CategoryStatusUpdated>();
}
return(true);
}
public void Can_serialize_ConsistentHashingPool()
{
var message = new ConsistentHashingPool(nrOfInstances: 25);
AssertEqual(message);
}
//
// ConsistentHashingPool
//
private byte[] ConsistentHashingPoolToProto(ConsistentHashingPool hashingPool)
{
return(GenericRoutingPoolBuilder(hashingPool).ToByteArray());
}
public void CanSerializeConsistentHashPool()
{
var message = new ConsistentHashingPool(10);
AssertEqual(message);
}
