public void Start()
{
Logger.Info("Starting shard");
var system = ActorSystem.Create(Constants.ActorSystemName, ConfigurationFactory.Load()
.WithFallback(config)
.WithFallback(ClusterSingletonManager.DefaultConfig()));
var sharding = ClusterSharding.Get(system);
shardRegion = sharding.Start(
typeName: nameof(MyActor),
entityProps: Props.Create(() => new MyActor(nodeId)),
settings: ClusterShardingSettings.Create(system),
messageExtractor: new MessageExtractor(Constants.MaxNumberOfNodes * 10)
);
ClusterClientReceptionist.Get(system).RegisterService(shardRegion);
}
static void Main(string[] args)
{
var akkaConfigSection = ((AkkaConfigurationSection)ConfigurationManager.GetSection("akka")).AkkaConfig;
var actorSystem = ActorSystem.Create("AkkaSingleton", akkaConfigSection);
var worker1 = actorSystem.ActorOf(WorkerActor.CreateProps("1"), "worker1");
var worker2 = actorSystem.ActorOf(WorkerActor.CreateProps("2"), "worker2");
var worker3 = actorSystem.ActorOf(WorkerActor.CreateProps("3"), "worker3");
var singletonActorRef = actorSystem.ActorOf(ClusterSingletonManager.Props(
singletonProps: ManagerSingletonActor.CreateProps("1"),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(actorSystem).WithSingletonName("singleton").WithRole("singletons")),
name: "ClusterSingletonManager");
Console.ReadLine();
}
public ClusterSingletonManagerLeave2SpecConfig()
{
First = Role("first");
Second = Role("second");
Third = Role("third");
Fourth = Role("fourth");
Fifth = Role("fifth");
CommonConfig = ConfigurationFactory.ParseString(@"
akka.loglevel = INFO
akka.actor.provider = ""cluster""
akka.remote.log-remote-lifecycle-events = off
akka.cluster.auto-down-unreachable-after = off
")
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(ClusterSingletonProxy.DefaultConfig())
.WithFallback(MultiNodeClusterSpec.ClusterConfig());
}
public ClusterSingletonManagerChaos2Config()
{
Controller = Role("controller");
First = Role("_config.First");
Second = Role("second");
Third = Role("third");
Fourth = Role("fourth");
CommonConfig = ConfigurationFactory.ParseString(@"
akka.loglevel = DEBUG
akka.actor.provider = ""Akka.Cluster.ClusterActorRefProvider, Akka.Cluster""
akka.remote.log-remote-lifecycle-events = off
akka.cluster.auto-down-unreachable-after = 0s
")
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(ClusterSingletonProxy.DefaultConfig())
.WithFallback(MultiNodeClusterSpec.ClusterConfig());
}
static void Main(string[] args)
{
var config = ConfigurationFactory.ParseString(configString).WithFallback(ClusterSingletonManager.DefaultConfig());
var system = ActorSystem.Create("cluster-system", config);
var client =
system
.ActorOf(
ClusterSingletonProxy.Props("/user/consumer",
ClusterSingletonProxySettings.Create(system).WithRole("worker")));
while (true)
{
Thread.Sleep(1000);
client.Tell(DateTime.Now.ToLongTimeString());
}
Console.ReadKey();
}
/// <summary>
/// TBD
/// </summary>
/// <param name="system">TBD</param>
public ClusterSharding(ExtendedActorSystem system)
{
_system = system;
_system.Settings.InjectTopLevelFallback(DefaultConfig());
_system.Settings.InjectTopLevelFallback(ClusterSingletonManager.DefaultConfig());
_cluster = Cluster.Get(_system);
Settings = ClusterShardingSettings.Create(system);
_guardian = new Lazy <IActorRef>(() =>
{
var guardianName = system.Settings.Config.GetString("akka.cluster.sharding.guardian-name");
var dispatcher = system.Settings.Config.GetString("akka.cluster.sharding.use-dispatcher");
if (string.IsNullOrEmpty(dispatcher))
{
dispatcher = Dispatchers.DefaultDispatcherId;
}
return(system.SystemActorOf(Props.Create(() => new ClusterShardingGuardian()).WithDispatcher(dispatcher), guardianName));
});
}
public void Join(ActorSystem from, ActorSystem to)
{
from.ActorOf(ClusterSingletonManager.Props(Echo.Props,
PoisonPill.Instance,
ClusterSingletonManagerSettings.Create(from)), "echo");
Within(TimeSpan.FromSeconds(10), () =>
{
AwaitAssert(() =>
{
Cluster.Get(from).Join(Cluster.Get(to).SelfAddress);
Cluster.Get(from).State.Members.Select(x => x.UniqueAddress).Should().Contain(Cluster.Get(from).SelfUniqueAddress);
Cluster.Get(from)
.State.Members.Select(x => x.Status)
.ToImmutableHashSet()
.Should()
.Equal(ImmutableHashSet <MemberStatus> .Empty.Add(MemberStatus.Up));
});
});
}
public ActorSys(string name = "ClusterSingletonProxySystem", Address joinTo = null)
: base(ActorSystem.Create(name, ConfigurationFactory.ParseString(_cfg).WithFallback(TestKit.Configs.TestConfigs.DefaultConfig)))
{
Cluster = Cluster.Get(Sys);
if (joinTo != null)
{
Cluster.Join(joinTo);
}
Cluster.RegisterOnMemberUp(() =>
{
Sys.ActorOf(ClusterSingletonManager.Props(Props.Create(() => new Singleton()), PoisonPill.Instance,
ClusterSingletonManagerSettings.Create(Sys)
.WithRemovalMargin(TimeSpan.FromSeconds(5))), "singletonmanager");
});
Proxy =
Sys.ActorOf(ClusterSingletonProxy.Props("user/singletonmanager",
ClusterSingletonProxySettings.Create(Sys)), $"singletonProxy-{Cluster.SelfAddress.Port ?? 0}");
}
public static Config GetConfig()
{
return(ConfigurationFactory.ParseString(@"
akka.loglevel = DEBUG
#akka.loggers = [""akka.testkit.SilenceAllTestEventListener""]
akka.loggers = [Akka.Event.DefaultLogger]
akka.actor.provider = ""cluster""
akka.remote.dot-netty.tcp.port = 0
akka.cluster.sharding {
use-lease = ""test-lease""
lease-retry-interval = 200ms
distributed-data.durable {
keys = []
}
}
")
.WithFallback(ClusterSharding.DefaultConfig())
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(TestLease.Configuration));
}
public void ClusterSingleton_with_lease_should_do_not_start_if_lease_acquire_returns_false()
{
var probe = CreateTestProbe();
var settings = NextSettings();
Sys.ActorOf(
ClusterSingletonManager.Props(Props.Create(() => new ImportantSingleton(probe.Ref)), PoisonPill.Instance, settings),
settings.SingletonName);
TestLease testLease = null;
AwaitAssert(() =>
{
testLease = testLeaseExt.GetTestLease(LeaseNameFor(settings));
}); // allow singleton manager to create the lease
probe.ExpectNoMsg(shortDuration);
testLease.InitialPromise.SetResult(false);
probe.ExpectNoMsg(shortDuration);
}
public static async Task Main(string[] args)
{
#region Console shutdown setup
var exitEvent = new ManualResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) =>
{
eventArgs.Cancel = true;
exitEvent.Set();
};
AppDomain.CurrentDomain.ProcessExit += (sender, eventArgs) =>
{
exitEvent.Set();
};
#endregion
var config = ConfigurationFactory.ParseString(await File.ReadAllTextAsync("app.conf"))
.BootstrapFromDocker()
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(SqlitePersistence.DefaultConfiguration());
var system = ActorSystem.Create("sharded-cluster-system", config);
var sharding = ClusterSharding.Get(system);
var shardRegion = await sharding.StartAsync(
typeName : "customer",
entityPropsFactory : e => Props.Create(() => new Customer(e)),
settings : ClusterShardingSettings.Create(system),
messageExtractor : new MessageExtractor(10));
var cluster = Cluster.Get(system);
cluster.RegisterOnMemberUp(() =>
{
ProduceMessages(system, shardRegion);
});
exitEvent.WaitOne();
await system.Terminate();
}
public ShardedDaemonProcessSpecConfig()
{
First = Role("first");
Second = Role("second");
Third = Role("third");
CommonConfig = DebugConfig(false)
.WithFallback(ConfigurationFactory.ParseString(@"
akka.loglevel = INFO
akka.cluster.sharded-daemon-process {{
sharding {{
# First is likely to be ignored as shard coordinator not ready
retry-interval = 0.2s
}}
# quick ping to make test swift
keep-alive-interval = 1s
}}
"))
.WithFallback(ClusterSharding.DefaultConfig())
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(MultiNodeClusterSpec.ClusterConfig());
}
public static IActorRef StartSingletonSubscriber(
ActorSystem actorSystem,
Expression <Func <TDomainEventSubscriber> > domainEventSubscriberFactory,
string roleName)
{
var name = typeof(TDomainEventSubscriber).Name;
var domainEventSubscriberProps = Props.Create(domainEventSubscriberFactory);
actorSystem.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new ClusterParentProxy(domainEventSubscriberProps, true)),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(actorSystem).WithRole(roleName).WithSingletonName(name)),
name: name);
var proxy = StartSingletonSubscriberProxy(actorSystem, roleName);
actorSystem.ActorOf(Props.Create(() =>
new SingletonDomainEventSubscriberDispatcher <TDomainEventSubscriber>(proxy)), $"{typeof(TDomainEventSubscriber).Name}Dispatcher");
return(proxy);
}
public ClusterSingletonManagerSpecConfig()
{
Controller = Role("controller");
Observer = Role("observer");
First = Role("first");
Second = Role("second");
Third = Role("third");
Fourth = Role("fourth");
Fifth = Role("fifth");
Sixth = Role("sixth");
CommonConfig = ConfigurationFactory.ParseString(@"
akka.loglevel = DEBUG
akka.actor.provider = ""Akka.Cluster.ClusterActorRefProvider, Akka.Cluster""
akka.remote.log-remote-lifecycle-events = off
akka.cluster.auto-down-unreachable-after = 0s
")
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(MultiNodeClusterSpec.ClusterConfig());
NodeConfig(new[] { First, Second, Third, Fourth, Fifth, Sixth }, new[] { ConfigurationFactory.ParseString(@"akka.cluster.roles =[worker]") });
}
public void Cluster_singleton_manager_with_lease_should_Start_singleton_and_ping_from_all_nodes()
{
RunOn(() =>
{
Sys.ActorOf(
ClusterSingletonManager.Props(
ClusterSingletonManagerLeaseSpecConfig.ImportantSingleton.Props, PoisonPill.Instance, ClusterSingletonManagerSettings.Create(Sys).WithRole("worker")),
"important");
}, _config.First, _config.Second, _config.Third, _config.Fourth);
EnterBarrier("singleton-started");
var proxy = Sys.ActorOf(
ClusterSingletonProxy.Props(
singletonManagerPath: "/user/important",
settings: ClusterSingletonProxySettings.Create(Sys).WithRole("worker")));
RunOn(() =>
{
proxy.Tell("Ping");
// lease has not been granted so now allowed to come up
ExpectNoMsg(TimeSpan.FromSeconds(2));
}, _config.First, _config.Second, _config.Third, _config.Fourth);
EnterBarrier("singleton-pending");
RunOn(() =>
{
TestLeaseActorClientExt.Get(Sys).GetLeaseActor().Tell(TestLeaseActor.GetRequests.Instance);
ExpectMsg <TestLeaseActor.LeaseRequests>(msg => msg.Requests.Should().BeEquivalentTo(new TestLeaseActor.Acquire(GetAddress(_config.First).HostPort())));
TestLeaseActorClientExt.Get(Sys).GetLeaseActor().Tell(new TestLeaseActor.ActionRequest(new TestLeaseActor.Acquire(GetAddress(_config.First).HostPort()), true));
}, _config.Controller);
EnterBarrier("lease-acquired");
RunOn(() =>
{
ExpectMsg(new ClusterSingletonManagerLeaseSpecConfig.ImportantSingleton.Response("Ping", GetAddress(_config.First)));
}, _config.First, _config.Second, _config.Third, _config.Fourth);
EnterBarrier("pinged");
}
public void ClusterSingleton_with_lease_should_release_lease_when_leaving_oldest()
{
var singletonProbe = CreateTestProbe();
var settings = NextSettings();
Sys.ActorOf(
ClusterSingletonManager.Props(Props.Create(() => new ImportantSingleton(singletonProbe.Ref)), PoisonPill.Instance, settings),
settings.SingletonName);
TestLease testLease = null;
AwaitAssert(() =>
{
testLease = testLeaseExt.GetTestLease(LeaseNameFor(settings));
}); // allow singleton manager to create the lease
singletonProbe.ExpectNoMsg(shortDuration);
testLease.Probe.ExpectMsg(new TestLease.AcquireReq(leaseOwner));
testLease.InitialPromise.SetResult(true);
singletonProbe.ExpectMsg("preStart");
cluster.Leave(cluster.SelfAddress);
testLease.Probe.ExpectMsg(new TestLease.ReleaseReq(leaseOwner));
}
public static async Task Main(string[] args)
{
var config = ConfigurationFactory.ParseString(BankHocon);
var actorSystem = ActorSystem.Create(ClusterName, config);
var clusterSystem = Cluster.Get(actorSystem);
clusterSystem.RegisterOnMemberUp(() =>
{
actorSystem.ActorOf(ClusterSingletonManager.Props(
Props.Create(() => new BasicBank.Actors.BankV2Actor()),
settings: ClusterSingletonManagerSettings.Create(actorSystem).WithRole(BankRoleName)),
BankActorName);
var bankProxy = actorSystem.ActorOf(ClusterSingletonProxy.Props(
singletonManagerPath: $"/user/{BankActorName}",
settings: ClusterSingletonProxySettings.Create(actorSystem).WithRole(BankRoleName)),
name: $"{BankActorName}-proxy");
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("BANK NODE UP!");
Console.WriteLine("ADD Billy White.");
bankProxy.Tell(new CreateCustomerRequest(new Customer(123, "Billy White")));
Console.WriteLine("ADD Sally Brown.");
bankProxy.Tell(new CreateCustomerRequest(new Customer(456, "Sally Brown")));
Console.WriteLine("ADD Wally Green.");
bankProxy.Tell(new CreateCustomerRequest(new Customer(789, "Wally Green")));
Console.ResetColor();
});
while (true)
{
await Task.Delay(10);
}
}
static int Main(string[] args)
{
var mongoConnectionString = Environment.GetEnvironmentVariable("MONGO_CONNECTION_STR")?.Trim();
if (string.IsNullOrEmpty(mongoConnectionString))
{
Console.WriteLine("ERROR! MongoDb connection string not provided. Can't start.");
return(-1);
}
else
{
Console.WriteLine("Connecting to MongoDb at {0}", mongoConnectionString);
}
var config = File.ReadAllText("app.conf");
var conf = ConfigurationFactory.ParseString(config).WithFallback(GetMongoHocon(mongoConnectionString))
.WithFallback(OpsConfig.GetOpsConfig())
.WithFallback(ClusterSharding.DefaultConfig())
.WithFallback(DistributedPubSub.DefaultConfig());
var actorSystem = ActorSystem.Create("AkkaPricing", conf.BootstrapFromDocker());
var readJournal = actorSystem.ReadJournalFor <MongoDbReadJournal>(MongoDbReadJournal.Identifier);
var priceViewMaster = actorSystem.ActorOf(Props.Create(() => new PriceViewMaster()), "prices");
Cluster.Cluster.Get(actorSystem).RegisterOnMemberUp(() =>
{
var sharding = ClusterSharding.Get(actorSystem);
var shardRegion = sharding.Start("priceAggregator",
s => Props.Create(() => new MatchAggregator(s, readJournal)),
ClusterShardingSettings.Create(actorSystem),
new StockShardMsgRouter());
// used to seed pricing data
var singleton = ClusterSingletonManager.Props(
Props.Create(() => new PriceInitiatorActor(readJournal, shardRegion)),
ClusterSingletonManagerSettings.Create(
actorSystem.Settings.Config.GetConfig("akka.cluster.price-singleton")));
// start the creation of the pricing views
priceViewMaster.Tell(new PriceViewMaster.BeginTrackPrices(shardRegion));
});
// start Petabridge.Cmd (for external monitoring / supervision)
var pbm = PetabridgeCmd.Get(actorSystem);
void RegisterPalette(CommandPaletteHandler h)
{
if (pbm.RegisterCommandPalette(h))
{
Console.WriteLine("Petabridge.Cmd - Registered {0}", h.Palette.ModuleName);
}
else
{
Console.WriteLine("Petabridge.Cmd - DID NOT REGISTER {0}", h.Palette.ModuleName);
}
}
RegisterPalette(ClusterCommands.Instance);
RegisterPalette(RemoteCommands.Instance);
RegisterPalette(ClusterShardingCommands.Instance);
RegisterPalette(new PriceCommands(priceViewMaster));
pbm.Start();
actorSystem.WhenTerminated.Wait();
return(0);
}
static void Main(string[] args)
{
Config config = @"
akka {
actor {
provider = cluster
serializers {
hyperion = ""Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion""
}
serialization-bindings {
""System.Object"" = hyperion
}
}
remote {
dot-netty.tcp {
public-hostname = ""localhost""
hostname = ""localhost""
port = 0
}
}
cluster {
auto-down-unreachable-after = 5s
sharding {
least-shard-allocation-strategy.rebalance-threshold = 3
}
}
persistence {
journal {
plugin = ""akka.persistence.journal.sqlite""
sqlite {
connection-string = ""Datasource=store.db""
auto-initialize = true
}
}
snapshot-store {
plugin = ""akka.persistence.snapshot-store.sqlite""
sqlite {
connection-string = ""Datasource=store.db""
auto-initialize = true
}
}
}
}";
using (var system = ActorSystem.Create("sharded-cluster-system", config.WithFallback(ClusterSingletonManager.DefaultConfig())))
{
var automaticCluster = new AutomaticCluster(system);
try
{
automaticCluster.Join();
RunExample(system);
Console.ReadLine();
}
finally
{
//WARNING: you may need to remove SQLite database file from bin/Debug or bin/Release in case when unexpected crash happened
automaticCluster.Leave();
}
}
}
/// <summary>
/// Creates a cluster singleton actor given its <see cref="Props"/>. Singleton actor will
/// exists only on one node in a cluster at a time. If this node goes down, it will be
/// recreated on another one (usually it lives on the oldest node in the cluster).
/// </summary>
/// <param name="system"></param>
/// <param name="props"></param>
/// <param name="name"></param>
/// <returns></returns>
public static IActorRef SingletonOf(this ActorSystem system, Props props, string name)
{
return(system.ActorOf(ClusterSingletonManager.Props(
singletonProps: props,
settings: ClusterSingletonManagerSettings.Create(system).WithRole(name)), name));
}
static ClusterShardingMessageSerializerSpec()
{
SpecConfig = ClusterSingletonManager.DefaultConfig().WithFallback(ClusterSharding.DefaultConfig());
}
static void Main(string[] args)
{
using (var system = ActorSystem.Create("sharded-cluster-system", Cch2.Cfg.WithFallback(ClusterSingletonManager.DefaultConfig())))
{
var automaticCluster = new AutomaticCluster(system);
try
{
automaticCluster.Join();
CounterHelper.CounterActor = system.ActorOf(Props.Create(() => new CounterActor()));
RunExample(system);
Console.WriteLine("## Is started");
Console.ReadLine();
}
finally
{
//WARNING: you may need to remove SQLite database file from bin/Debug or bin/Release in case when unexpected crash happened
automaticCluster.Leave();
}
}
}
public ClusterSingletonMessageSerializerSpec()
: base(ConfigurationFactory.ParseString(@"akka.actor.provider = cluster
akka.remote.dot-netty.tcp.port = 0").WithFallback(ClusterSingletonManager.DefaultConfig()))
{
}
public void Start()
{
SystemActors.ClusterSystem = SystemHostFactory.Launch();
// Create and build the container
var container = new Ninject.StandardKernel();
container.Bind <IFileProcessorRepository>().To(typeof(FileProcessorRepository)).InTransientScope();
container.Bind <DistributedPubSub>().ToConstant(DistributedPubSub.Get(SystemActors.ClusterSystem));
// Create the dependency resolver for the actor system
IDependencyResolver resolver = new NinjectDependencyResolver(container, SystemActors.ClusterSystem);
var pbm = PetabridgeCmd.Get(SystemActors.ClusterSystem);
pbm.RegisterCommandPalette(ClusterCommands.Instance); // enable cluster management commands
pbm.Start();
SystemActors.SettingsWatcherRef = SystemActors.ClusterSystem.ActorOf(SystemActors.ClusterSystem.DI().Props <DatabaseWatcherActor>(), "DatabaseWatcher");
SystemActors.Mediator = DistributedPubSub.Get(SystemActors.ClusterSystem).Mediator;
SystemActors.LocationManagerActorRef = SystemActors.ClusterSystem.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new LocationManagerActor()), // Props used to create actor singleton
terminationMessage: PoisonPill.Instance, // message used to stop actor gracefully
settings: ClusterSingletonManagerSettings.Create(SystemActors.ClusterSystem).WithRole(StaticMethods.GetServiceWorkerRole())), // cluster singleton manager settings
name: ActorPaths.SingletonManagerActor.Name);
SystemActors.LocationManagerProxyRef = SystemActors.ClusterSystem.ActorOf(ClusterSingletonProxy.Props(
singletonManagerPath: ActorPaths.SingletonManagerActor.Path,
settings: ClusterSingletonProxySettings.Create(SystemActors.ClusterSystem).WithRole(StaticMethods.GetServiceWorkerRole())),
name: ActorPaths.SingletonManagerProxy.Name);
}
static void Main(string[] args)
{
using (var system = ActorSystem.Create("sharded-cluster-system", ConfigurationFactory.Load().WithFallback(ClusterSingletonManager.DefaultConfig())))
{
var automaticCluster = new AutomaticCluster(system);
try
{
automaticCluster.Join();
RunExample(system);
Console.ReadLine();
}
finally
{
//WARNING: you may need to remove SQLite database file from bin/Debug or bin/Release in case when unexpected crash happened
automaticCluster.Leave();
}
}
}
static async Task Main(string[] args)
{
var myPort = int.Parse(args[0]);
var portConfig = ConfigurationFactory.ParseString($"akka.remote.dot-netty.tcp.port = {myPort}");
var config = ConfigurationFactory.ParseString(File.ReadAllText("app.conf")).WithFallback(portConfig);
using var system = ActorSystem.Create("MyCluster", config);
var broadcaster = system.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "broadcaster");
#region Echo singleton service example
system.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create <EchoService>(),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system)
), "echo-single");
var echoSingleton = new Lazy <IActorRef>(() =>
system.ActorOf(ClusterSingletonProxy.Props(singletonManagerPath: "/user/echo-single",
settings: ClusterSingletonProxySettings.Create(system)),
"echo-proxy"));
#endregion
var quit = false;
IActorRef echo = ActorRefs.Nobody;
while (!quit)
{
switch (Menu())
{
case '1':
echo = system.ActorOf(Props.Create(typeof(EchoService)).WithRouter(FromConfig.Instance), "echo");
Console.WriteLine("Echo service is created.");
break;
case '2':
Console.Write("Input: ");
echo.Tell(Console.ReadLine());
break;
case '3':
Console.Write("Broadcast: ");
broadcaster.Tell(Console.ReadLine());
break;
case '4':
Console.Write("To singleton: ");
echoSingleton.Value.Tell(Console.ReadLine());
break;
case 'Q':
quit = true;
break;
}
}
await CoordinatedShutdown.Get(system).Run(CoordinatedShutdown.ClusterLeavingReason.Instance);
Console.WriteLine("End..");
}
public ClusterShardingSpecConfig(/*string entityRecoveryStrategy*/)
{
Controller = Role("controller");
First = Role("first");
Second = Role("second");
Third = Role("third");
Fourth = Role("fourth");
Fifth = Role("fifth");
Sixth = Role("sixth");
CommonConfig = DebugConfig(false)
.WithFallback(ConfigurationFactory.ParseString(@"
akka.actor {
serializers {
hyperion = ""Akka.Serialization.HyperionSerializer, Akka.Serialization.Hyperion""
}
serialization-bindings {
""System.Object"" = hyperion
}
}
akka.cluster.auto-down-unreachable-after = 0s
akka.cluster.roles = [""backend""]
akka.cluster.sharding {
retry-interval = 1 s
handoff-timeout = 10 s
shard-start-timeout = 5s
entity-restart-backoff = 1s
rebalance-interval = 2 s
entity-recovery-strategy = ""all""
entity-recovery-constant-rate-strategy {
frequency = 1 ms
number-of-entities = 1
}
least-shard-allocation-strategy {
rebalance-threshold = 2
max-simultaneous-rebalance = 1
}
}
akka.testconductor.barrier-timeout = 70s
akka.persistence.snapshot-store.plugin = ""akka.persistence.snapshot-store.inmem""
akka.persistence.journal.plugin = ""akka.persistence.journal.memory-journal-shared""
akka.persistence.journal.MemoryJournal {
class = ""Akka.Persistence.Journal.MemoryJournal, Akka.Persistence""
plugin-dispatcher = ""akka.actor.default-dispatcher""
}
akka.persistence.journal.memory-journal-shared {
class = ""Akka.Cluster.Sharding.Tests.MemoryJournalShared, Akka.Cluster.Sharding.Tests.MultiNode""
plugin-dispatcher = ""akka.actor.default-dispatcher""
timeout = 5s
}
"))
.WithFallback(Sharding.ClusterSharding.DefaultConfig())
.WithFallback(ClusterSingletonManager.DefaultConfig())
.WithFallback(MultiNodeClusterSpec.ClusterConfig());
NodeConfig(new[] { Sixth }, new[] { ConfigurationFactory.ParseString(@"akka.cluster.roles = [""frontend""]") });
}
internal static Config GetConfig(int port, string role)
{
var systemConfigString = SystemConfigString.Replace("PORT", port.ToString()).Replace("ROLE", role);
return(ConfigurationFactory.ParseString(systemConfigString).WithFallback(ClusterSingletonManager.DefaultConfig()));
}
/// <summary>
/// TBD
/// </summary>
public ClusterShardingGuardian()
{
Receive <Start>(start =>
{
try
{
var settings = start.Settings;
var encName = Uri.EscapeDataString(start.TypeName);
var coordinatorSingletonManagerName = CoordinatorSingletonManagerName(encName);
var coordinatorPath = CoordinatorPath(encName);
var shardRegion = Context.Child(encName);
var replicator = Replicator(settings);
if (Equals(shardRegion, ActorRefs.Nobody))
{
if (Equals(Context.Child(coordinatorSingletonManagerName), ActorRefs.Nobody))
{
var minBackoff = settings.TunningParameters.CoordinatorFailureBackoff;
var maxBackoff = new TimeSpan(minBackoff.Ticks * 5);
var coordinatorProps = settings.StateStoreMode == StateStoreMode.Persistence
? PersistentShardCoordinator.Props(start.TypeName, settings, start.AllocationStrategy)
: DDataShardCoordinator.Props(start.TypeName, settings, start.AllocationStrategy, replicator, _majorityMinCap, settings.RememberEntities);
var singletonProps = BackoffSupervisor.Props(coordinatorProps, "coordinator", minBackoff, maxBackoff, 0.2).WithDeploy(Deploy.Local);
var singletonSettings = settings.CoordinatorSingletonSettings.WithSingletonName("singleton").WithRole(settings.Role);
Context.ActorOf(ClusterSingletonManager.Props(singletonProps, PoisonPill.Instance, singletonSettings).WithDispatcher(Context.Props.Dispatcher), coordinatorSingletonManagerName);
}
shardRegion = Context.ActorOf(ShardRegion.Props(
typeName: start.TypeName,
entityProps: start.EntityProps,
settings: settings,
coordinatorPath: coordinatorPath,
extractEntityId: start.ExtractEntityId,
extractShardId: start.ExtractShardId,
handOffStopMessage: start.HandOffStopMessage,
replicator: replicator,
majorityMinCap: _majorityMinCap).WithDispatcher(Context.Props.Dispatcher), encName);
}
Sender.Tell(new Started(shardRegion));
}
catch (Exception ex)
{
//TODO: JVM version matches NonFatal. Can / should we do something similar?
// don't restart
// could be invalid ReplicatorSettings, or InvalidActorNameException
// if it has already been started
Sender.Tell(new Status.Failure(ex));
}
});
Receive <StartProxy>(startProxy =>
{
try
{
var settings = startProxy.Settings;
var encName = Uri.EscapeDataString(startProxy.TypeName);
var coordinatorSingletonManagerName = CoordinatorSingletonManagerName(encName);
var coordinatorPath = CoordinatorPath(encName);
var shardRegion = Context.Child(encName);
var replicator = Replicator(settings);
if (Equals(shardRegion, ActorRefs.Nobody))
{
shardRegion = Context.ActorOf(ShardRegion.ProxyProps(
typeName: startProxy.TypeName,
settings: settings,
coordinatorPath: coordinatorPath,
extractEntityId: startProxy.ExtractEntityId,
extractShardId: startProxy.ExtractShardId,
replicator: replicator,
majorityMinCap: _majorityMinCap).WithDispatcher(Context.Props.Dispatcher), encName);
}
Sender.Tell(new Started(shardRegion));
}
catch (Exception ex)
{
//TODO: JVM version matches NonFatal. Can / should we do something similar?
// don't restart
// could be InvalidActorNameException if it has already been started
Sender.Tell(new Status.Failure(ex));
}
});
}
/// <summary>
/// Creates cluster singleton actor from config
/// </summary>
/// <param name="context">Current actor context (will create child actor)</param>
/// <param name="actorConfig">Configuration to create from</param>
/// <param name="currentPath">Parent (current) actor path</param>
/// <param name="pathName">New actor's path name</param>
protected virtual void CreateSingletonActor(
IActorContext context,
Config actorConfig,
string currentPath,
string pathName)
{
var childTypeName = actorConfig.GetString("type");
if (string.IsNullOrWhiteSpace(childTypeName))
{
return;
}
var type = Type.GetType(childTypeName);
if (type == null)
{
context.GetLogger()
.Error(
"{Type}: {ClassTypeString} was not found for actor {NameSpaceName}/{PathString}",
typeof(NameSpaceActor).Name,
childTypeName,
currentPath,
pathName);
return;
}
var singletonName = actorConfig.GetString("singleton-name");
if (string.IsNullOrEmpty(singletonName))
{
context.GetLogger()
.Error(
"{Type}: singleton-name was not defined for{NameSpaceName}/ {PathString}",
typeof(NameSpaceActor).Name,
currentPath,
pathName);
return;
}
var role = actorConfig.GetString("singleton-node-role");
if (string.IsNullOrEmpty(role))
{
context.GetLogger()
.Error(
"{Type}: singleton-node-role was not defined for {NameSpaceName}/{PathString}",
typeof(NameSpaceActor).Name,
currentPath,
pathName);
return;
}
context.GetLogger()
.Info(
"{Type}: {NameSpaceName} initializing singleton {SingletonName} of type {ActorType} on {PathString}",
typeof(NameSpaceActor).Name,
currentPath,
singletonName,
type.Name,
pathName);
context.ActorOf(
ClusterSingletonManager.Props(
context.System.DI().Props(type),
new ClusterSingletonManagerSettings(
singletonName,
role,
actorConfig.GetTimeSpan("removal-margin", TimeSpan.FromSeconds(1), false),
actorConfig.GetTimeSpan("handover-retry-interval", TimeSpan.FromSeconds(5), false))),
pathName);
}
