private void ClusterClient_must_startup_cluster_with_single_node() { Within(TimeSpan.FromSeconds(30), () => { Join(_config.First, _config.First); RunOn(() => { var service = Sys.ActorOf(EchoActor.Props(this), "testService"); ClusterClientReceptionist.Get(Sys).RegisterService(service); AwaitMembersUp(1); }, _config.First); EnterBarrier("cluster-started"); }); }
public void ClusterClient_must_demonstrate_usage() { var host1 = _config.First; var host2 = _config.Second; var host3 = _config.Third; Within(15.Seconds(), () => { //#server RunOn(() => { var serviceA = Sys.ActorOf(Props.Create <ClusterClientSpecConfig.Service>(), "serviceA"); ClusterClientReceptionist.Get(Sys).RegisterService(serviceA); }, host1); RunOn(() => { var serviceB = Sys.ActorOf(Props.Create <ClusterClientSpecConfig.Service>(), "serviceB"); ClusterClientReceptionist.Get(Sys).RegisterService(serviceB); }, host2, host3); //#server RunOn(() => { AwaitCount(4); }, host1, host2, host3, _config.Fourth); EnterBarrier("services-replicated"); //#client RunOn(() => { var c = Sys.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client"); c.Tell(new ClusterClient.Send("/user/serviceA", "hello", localAffinity: true)); c.Tell(new ClusterClient.SendToAll("/user/serviceB", "hi")); }, _config.Client); //#client RunOn(() => { // note that "hi" was sent to 2 "serviceB" var received = ReceiveN(3); received.ToImmutableHashSet().Should().BeEquivalentTo(ImmutableHashSet.Create("hello", "hi")); }, _config.Client); // strange, barriers fail without this sleep Thread.Sleep(1000); EnterBarrier("after-4"); }); }
public void ClusterClient_must_reestablish_connection_to_receptionist_after_server_restart() { Within(30.Seconds(), () => { RunOn(() => { _remainingServerRoleNames.Count.Should().Be(1); var remainingContacts = _remainingServerRoleNames.Select(r => Node(r) / "system" / "receptionist").ToImmutableHashSet(); var c = Sys.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(remainingContacts)), "client4"); c.Tell(new ClusterClient.Send("/user/service2", "bonjour4", localAffinity: true)); var reply = ExpectMsg <ClusterClientSpecConfig.Reply>(10.Seconds()); reply.Msg.Should().Be("bonjour4-ack"); reply.Node.Should().Be(remainingContacts.First().Address); // TODO: bug, cannot compare with a logsource var logSource = $"{Sys.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress}/user/client4"; EventFilter.Info(start: "Connected to").ExpectOne(() => { EventFilter.Info(start: "Lost contact").ExpectOne(() => { // shutdown server TestConductor.Shutdown(_remainingServerRoleNames.First()).Wait(); }); }); c.Tell(new ClusterClient.Send("/user/service2", "shutdown", localAffinity: true)); Thread.Sleep(2000); // to ensure that it is sent out before shutting down system }, _config.Client); RunOn(() => { Sys.WhenTerminated.Wait(20.Seconds()); // start new system on same port var port = Cluster.Get(Sys).SelfAddress.Port; var sys2 = ActorSystem.Create( Sys.Name, ConfigurationFactory.ParseString($"akka.remote.dot-netty.tcp.port={port}").WithFallback(Sys.Settings.Config)); Cluster.Get(sys2).Join(Cluster.Get(sys2).SelfAddress); var service2 = sys2.ActorOf(Props.Create(() => new ClusterClientSpecConfig.TestService(TestActor)), "service2"); ClusterClientReceptionist.Get(sys2).RegisterService(service2); sys2.WhenTerminated.Wait(20.Seconds()); }, _remainingServerRoleNames.ToArray()); }); }
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); }
public static void StartUp(string port) { var section = (AkkaConfigurationSection)ConfigurationManager.GetSection("akka"); //Override the configuration of the port var config = ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.port=" + port) .WithFallback(section.AkkaConfig); //create an Akka system var system = ActorSystem.Create("cluster-playground", config); //create an actor that handles cluster domain events var node = system.ActorOf(Node.MyProps(port), "node"); ClusterClientReceptionist.Get(system).RegisterService(node); system.WhenTerminated.Wait(); }
//[MultiNodeFact(Skip = "TODO")] public void ClusterClient_should_demonstrate_usage() { ClusterClient_should_communicate_to_any_node_in_cluster(); Within(TimeSpan.FromSeconds(15), () => { RunOn(() => { var serviceA = Sys.ActorOf(Props.Create <Service>(), "serviceA"); ClusterClientReceptionist.Get(Sys).RegisterService(serviceA); }, _first); RunOn(() => { var serviceB = Sys.ActorOf(Props.Create <Service>(), "serviceB"); ClusterClientReceptionist.Get(Sys).RegisterService(serviceB); }, _second, _third); RunOn(() => { AwaitCount(4); }, _first, _second, _third, _fourth); RunOn(() => { var c = Sys.ActorOf(Client.ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client"); c.Tell(new Client.ClusterClient.Send("/user/serviceA", "hello", localAffinity: true)); c.Tell(new Client.ClusterClient.SendToAll("/user/serviceB", "hi")); }, _client); RunOn(() => { // note that "hi" was sent to 2 "serviceB" var received = ReceiveN(3); Assert.True(received.Contains("hello")); Assert.True(received.Contains("hi")); }, _client); // strange, barriers fail without this sleep Thread.Sleep(1000); EnterBarrier("after-3"); }); }
protected override void PreStart() { base.PreStart(); _receptionistActor = ClusterClientReceptionist.Get(Context.System).Underlying; // // 이벤트 등록: SubscribeClusterClients.Instance // -> Receive<ClusterClients> // -> Receive<ClusterClientUp> // -> Receive<ClusterClientUnreachable > // 이벤트 제거: UnsubscribeClusterClients.Instance // // vs. // // 명시적 확인 : GetClusterClients.Instance // -> _receptionistActor.Tell(SubscribeClusterClients.Instance); }
public async Task StartAsync() { var setup = ActorSystemSetup.Create( BootstrapSetup.Create() .WithConfig(Util.Config(_port)) .WithConfigFallback(DistributedPubSub.DefaultConfig()) .WithConfigFallback(ClusterClientReceptionist.DefaultConfig()) .WithActorRefProvider(ProviderSelection.Cluster.Instance)); _actorSystem = ActorSystem.Create(Consts.NodeName, setup); var cluster = Akka.Cluster.Cluster.Get(_actorSystem); await cluster.JoinSeedNodesAsync(Consts.Seeds); _receptionist = ClusterClientReceptionist.Get(_actorSystem); foreach (var id in Enumerable.Range(_nodeId * Consts.ActorCount, Consts.ActorCount)) { var actor = _actorSystem.ActorOf(Props.Create(() => new ServiceActor(id)), Util.ActorName(id)); _receptionist.RegisterService(actor); } }
public void ClusterClient_must_startup_cluster() { Within(30.Seconds(), () => { Join(_config.First, _config.First); Join(_config.Second, _config.First); RunOn(() => { var service = Sys.ActorOf(Props.Create(() => new ClusterClientStopSpecConfig.Service()), "testService"); ClusterClientReceptionist.Get(Sys).RegisterService(service); }, _config.First); RunOn(() => { AwaitCount(1); }, _config.First, _config.Second); EnterBarrier("cluster-started"); }); }
static void Main(string[] args) { var port = args.Length > 0 ? int.Parse(args[0]) : 0; var section = (AkkaConfigurationSection)ConfigurationManager.GetSection("akka"); var config = ConfigurationFactory .ParseString($"akka.remote.dot-netty.tcp.port={port}") .WithFallback(section.AkkaConfig); using (var system = ActorSystem.Create("Cluster", config)) { Props props = Props.Create(() => new WorkerActor()); // Uocite da je receptionist takodjer IActorRef var service = system.ActorOf(props, "service"); //Retrieve the cluster receptionist extension var receptionist = ClusterClientReceptionist.Get(system); //Register the service with the cluster client receptionist.RegisterService(service); Console.ReadLine(); } }
//[MultiNodeFact(Skip = "TODO")] public void ClusterClient_should_startup_cluster() { Within(TimeSpan.FromSeconds(30), () => { Join(_first, _first); Join(_second, _first); Join(_third, _first); Join(_fourth, _first); RunOn(() => { var service = Sys.ActorOf(Props.Create(() => new TestService(TestActor)), "testService"); ClusterClientReceptionist.Get(Sys).RegisterService(service); }, _fourth); RunOn(() => { AwaitCount(1); }, _first, _second, _third, _fourth); EnterBarrier("after-1"); }); }
/// <summary> /// Starts a job, which establishes cluster client receptionist for target <see cref="EchoReceiver"/> actor, /// making it visible from outside of the cluster. /// </summary> static void RunClusterClientSeed(ActorSystem system) { var receptionist = ClusterClientReceptionist.Get(system); receptionist.RegisterService(system.ActorOf(Props.Create <EchoReceiver>(), "my-service")); }
protected override void PreStart() { var c = ClusterClientReceptionist.Get(Context.System); //c.RegisterService(Self); }
private void CreateReceptionist() { var x = ClusterClientReceptionist.Get(Sys); }
public void ClusterClient_must_report_events() { Within(15.Seconds(), () => { RunOn(() => { var c = Sys.ActorSelection("/user/client").ResolveOne(Dilated(1.Seconds())).Result; var l = Sys.ActorOf( Props.Create(() => new ClusterClientSpecConfig.TestClientListener(c)), "reporter-client-listener"); var expectedContacts = ImmutableHashSet.Create(_config.First, _config.Second, _config.Third, _config.Fourth) .Select(_ => Node(_) / "system" / "receptionist"); Within(10.Seconds(), () => { AwaitAssert(() => { var probe = CreateTestProbe(); l.Tell(ClusterClientSpecConfig.TestClientListener.GetLatestContactPoints.Instance, probe.Ref); probe.ExpectMsg <ClusterClientSpecConfig.TestClientListener.LatestContactPoints>() .ContactPoints.Should() .BeEquivalentTo(expectedContacts); }); }); }, _config.Client); EnterBarrier("reporter-client-listener-tested"); RunOn(() => { // Only run this test on a node that knows about our client. It could be that no node knows // but there isn't a means of expressing that at least one of the nodes needs to pass the test. var r = ClusterClientReceptionist.Get(Sys).Underlying; r.Tell(GetClusterClients.Instance); var cps = ExpectMsg <ClusterClients>(); if (cps.ClusterClientsList.Any(c => c.Path.Name.Equals("client"))) { Log.Info("Testing that the receptionist has just one client"); var l = Sys.ActorOf( Props.Create(() => new ClusterClientSpecConfig.TestReceptionistListener(r)), "reporter-receptionist-listener"); var c = Sys .ActorSelection(Node(_config.Client) / "user" / "client") .ResolveOne(Dilated(2.Seconds())).Result; var expectedClients = ImmutableHashSet.Create(c); Within(10.Seconds(), () => { AwaitAssert(() => { var probe = CreateTestProbe(); l.Tell(ClusterClientSpecConfig.TestReceptionistListener.GetLatestClusterClients.Instance, probe.Ref); // "ask-client" might still be around, filter probe.ExpectMsg <ClusterClientSpecConfig.TestReceptionistListener.LatestClusterClients>() .ClusterClients.Should() .Contain(expectedClients); }); }); } }, _config.First, _config.Second, _config.Third); EnterBarrier("after-5"); }); }
/// <summary> /// Creates a new actor system according to the supplied parameters and the /// "hub.hocon" file /// /// Assumed transport used is tcp /// </summary> /// <param name="systemName">System name</param> /// <param name="hostname">IP address or hostname</param> /// <param name="requestedPort">Non-zero port</param> /// <returns>The Actor System</returns> public static ActorSystem Create(string systemName, string hostname, int?requestedPort) { if (!File.Exists("hub.hocon")) { throw new FileLoadException($"Could not find 'hub.hocon' file in {Directory.GetCurrentDirectory()}"); } // Reads in the entire hocon configuration and parses to a Config object var configText = File.ReadAllText("hub.hocon"); var clusterConfig = ConfigurationFactory.ParseString(configText); // Find the "hub" specific configuration var hubConfig = clusterConfig.GetConfig("hub"); // Set the actor system name if supplied value is null or empty if (hubConfig != null && string.IsNullOrEmpty(systemName)) { systemName = hubConfig.GetString("actorsystem"); } var remoteConfig = clusterConfig.GetConfig("akka.remote"); if (string.IsNullOrEmpty(hostname)) { // Defaults to localhost as final step hostname = remoteConfig.GetString("dot-netty.tcp.public-hostname") ?? "127.0.0.1"; } int port = requestedPort ?? remoteConfig.GetInt("dot-netty.tcp.port"); if (port == 0) { throw new ConfigurationException("An explicit port must be specified for the Hub. Zero is unnacceptable."); } // Display configuration Log.Information($"[Cluster Hub] ActorSystem: {systemName}; IP: {hostname}; PORT: {port}"); Log.Information($"[Cluster Hub] Parsing address"); Log.Information("[Cluster Hub] Parse successful"); Log.Information("[Cluster Hub] Public hostname {PublicHubHostname}", hostname); var selfAddress = new Address("akka.tcp", systemName, hostname.Trim(), port).ToString(); var seeds = clusterConfig.GetStringList("akka.cluster.seed-nodes"); seeds.Add(selfAddress); var injectedClusterConfigString = seeds.Aggregate("akka.cluster.seed-nodes = [", (current, seed) => current + (@"""" + seed + @""",")); injectedClusterConfigString += "]"; var finalConfig = ConfigurationFactory.ParseString( string.Format("akka.remote.dot-netty.tcp.public-hostname = {0}, akka.remote.dot-netty.tcp.port = {1}", hostname, port) ) .WithFallback(ConfigurationFactory.ParseString(injectedClusterConfigString)) .WithFallback(clusterConfig); // Create the actor system var system = ActorSystem.Create(systemName, finalConfig); var proxySettings = ClusterSingletonProxySettings.Create(system).WithBufferSize(1000); var name = "manager"; // Create the cluster singleton proxy for the node manager var managerProxy = system.ActorOf( ClusterSingletonProxy.Props( singletonManagerPath: $"/user/{name}", settings: proxySettings ), $"{name}-proxy"); // Subscribe the forwarder to the client receptionist topic var forwarder = system.ActorOf(Props.Create(() => new PublisherActor("client-messages")), "forwarder"); ClusterClientReceptionist.Get(system).RegisterSubscriber("client-messages", forwarder); // ClusterClientReceptionist.Get(system).RegisterService(managerProxy); return(system); }
public void ClusterClient_must_reestablish_connection_to_another_receptionist_when_server_is_shutdown() { Within(30.Seconds(), () => { RunOn(() => { var service2 = Sys.ActorOf(Props.Create(() => new ClusterClientSpecConfig.TestService(TestActor)), "service2"); ClusterClientReceptionist.Get(Sys).RegisterService(service2); AwaitCount(8); }, _config.First, _config.Second, _config.Third, _config.Fourth); EnterBarrier("service2-replicated"); RunOn(() => { var c = Sys.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client2"); c.Tell(new ClusterClient.Send("/user/service2", "bonjour", localAffinity: true)); var reply = ExpectMsg <ClusterClientSpecConfig.Reply>(); reply.Msg.Should().Be("bonjour-ack"); RoleName receptionistRoleName = GetRoleName(reply.Node); if (receptionistRoleName == null) { throw new Exception("Unexpected missing role name: " + reply.Node); } TestConductor.Exit(receptionistRoleName, 0).Wait(); _remainingServerRoleNames = _remainingServerRoleNames.Remove(receptionistRoleName); Within(Remaining - 3.Seconds(), () => { AwaitAssert(() => { c.Tell(new ClusterClient.Send("/user/service2", "hi again", localAffinity: true)); ExpectMsg <ClusterClientSpecConfig.Reply>(1.Seconds()).Msg.Should().Be("hi again-ack"); }); }); Sys.Stop(c); }, _config.Client); EnterBarrier("verified-3"); ReceiveWhile(2.Seconds(), msg => { if (msg.Equals("hi again")) { return(msg); } else { throw new Exception("Unexpected message: " + msg); } }); EnterBarrier("verified-4"); RunOn(() => { // Locate the test listener from a previous test and see that it agrees // with what the client is telling it about what receptionists are alive var l = Sys.ActorSelection("/user/reporter-client-listener"); var expectedContacts = _remainingServerRoleNames.Select(c => Node(c) / "system" / "receptionist"); Within(10.Seconds(), () => { AwaitAssert(() => { var probe = CreateTestProbe(); l.Tell(ClusterClientSpecConfig.TestClientListener.GetLatestContactPoints.Instance, probe.Ref); probe.ExpectMsg <ClusterClientSpecConfig.TestClientListener.LatestContactPoints>() .ContactPoints.Should() .BeEquivalentTo(expectedContacts); }); }); }, _config.Client); EnterBarrier("after-4"); }); }