private void CreateCoordinator()
{
var typeNames = new[]
{
"counter", "rebalancingCounter", "PersistentCounterEntities", "AnotherPersistentCounter",
"PersistentCounter", "RebalancingPersistentCounter", "AutoMigrateRegionTest"
};
foreach (var typeName in typeNames)
{
var rebalanceEnabled = string.Equals(typeName, "rebalancing", StringComparison.InvariantCultureIgnoreCase);
var singletonProps = Props.Create(() => new BackoffSupervisor(
CoordinatorProps(typeName, rebalanceEnabled),
"coordinator",
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(5),
0.1)).WithDeploy(Deploy.Local);
Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps,
PoisonPill.Instance,
ClusterSingletonManagerSettings.Create(Sys)),
typeName + "Coordinator");
}
}
/// <summary>
/// Static factory method for creating the a singleton manager and proxy
/// of the <see cref="ClusterCommandActor"/>
/// </summary>
/// <param name="system">The <see cref="ActorSystem"/>within which to create the singleton</param>
/// <returns>A tuple containing <see cref="Props"/> for the proxy and manager in a given system</returns>
public static (Props proxy, Props manager) CreateSingleton(ActorSystem system, string role)
{
var managerSettings = ClusterSingletonManagerSettings
.Create(system)
.WithSingletonName("cluster-command")
.WithRemovalMargin(TimeSpan.FromSeconds(2))
.WithHandOverRetryInterval(TimeSpan.FromMilliseconds(200));
managerSettings = role != null?managerSettings.WithRole(role) : managerSettings;
var proxySettings = ClusterSingletonProxySettings
.Create(system)
.WithSingletonName("cluster-command-proxy")
.WithBufferSize(1000);
proxySettings = role != null?proxySettings.WithRole(role) : proxySettings;
var manager = ClusterSingletonManager.Props(
Props.Create(() => new ClusterCommandActor()),
PoisonPill.Instance,
managerSettings
);
var proxy = ClusterSingletonProxy.Props(
"/user/cluster-command",
proxySettings
);
return(proxy : proxy, manager : manager);
}
private static async Task Main()
{
Console.WriteLine("Starting sender system...");
var system = ActorSystem.Create("ClusterSys", ConfigurationFactory.ParseString(File.ReadAllText("Akka.hocon")));
Console.ReadKey();
system.ActorOf(ClusterSingletonManager.Props(
Props.Create <SingletonActor>(),
PoisonPill.Instance,
ClusterSingletonManagerSettings.Create(system).WithRole("b")
), "single");
system.ActorOf(ClusterSingletonProxy.Props("/user/single",
ClusterSingletonProxySettings.Create(system).WithRole("b")),
"singleProxy").Tell("Hello to singletone!");
var message = "initial message";
var mediator = DistributedPubSub.Get(system).Mediator;
mediator.Tell(new Send("/user/invoker", "Remote hello to singleton!"));
while (!message.Equals("Stop"))
{
Console.WriteLine("New message:");
message = Console.ReadLine();
mediator.Tell(new Send("/user/ping", message, false));
}
Console.WriteLine("Terminating system.");
await system.Terminate();
Console.WriteLine("Bye...");
}
private void CreateCoordinator()
{
var typeNames = new[]
{
"counter", "rebalancingCounter", "RememberCounterEntities", "AnotherRememberCounter",
"RememberCounter", "RebalancingRememberCounter", "AutoMigrateRememberRegionTest"
};
foreach (var typeName in typeNames)
{
var rebalanceEnabled = typeName.ToLowerInvariant().StartsWith("rebalancing");
var rememberEnabled = typeName.ToLowerInvariant().Contains("remember");
var singletonProps = BackoffSupervisor.Props(
CoordinatorProps(typeName, rebalanceEnabled, rememberEnabled),
"coordinator",
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(5),
0.1).WithDeploy(Deploy.Local);
Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps,
PoisonPill.Instance,
ClusterSingletonManagerSettings.Create(Sys)),
typeName + "Coordinator");
}
}
public void ClusterSingleton_with_lease_should_stop_singleton_if_the_lease_fails_periodic_check()
{
var lifecycleProbe = CreateTestProbe();
var settings = NextSettings();
Sys.ActorOf(
ClusterSingletonManager.Props(Props.Create(() => new ImportantSingleton(lifecycleProbe.Ref)), PoisonPill.Instance, settings),
settings.SingletonName);
TestLease testLease = null;
AwaitAssert(() =>
{
testLease = testLeaseExt.GetTestLease(LeaseNameFor(settings));
}); // allow singleton manager to create the lease
testLease.Probe.ExpectMsg(new TestLease.AcquireReq(leaseOwner));
testLease.InitialPromise.SetResult(true);
lifecycleProbe.ExpectMsg("preStart");
var callback = testLease.GetCurrentCallback();
callback(null);
lifecycleProbe.ExpectMsg("postStop");
testLease.Probe.ExpectMsg(new TestLease.ReleaseReq(leaseOwner));
// should try and reacquire lease
testLease.Probe.ExpectMsg(new TestLease.AcquireReq(leaseOwner));
lifecycleProbe.ExpectMsg("preStart");
}
public static DeploymentManager InitDeploymentManager(ActorSystem actorSystem, IMongoClient client, DataTransferManager manager, RepositoryApi api)
{
var repo = ClusterSingletonManager.Props(Props.Create(() => new DeploymentServerImpl(client, manager, api)),
ClusterSingletonManagerSettings.Create(actorSystem).WithRole("UpdateSystem"));
return(new DeploymentManager(actorSystem.ActorOf(repo, DeploymentApi.DeploymentPath)));
}
public static RepositoryManager InitRepositoryManager(ActorSystem actorSystem, IMongoClient client, DataTransferManager tranferManager)
{
var repo = ClusterSingletonManager.Props(Props.Create(() => new RepositoryManagerImpl(client, tranferManager)),
ClusterSingletonManagerSettings.Create(actorSystem).WithRole("UpdateSystem"));
return(new RepositoryManager(actorSystem.ActorOf(repo, RepositoryApi.RepositoryPath)));
}
public static ClusterStartupTask Apply(
ActorSystem system, string taskName,
Func <Task <Done> > task, TimeSpan taskTimeout,
Option <string> role, TimeSpan minBackoff,
TimeSpan maxBackoff, double randomBackoffFactor)
{
var startupTaskProps = Akka.Actor.Props.Create(
() => new ClusterStartupTaskActor(
task, taskTimeout
)
);
var backoffProps = BackoffSupervisor.PropsWithSupervisorStrategy(
startupTaskProps, taskName, minBackoff, maxBackoff, randomBackoffFactor, SupervisorStrategy.StoppingStrategy
);
var singletonProps = ClusterSingletonManager.Props(
backoffProps, PoisonPill.Instance, ClusterSingletonManagerSettings.Create(system)
);
var singleton = system.ActorOf(singletonProps, $"{taskName}-singleton");
var singletonProxy = system.ActorOf(
ClusterSingletonProxy.Props(
singletonManagerPath: singleton.Path.ToStringWithoutAddress(),
settings: ClusterSingletonProxySettings.Create(system).WithRole(role.Value)
),
$"{taskName}-singletonProxy"
);
return(new ClusterStartupTask(singletonProxy));
}
public static void Main(string[] args)
{
if (!int.TryParse(args[0], out var nodeId))
{
Console.Error.WriteLine("Please supply a node ID");
return;
}
var config = GetAkkaConfig(nodeId);
using (var system = ActorSystem.Create("demo-cluster", config))
{
var cmd = PetabridgeCmd.Get(system);
cmd.RegisterCommandPalette(ClusterCommands.Instance);
cmd.Start();
system.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create <SenderActor>(),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system)),
name: "sender");
var props = Props.Create <ReceiverActor>().WithRouter(FromConfig.Instance);
system.ActorOf(props, "receivers");
Console.ReadLine();
}
}
public void ClusterSingleton_with_lease_should_retry_trying_to_get_lease_if_acquire_returns_fails()
{
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
testLease.Probe.ExpectMsg(new TestLease.AcquireReq(leaseOwner));
singletonProbe.ExpectNoMsg(shortDuration);
TaskCompletionSource <bool> nextResponse = new TaskCompletionSource <bool>();
testLease.SetNextAcquireResult(nextResponse.Task);
testLease.InitialPromise.SetException(new TestException("no lease for you"));
testLease.Probe.ExpectMsg(new TestLease.AcquireReq(leaseOwner));
singletonProbe.ExpectNoMsg(shortDuration);
nextResponse.SetResult(true);
singletonProbe.ExpectMsg("preStart");
}
public static IActorRef BootstrapSingleton <T>(this ActorSystem system, string name, string role = null) where T : ActorBase
{
var props = ClusterSingletonManager.Props(
singletonProps: Props.Create <T>(),
settings: new ClusterSingletonManagerSettings(name, role, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(3)));
return(system.ActorOf(props, typeof(T).Name));
}
public static IActorRef BootstrapSingleton <T>(this ActorSystem system, string role = null) where T : ActorBase
{
var props = ClusterSingletonManager.Props(
singletonProps: Props.Create <T>(),
settings: ClusterSingletonManagerSettings.Create(system).WithRole(role));
return(system.ActorOf(props, typeof(T).Name));
}
private IActorRef CreateSingleton()
{
return(Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new EchoActor(TestActor)),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(Sys)),
name: "echo"));
}
private IActorRef CreateSingleton()
{
return(Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps: ClusterSingletonManagerDownedSpecConfig.Echo.Props(TestActor),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(Sys)),
name: "echo"));
}
protected override void ConfigImpl()
{
Context.ActorOf(ClusterSingletonManager.Props(ConfigurationManagerActor.New(CurrentState.Repository),
ClusterSingletonManagerSettings.Create(Context.System)
.WithRole(RoleName)), "ConfigurationManager");
SupervisorStrategy = SupervisorStrategy.DefaultStrategy;
}
/// <summary>
/// Initializes cluster singleton of the <see cref="WorkerManager"/> actor.
/// </summary>
/// <param name="system"></param>
static void RunClusterSingletonSeed(ActorSystem system)
{
var aref = system.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new WorkerManager()),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system)),
name: "manager");
}
private void CreateSingleton()
{
Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new Consumer(Queue, TestActor)),
terminationMessage: Consumer.End.Instance,
settings: ClusterSingletonManagerSettings.Create(Sys).WithRole("worker")),
name: "consumer");
}
public Props ManagerProps(ActorSystem system, Props childProps)
{
return(ClusterSingletonManager.Props(
childProps,
PoisonPill.Instance,
ManagerSettings(system)
));
}
private IActorRef CreateSingleton()
{
return(Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps: ClusterSingletonManagerLeaveSpecConfig.Echo.Props(TestActor),
terminationMessage: "stop",
settings: ClusterSingletonManagerSettings.Create(Sys)),
name: "echo"));
}
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(ClusterSharding.DefaultConfig())
.WithFallback(DistributedPubSub.DefaultConfig());
var actorSystem = ActorSystem.Create("AkkaPricing", conf.BootstrapFromDocker());
var readJournal = actorSystem.ReadJournalFor <MongoDbReadJournal>(MongoDbReadJournal.Identifier);
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")));
var mediator = DistributedPubSub.Get(actorSystem).Mediator;
foreach (var stock in AvailableTickerSymbols.Symbols)
{
actorSystem.ActorOf(Props.Create(() => new PriceVolumeViewActor(stock, shardRegion, mediator)),
stock + "-view");
}
});
// start Petabridge.Cmd (for external monitoring / supervision)
var pbm = PetabridgeCmd.Get(actorSystem);
pbm.RegisterCommandPalette(ClusterCommands.Instance);
pbm.RegisterCommandPalette(ClusterShardingCommands.Instance);
pbm.RegisterCommandPalette(RemoteCommands.Instance);
pbm.Start();
actorSystem.WhenTerminated.Wait();
return(0);
}
static int Main(string[] args)
{
var config = File.ReadAllText("app.conf");
var conf = ConfigurationFactory.ParseString(config);
var actorSystem = ActorSystem.Create("AkkaTrader", conf.BoostrapApplication(new AppBootstrapConfig(true, true)));
var sharding = ClusterSharding.Get(actorSystem);
var shardRegion = sharding.Start("priceAggregator",
s => Props.Create(() => new MatchAggregator(s)),
ClusterShardingSettings.Create(actorSystem),
new StockShardMsgRouter());
var priceInitiatorActor = actorSystem.ActorOf(ClusterSingletonManager.Props(Props.Create(() => new PriceInitiatorActor(shardRegion)),
ClusterSingletonManagerSettings.Create(actorSystem).WithRole("pricing-engine").WithSingletonName("priceInitiator")), "priceInitiator");
var clientHandler =
actorSystem.ActorOf(Props.Create(() => new ClientHandlerActor(shardRegion)), "subscriptions");
// make ourselves available to ClusterClient at /user/subscriptions
ClusterClientReceptionist.Get(actorSystem).RegisterService(clientHandler);
Cluster.Cluster.Get(actorSystem).RegisterOnMemberUp(() =>
{
foreach (var ticker in AvailableTickerSymbols.Symbols)
{
shardRegion.Tell(new Ping(ticker));
}
});
// 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(shardRegion));
pbm.Start();
actorSystem.WhenTerminated.Wait();
return(0);
}
static void Main()
{
var config = ConfigurationFactory.ParseString(configString).WithFallback(ClusterSingletonManager.DefaultConfig());
var system = ActorSystem.Create("cluster-system", config);
var server = system.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create <Server>(),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system).WithRole("worker")),
name: "consumer");
Console.ReadKey();
}
static void Main(string[] args)
{
var config = ConfigurationFactory.ParseString(File.ReadAllText("App.Akka.conf"));
//
// "{app-name} - akka.tcp://{actorysystem-name}@{hostname}:{port}"
//
Console.Title = $"{config.GetString("akka.system.app-name")}" +
$" - akka.tcp://{config.GetString("akka.system.actorsystem-name")}" +
$"@{config.GetString("akka.remote.dot-netty.tcp.hostname")}" +
$":{config.GetString("akka.remote.dot-netty.tcp.port")}";
ActorSystem system = ActorSystem.Create("ClusterLab", config);
system.ActorOf(ClusterSingletonManager
.Props(
singletonProps: MySingletonActor.Props(),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system)
.WithRole("Provider")),
name: "ConsumerSingleton");
IActorRef singletonProxyActor = system.ActorOf(ClusterSingletonProxy
.Props(
singletonManagerPath: "/user/ConsumerSingleton",
settings: ClusterSingletonProxySettings.Create(system)
.WithRole("Provider")),
name: "ConsumerProxy");
system.Scheduler.ScheduleTellRepeatedly(
TimeSpan.Zero,
TimeSpan.FromSeconds(4),
singletonProxyActor,
$"Message from process {Process.GetCurrentProcess().Id}",
Nobody.Instance);
//
// TODO ClusterSingletonManagerSettings 세부 설정
// - WithHandOverRetryInterval
// - WithRemovalMargin
// - WithRole
// - WithSingletonName
//
Console.WriteLine();
Console.WriteLine("NonSeedNode1 is running...");
Console.WriteLine();
Console.ReadLine();
}
public void RegisterOnMemberUp()
{
Console.WriteLine(cluster.SelfAddress + "上线.....");
var clusterSingletonManagerProps = ClusterSingletonManager.Props(
singletonProps: SingleActor.CreateProps(this.actorSystem).WithRouter(new Akka.Routing.RoundRobinPool(5)),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(ActorSystem));
var singlet = ActorSystem.ActorOf(clusterSingletonManagerProps, name: "singletonManager");
Console.WriteLine("singletonManager:{0}", singlet.Path.ToString());
}
public void InitializeClusterSystem()
{
Program.ClusterSystem = ActorSystemFactory.LaunchClusterManager();
GlobalContext.Properties["ipaddress"] = AppSettings.GetIpAddressFromConfig();
Program.ClusterHelper = Program.ClusterSystem.ActorOf(Props.Create(() => new ClusterHelper()), ActorPaths.ClusterHelperActor.Name);
Program.ClusterSystem.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new JobManager()), // Props used to create actor singleton
terminationMessage: PoisonPill.Instance, // message used to stop actor gracefully
settings: ClusterSingletonManagerSettings.Create(Program.ClusterSystem).WithRole("worker")), // cluster singleton manager settings
name: "jobmanager");
}
public ClusterShardingGuardian()
{
Receive <Start>(start =>
{
var settings = start.Settings;
var encName = Uri.EscapeDataString(start.TypeName);
var coordinatorSingletonManagerName = CoordinatorSingletonManagerName(encName);
var coordinatorPath = CoordinatorPath(encName);
var shardRegion = Context.Child(encName);
if (Equals(shardRegion, ActorRefs.Nobody))
{
var minBackoff = settings.TunningParameters.CoordinatorFailureBackoff;
var maxBackoff = new TimeSpan(minBackoff.Ticks * 5);
var coordinatorProps = PersistentShardCoordinator.Props(start.TypeName, settings, start.AllocationStrategy);
var singletonProps = Props.Create(() => new BackoffSupervisor(coordinatorProps, "coordinator", minBackoff, maxBackoff, 0.2)).WithDeploy(Deploy.Local);
var singletonSettings = settings.CoordinatorSingletonSettings.WithSingletonName("singleton").WithRole(settings.Role);
var shardCoordinatorSingleton = Context.ActorOf(ClusterSingletonManager.Props(singletonProps, PoisonPill.Instance, singletonSettings), coordinatorSingletonManagerName);
}
shardRegion = Context.ActorOf(ShardRegion.Props(
typeName: start.TypeName,
entityProps: start.EntityProps,
settings: settings,
coordinatorPath: coordinatorPath,
extractEntityId: start.IdExtractor,
extractShardId: start.ShardResolver,
handOffStopMessage: start.HandOffStopMessage), encName);
Sender.Tell(new Started(shardRegion));
});
Receive <StartProxy>(startProxy =>
{
var settings = startProxy.Settings;
var encName = Uri.EscapeDataString(startProxy.TypeName);
var coordinatorSingletonManagerName = CoordinatorSingletonManagerName(encName);
var coordinatorPath = CoordinatorPath(encName);
var shardRegion = Context.ActorOf(ShardRegion.ProxyProps(
typeName: startProxy.TypeName,
settings: settings,
coordinatorPath: coordinatorPath,
extractEntityId: startProxy.ExtractEntityId,
extractShardId: startProxy.ExtractShardId), encName);
Sender.Tell(new Started(shardRegion));
});
}
private IActorRef CreateSingleton()
{
/**
* system.actorOf(ClusterSingletonManager.props(
* singletonProps = Props(classOf[Echo], testActor),
* terminationMessage = PoisonPill,
* settings = ClusterSingletonManagerSettings(system)),
* name = "echo")
*/
return(Sys.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new Echo(TestActor)),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(Sys)),
name: "echo"));
}
static void Main()
{
var config = ConfigurationFactory.ParseString(configString).WithFallback(ClusterSingletonManager.DefaultConfig());
var system = ActorSystem.Create("cluster-system", config);
var server = system.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create <Server>(),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system).WithRole("worker")),
name: "consumer");
Thread.Sleep(10000);
var s = Address.Parse("akka.tcp://cluster-system@localhost:5001/");
Cluster.Get(system).Leave(s);
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Hello from MemoryWallet!");
var system = DI.Provider.GetService <ActorSystem>();
var logger = system.Log;
logger.Info($"Joining cluster {system.Name}");
// Singleton actor that keeps book of record of a player
system.ActorOf(ClusterSingletonManager.Props(
singletonProps: PlayerBook.Props(),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(system).WithRole("player-manager")
), "playerbook");
system.ActorOf(ClusterSingletonProxy.Props(
singletonManagerPath: "/user/playerbook",
settings: ClusterSingletonProxySettings.Create(system)
.WithRole("player-manager")),
name: "playerbook-proxy");
// Register web hub across cluster
var hub = system.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "hub");
// create local player manager instances with router.
var pm = system.ActorOf(PlayerManagerActor.Props(), "player-manager");
// var pm = system.ActorOf(
// PlayerManagerActor.Props().WithRouter(FromConfig.Instance),
// "player-manager");
hub.Tell("dsadsada");
pm.Tell(new PlayerManagerActor.HelloWorld("hello world"));
logger.Info($"{pm.Path} created.");
Console.ReadLine();
CoordinatedShutdown.Get(system)
.Run(CoordinatedShutdown.ClrExitReason.Instance)
.Wait();
}
public Task StartAsync(CancellationToken cancellationToken)
{
var config = ConfigurationFactory.ParseString(File.ReadAllText("app.conf")).BootstrapFromDocker();
var bootstrap = BootstrapSetup.Create()
.WithConfig(config) // load HOCON
.WithActorRefProvider(ProviderSelection.Cluster.Instance); // launch Akka.Cluster
// N.B. `WithActorRefProvider` isn't actually needed here - the HOCON file already specifies Akka.Cluster
// enable DI support inside this ActorSystem, if needed
var diSetup = ServiceProviderSetup.Create(_serviceProvider);
// merge this setup (and any others) together into ActorSystemSetup
var actorSystemSetup = bootstrap.And(diSetup);
ThreadPool.GetMinThreads(out var workerThreads, out var completionThreads);
Console.WriteLine("Min threads: {0}, Min I/O threads: {1}", workerThreads, completionThreads);
ThreadPool.SetMinThreads(0, 0);
// start ActorSystem
_clusterSystem = ActorSystem.Create("ClusterSys", actorSystemSetup);
DebugConfigurator("akka.actor.default-dispatcher", _clusterSystem);
DebugConfigurator("akka.actor.internal-dispatcher", _clusterSystem);
DebugConfigurator("akka.remote.default-remote-dispatcher", _clusterSystem);
DebugConfigurator("akka.remote.backoff-remote-dispatcher", _clusterSystem);
// instantiate actors
BenchmarkHostRouter = _clusterSystem.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "host-router");
BenchmarkCoordinatorManager = _clusterSystem.ActorOf(ClusterSingletonManager.Props(
singletonProps: Props.Create(() => new BenchmarkCoordinator(2, 6, BenchmarkHostRouter)),
terminationMessage: PoisonPill.Instance,
settings: ClusterSingletonManagerSettings.Create(_clusterSystem)), "coordinator");
BenchmarkCoordinator = _clusterSystem.ActorOf(ClusterSingletonProxy.Props(
singletonManagerPath: "/user/coordinator",
settings: ClusterSingletonProxySettings.Create(_clusterSystem)), "coordinator-proxy");
BenchmarkHost = _clusterSystem.ActorOf(Props.Create(() => new BenchmarkHost(BenchmarkCoordinator)), "host");
Akka.Cluster.Cluster.Get(_clusterSystem).RegisterOnMemberRemoved(() => {
_lifetime.StopApplication(); // when the ActorSystem terminates, terminate the process
});
return(Task.CompletedTask);
}
