public void Start() { var system = ActorSystem.Create(Constants.ActorSystemName, ConfigurationFactory.Load().WithFallback(ClusterSingletonManager.DefaultConfig())); system.Settings.InjectTopLevelFallback(ClusterClientReceptionist.DefaultConfig()); var settings = ClusterClientSettings.Create(system); var client = system.ActorOf(ClusterClient.Props(settings), clientName); while (!shouldStop) { Console.WriteLine("Press key to send message"); Console.ReadKey(); client.Ask <ShardEnvelope>(new ClusterClient.Send("/user/sharding/MyActor", new ShardEnvelope(envelopeId, SendMessage) { FromClientId = clientId }), TimeSpan.FromSeconds(10)) .ContinueWith(se => { if (se.Status == TaskStatus.Canceled) { Logger.Warn("He ignored me:("); } else { Logger.Info($"Received response with EntityId: {se.Result.EntityId}, Message: {se.Result.Message}, from NodeId: {se.Result.FromNodeId}"); } }); } }
static void Main(string[] args) { var initialContacts = ImmutableHashSet <ActorPath> .Empty .Add(ActorPath.Parse("akka.tcp://Cluster@localhost:12000/system/receptionist")); //.Add(ActorPath.Parse("akka.tcp://ClusterClientExample@localhost:12001/user/service")); using (var system = ActorSystem.Create("ClusterClient")) { var clusterClientSettings = ClusterClientSettings.Create(system) .WithInitialContacts(initialContacts); // Creaste the Props used to deploy the cluster client on the local actor system var clusterClientProps = ClusterClient.Props(clusterClientSettings); //Deploy the cluster client into the local actor system //Ovaj dio je prebacen u actora kako bi vidjeli da mozemo iz bilo kojeg actora pristupiti nekom clusteru, // a ne samo iz actora stvorenih iz system.ActorOf //var clusterClient = system.ActorOf(clusterClientProps, "clusterClient"); //clusterClient.Tell(new ClusterClient.Send("/user/service", new Msg($"Hello from cluster client"))); var props = Props.Create(() => new ChatActor(clusterClientProps)); var actor = system.ActorOf(props); Console.ReadLine(); actor.Tell(new Init()); Console.ReadLine(); actor.Tell(new InitPub()); Console.ReadLine(); } }
private static void InitializeProgressSubscription() { string receptionistActorPath = string.Format("{3}://App-Cluster@{0}:{1}/system/{2}", AkkaDistributedHelper.GetFullyQualifiedDomainName(), Ports.Router, "receptionist", TcpProtocol); ImmutableHashSet <ActorPath> initialContacts = ImmutableHashSet.Create(ActorPath.Parse(receptionistActorPath)); var settings = ClusterClientSettings.Create(MyActorSystem).WithInitialContacts(initialContacts); clusterClient = MyActorSystem.ActorOf(ClusterClient.Props(settings), "Client"); subscriber = MyActorSystem.ActorOf(Props.Create <ProgressSubscriberActor>(), NamesRegistry.ProgressSubscriber); Timer progressTimer = new Timer { Interval = 500 }; progressTimer.Enabled = true; progressTimer.Elapsed += (sender, args) => { object response = clusterClient.Ask(new ClusterClient.Publish(NamesRegistry.ProgressTopic, new ProgressPublisherActor.ProgressUpdateRequest())).Result; subscriber.Tell(response); }; Console.WriteLine($"Created Subscriber for progress updates: {clusterClient.Path} on {MyActorSystem.Name}"); }
public void ClusterClientSettings_must_throw_exception_on_wrong_buffer(int bufferSize) { var sys = ActorSystem.Create("test", ConfigurationFactory.ParseString("akka.cluster.client.buffer-size = " + bufferSize)); var exception = Assert.Throws <ArgumentException>(() => ClusterClientSettings.Create(sys)); exception.Message.Should().Be("BufferSize must be >= 0 and <= 10000"); }
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(config.GetString("akka.system.actorsystem-name"), config); var cmd = PetabridgeCmd.Get(system); cmd.Start(); // // Cluster 접속하기 // system.ActorOf( ClusterClient .Props(ClusterClientSettings.Create(system)), "ClusterClientActor"); Console.WriteLine(); Console.WriteLine("ClusterClientApp1 is running..."); Console.WriteLine(); Console.ReadLine(); }
protected override void PreStart() { _clusterClient = Context.ActorOf(ClusterClient.Props( ClusterClientSettings.Create(Context.System).WithInitialContacts(Consts.ContactPoints))); Timers.StartPeriodicTimer(TimerName, SendPing.Instance, TimeSpan.FromSeconds(1)); }
/// <summary> /// Creates a cluster client, that allows to connect to cluster even thou current actor system is not part of it. /// </summary> static void RunClusterClient(ActorSystem system) { //NOTE: to properly run cluster client set up actor ref provider for nodes on `provider = "Akka.Remote.RemoteActorRefProvider, Akka.Remote"` system.Settings.InjectTopLevelFallback(ClusterClientReceptionist.DefaultConfig()); var clusterClient = system.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(system))); clusterClient.Tell(new ClusterClient.Send("/user/my-service", new Echo("hello from cluster client"))); }
public void ClusterClient_must_report_removal_of_a_receptionist() { Within(TimeSpan.FromSeconds(30), () => { RunOn(() => { var unreachableContact = Node(_config.Client) / "system" / "receptionist"; var expectedRoles = ImmutableHashSet.Create(_config.First, _config.Second, _config.Third, _config.Fourth); var expectedContacts = expectedRoles.Select(x => Node(x) / "system" / "receptionist").ToImmutableHashSet(); // We need to slow down things otherwise our receptionists can sometimes tell us // that our unreachableContact is unreachable before we get a chance to // subscribe to events. foreach (var role in expectedRoles) { TestConductor.Blackhole(_config.Client, role, ThrottleTransportAdapter.Direction.Both) .Wait(); } var c = Sys.ActorOf( ClusterClient.Props(ClusterClientSettings.Create(Sys) .WithInitialContacts(expectedContacts.Add(unreachableContact))), "client5"); var probe = CreateTestProbe(); c.Tell(SubscribeContactPoints.Instance, probe.Ref); foreach (var role in expectedRoles) { TestConductor.PassThrough(_config.Client, role, ThrottleTransportAdapter.Direction.Both) .Wait(); } probe.FishForMessage(o => (o is ContactPointRemoved cp && cp.ContactPoint.Equals(unreachableContact)), TimeSpan.FromSeconds(10), "removal"); }, _config.Client);
public void ClusterClientSettings_must_throw_exception_on_empty_initial_contacts() { var clusterClientSettings = ClusterClientSettings.Create(Sys); var exception = Assert.Throws <ArgumentException>(() => clusterClientSettings.WithInitialContacts(ImmutableHashSet <ActorPath> .Empty)); exception.Message.Should().Be("InitialContacts must be defined"); }
public void ClusterClientSettings_must_copy_initial_contacts_via_fluent_interface() { var initialContacts = ImmutableHashSet <ActorPath> .Empty.Add(new RootActorPath(Address.AllSystems) / "user" / "foo"); var clusterClientSettings = ClusterClientSettings.Create(Sys).WithInitialContacts(initialContacts).WithBufferSize(2000); clusterClientSettings.InitialContacts.Should().BeEquivalentTo(initialContacts); }
//[MultiNodeFact(Skip = "TODO")] public void ClusterClient_should_reestablish_connection_to_another_receptionist_when_server_is_shutdown() { ClusterClient_should_demonstrate_usage(); Within(TimeSpan.FromSeconds(30), () => { RunOn(() => { var service2 = Sys.ActorOf(Props.Create(() => new TestService(TestActor)), "service2"); ClusterClientReceptionist.Get(Sys).RegisterService(service2); AwaitCount(8); }, _first, _second, _third, _fourth); EnterBarrier("service2-replicated"); RunOn(() => { var c = Sys.ActorOf(Client.ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client2"); c.Tell(new Client.ClusterClient.Send("/user/service2", "bonjour", localAffinity: true)); ExpectMsg("bonjour-ack"); var lastSenderAddress = LastSender.Path.Address; var receptionistRoleName = RoleName(lastSenderAddress); if (receptionistRoleName == null) { throw new Exception("Unexpected missing role name: " + lastSenderAddress); } TestConductor.Exit(receptionistRoleName, 0).Wait(); _remainingServerRoleNames.Remove(receptionistRoleName); Within(Remaining - TimeSpan.FromSeconds(3), () => { AwaitAssert(() => { c.Tell(new Client.ClusterClient.Send("/user/service2", "hi again", localAffinity: true)); ExpectMsg("hi again-ack", TimeSpan.FromSeconds(1)); }); }); Sys.Stop(c); }, _client); EnterBarrier("verified-3"); ReceiveWhile(TimeSpan.FromSeconds(2), msg => { if (msg.Equals("hi again")) { return(msg); } else { throw new Exception("unexpected message: " + msg); } }); EnterBarrier("after-4"); }); }
protected override void PreStart() { _clusterClient = Context.ActorOf( ClusterClient .Props(ClusterClientSettings.Create(Context.System)), "ClusterClientActor"); _pingTask = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), Self, TryPing.Instance, ActorRefs.NoSender); }
public void ClusterClientSettings_must_have_default_config() { var clusterClientSettings = ClusterClientSettings.Create(Sys); clusterClientSettings.Should().NotBeNull(); clusterClientSettings.InitialContacts.Should().HaveCount(0); clusterClientSettings.EstablishingGetContactsInterval.Should().Be(3.Seconds()); clusterClientSettings.RefreshContactsInterval.Should().Be(60.Seconds()); clusterClientSettings.HeartbeatInterval.Should().Be(2.Seconds()); clusterClientSettings.AcceptableHeartbeatPause.Should().Be(13.Seconds()); clusterClientSettings.BufferSize.Should().Be(1000); }
private void ClusterClient_must_establish_connection_to_first_node() { RunOn(() => { _clusterClient = Sys.ActorOf( ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client1"); _clusterClient.Tell(new ClusterClient.Send("/user/testService", "hello", localAffinity: true)); ExpectMsg <string>().Should().Be("hello"); }, _config.Client); EnterBarrier("established"); }
//[MultiNodeFact(Skip = "TODO")] public void ClusterClient_should_reestablish_connection_to_receptionist_after_partition() { ClusterClient_should_reestablish_connection_to_another_receptionist_when_server_is_shutdown(); Within(TimeSpan.FromSeconds(30), () => { RunOn(() => { var c = Sys.ActorOf(Client.ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client3"); c.Tell(new Client.ClusterClient.Send("/user/service2", "bonjour2", localAffinity: true)); ExpectMsg("bonjour2-ack"); var lastSenderAddress = LastSender.Path.Address; var receptionistRoleName = RoleName(lastSenderAddress); if (receptionistRoleName == null) { throw new Exception("Unexpected missing role name: " + lastSenderAddress); } // shutdown all but the one that the client is connected to foreach (var roleName in _remainingServerRoleNames.ToArray()) { if (!roleName.Equals(receptionistRoleName)) { TestConductor.Exit(roleName, 0).Wait(); } } _remainingServerRoleNames = new HashSet <RoleName>(new[] { receptionistRoleName }); // network partition between client and server TestConductor.Blackhole(_client, receptionistRoleName, ThrottleTransportAdapter.Direction.Both).Wait(); c.Tell(new Client.ClusterClient.Send("/user/service2", "ping", localAffinity: true)); // if we would use remote watch the failure detector would trigger and // connection quarantined ExpectNoMsg(TimeSpan.FromSeconds(5)); TestConductor.PassThrough(_client, receptionistRoleName, ThrottleTransportAdapter.Direction.Both).Wait(); var expectedAddress = Node(receptionistRoleName).Address; AwaitAssert(() => { c.Tell(new Client.ClusterClient.Send("/user/service2", "bonjour3", localAffinity: true)); ExpectMsg("bonjour3-ack", TimeSpan.FromSeconds(1)); var lastSenderAddress2 = LastSender.Path.Address; Assert.Equal(expectedAddress, lastSenderAddress2); }); Sys.Stop(c); }, _client); EnterBarrier("after-5"); }); }
public ClusterClientSendActor() { // // ClusterClient 액터를 생성한다. // var c = Context.ActorOf( ClusterClient .Props(ClusterClientSettings.Create(Context.System)), "ClusterClientActor"); c.Tell(new ClusterClient.Publish("Topic1", "Hello1")); c.Tell(new ClusterClient.Publish("Topic1", "Hello2")); c.Tell(new ClusterClient.Publish("Topic2", "Hello3")); }
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_partition() { Within(30.Seconds(), () => { RunOn(() => { var c = Sys.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client3"); c.Tell(new ClusterClient.Send("/user/service2", "bonjour2", localAffinity: true)); var reply = ExpectMsg <ClusterClientSpecConfig.Reply>(); reply.Msg.Should().Be("bonjour2-ack"); RoleName receptionistRoleName = GetRoleName(reply.Node); if (receptionistRoleName == null) { throw new Exception("Unexpected missing role name: " + reply.Node); } // shutdown all but the one that the client is connected to _remainingServerRoleNames.Where(r => !r.Equals(receptionistRoleName)).ForEach(r => { TestConductor.Exit(r, 0).Wait(); }); _remainingServerRoleNames = ImmutableHashSet.Create(receptionistRoleName); // network partition between client and server TestConductor.Blackhole(_config.Client, receptionistRoleName, ThrottleTransportAdapter.Direction.Both).Wait(); c.Tell(new ClusterClient.Send("/user/service2", "ping", localAffinity: true)); // if we would use remote watch the failure detector would trigger and // connection quarantined ExpectNoMsg(5.Seconds()); TestConductor.PassThrough(_config.Client, receptionistRoleName, ThrottleTransportAdapter.Direction.Both).Wait(); var expectedAddress = GetAddress(receptionistRoleName); AwaitAssert(() => { var probe = CreateTestProbe(); c.Tell(new ClusterClient.Send("/user/service2", "bonjour3", localAffinity: true), probe.Ref); var reply2 = probe.ExpectMsg <ClusterClientSpecConfig.Reply>(1.Seconds()); reply2.Msg.Should().Be("bonjour3-ack"); reply2.Node.Should().Be(expectedAddress); }); Sys.Stop(c); }, _config.Client); EnterBarrier("after-5"); }); }
public void Should_cluster_client_settings_have_default_config() { ClusterClientSettings.Create(Sys); var config = Sys.Settings.Config.GetConfig("akka.cluster.client"); Assert.NotNull(config); var initialContacts = config.GetStringList("initial-contacts"); Assert.Equal(0, initialContacts.Count); Assert.Equal(TimeSpan.FromSeconds(3), config.GetTimeSpan("establishing-get-contacts-interval")); Assert.Equal(TimeSpan.FromSeconds(60), config.GetTimeSpan("refresh-contacts-interval")); Assert.Equal(TimeSpan.FromSeconds(2), config.GetTimeSpan("heartbeat-interval")); Assert.Equal(TimeSpan.FromSeconds(13), config.GetTimeSpan("acceptable-heartbeat-pause")); Assert.Equal(TimeSpan.FromSeconds(3), config.GetTimeSpan("establishing-get-contacts-interval")); Assert.Equal(1000, config.GetInt("buffer-size")); }
public ClusterClientSendActor() { var c = Context.ActorOf( ClusterClient .Props(ClusterClientSettings.Create(Context.System)), "ClusterClientActor"); //// //// 사용자 정의 메시지는 Seed Node에 참조되어야 한다. //// TODO: 해결 방법이 없을까?, 메시지를 받는 Node만 참조할 수 없을까? //// c.Tell(new ClusterClient.Send("/user/FooActor", new CustomWelcome("Send"))); c.Tell(new ClusterClient.Send("/user/FooActor", new CustomWelcome("Send"))); c.Tell(new ClusterClient.SendToAll("/user/FooActor", new CustomWelcome("SendToAll"))); }
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()); }); }
//[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"); }); }
public ClusterClientSendActor() { // // ClusterClient 액터를 생성한다. // var c = Context.ActorOf( ClusterClient .Props(ClusterClientSettings.Create(Context.System)), // .WithInitialContacts "ClusterClientActor"); // // TODO ClusterClientSettings 세부 설정 // - WithBufferSize // - WithEstablishingGetContactsInterval // - WithHeartbeatInterval // - WithInitialContacts // - WithReconnectTimeout // - WithRefreshContactsInterval // // // 메시지를 경로가 일치하는 한 액터에게 보낸다. // The message will be delivered to one recipient with a matching path, if any such exists // c.Tell(new ClusterClient.Send("/user/FooActor", "hello-localAffinity", localAffinity: true)); c.Tell(new ClusterClient.Send("/user/FooActor", "hello-localAffinity", localAffinity: true)); // // Send 기본적으로 경로가 일치하는 액터 중에서 랜덤으로 대상을 선택하여 메시지를 보낸다. // random to any other matching entry // c.Tell(new ClusterClient.Send("/user/FooActor", "hello")); c.Tell(new ClusterClient.Send("/user/FooActor", "hello")); c.Tell(new ClusterClient.Send("/user/FooActor", "hello")); c.Tell(new ClusterClient.Send("/user/FooActor", "hello")); // // 메시지를 경로가 일치하는 모든 액터에게 보낸다. // The message will be delivered to all recipients with a matching path // c.Tell(new ClusterClient.SendToAll("/user/FooActor", "hi, everybody")); }
public void ClusterClient_must_communicate_to_any_node_in_cluster() { Within(10.Seconds(), () => { RunOn(() => { var c = Sys.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client1"); c.Tell(new ClusterClient.Send("/user/testService", "hello", localAffinity: true)); ExpectMsg <ClusterClientSpecConfig.Reply>().Msg.Should().Be("hello-ack"); Sys.Stop(c); }, _config.Client); RunOn(() => { ExpectMsg("hello"); }, _config.Fourth); EnterBarrier("after-2"); }); }
private static void SendToCluster() { var sys = ActorSystem.Create("sys"); var client = sys.ActorOf( ClusterClient.Props( ClusterClientSettings.Create(sys) .WithInitialContacts( ImmutableHashSet.Create( new[] { ActorPath.Parse("akka.tcp://cluster-sys@localhost:2551/system/receptionist") }))), "client"); var random = new Random(Guid.NewGuid().GetHashCode()); do { client.Tell(new ClusterClient.Send("/user/addition", random.Next(10000))); Thread.Sleep(1000); }while (true); }
protected override void PreStart() { _clusterClientActor = Context.ActorOf( ClusterClient .Props(ClusterClientSettings.Create(Context.System)), "ClusterClientActor"); // // 이벤트 등록: SubscribeContactPoints.Instance // -> Receive<ContactPoints> // -> Receive<ContactPointAdded> // -> Receive<ContactPointRemoved> // 이벤트 제거: UnsubscribeContactPoints.Instance // // vs. // // 명시적 확인: GetContactPoints.Instance // -> Receive<ContactPoints> // _clusterClientActor.Tell(SubscribeContactPoints.Instance); }
static void Main(string[] args) { var config = ConfigurationFactory.ParseString(@" akka { extensions = [""Akka.Cluster.Tools.Client.ClusterClientReceptionistExtensionProvider, Akka.Cluster.Tools""] actor { provider = ""Akka.Cluster.ClusterActorRefProvider, Akka.Cluster"" } remote { log-remote-lifecycle-events = DEBUG dot-netty.tcp { hostname = ""127.0.0.1"" port = 0 } } cluster { seed-nodes = [ ""akka.tcp://[email protected]:2551"", ] auto-down-unreachable-after = 30s roles = [client] client { initial-contacts = [""akka.tcp://[email protected]:2551/system/receptionist""] } } }"); using (var system = ActorSystem.Create("ClusterSystemClient", config)) { system.Settings.InjectTopLevelFallback(ClusterClientReceptionist.DefaultConfig()); var clusterClient = system.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(system)), "greeting"); while (true) { var message = Console.ReadLine(); clusterClient.Tell(new ClusterClient.Send("/user/greeting", new Ping(message)), system.ActorOf(Props.Create <GreetingActor>())); } } }
public void ClusterClient_must_work_with_ask() { Within(10.Seconds(), () => { RunOn(() => { var c = Sys.ActorOf(ClusterClient.Props( ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "ask-client"); var reply = c.Ask <ClusterClientSpecConfig.Reply>(new ClusterClient.Send("/user/testService", "hello-request", localAffinity: true)); reply.Wait(Remaining); reply.Result.Msg.Should().Be("hello-request-ack"); Sys.Stop(c); }, _config.Client); RunOn(() => { ExpectMsg("hello-request"); }, _config.Fourth); EnterBarrier("after-3"); }); }
//[MultiNodeFact(Skip = "TODO")] public void ClusterClient_should_communicate_to_any_node_in_cluster() { ClusterClient_should_startup_cluster(); Within(TimeSpan.FromSeconds(10), () => { RunOn(() => { var c = Sys.ActorOf(Client.ClusterClient.Props(ClusterClientSettings.Create(Sys).WithInitialContacts(InitialContacts)), "client1"); c.Tell(new Client.ClusterClient.Send("/user/testService", "hello", localAffinity: true)); ExpectMsg("hello-ack"); Sys.Stop(c); }, _client); RunOn(() => { ExpectMsg("hello"); }, _fourth); EnterBarrier("after-2"); }); }
public ClusterClientSendActor() { clusterClient = //Context.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Context.System)), "ClusterClientActor"); Context.ActorOf(ClusterClient.Props(ClusterClientSettings.Create(Context.System)), "ClusterClientActor"); this.Receive <Ping>(p => { clusterClient.Ask <Pong>(new ClusterClient.Send("/user/publisher", p)) .PipeTo(Self); }); this.Receive <Pong>(p => { Console.WriteLine(p.Rsp + "--" + p.ReplyAddress); }); this.Receive <ITradeEvent>(@event => { var message = new ClusterClient.Publish("/user/publisher", @event); this.clusterClient.Tell(message); }); }