Akka.Cluster.Tests.MultiNode.UnreachableNodeJoinsAgainSpec.AllowFreshNodeWithSameHostAndPortToJoinAgainWhenTheNetworkIsPluggedBackIn C# (CSharp) Method

        public void AllowFreshNodeWithSameHostAndPortToJoinAgainWhenTheNetworkIsPluggedBackIn()
        {
            var expectedNumberOfMembers = Roles.Count;

            // victim actor system will be shutdown, not part of TestConductor any more
            // so we can't use barriers to synchronize with it
            var masterAddress = GetAddress(_master.Value);
            RunOn(() =>
            {
                Sys.ActorOf(Props.Create(() => new EndActor(TestActor, null)), "end");
            }, _master.Value);
            EnterBarrier("end-actor-created");

            RunOn(() =>
            {
                // put the network back in
                AllBut(_victim.Value).ForEach(role =>
                {
                    TestConductor.PassThrough(_victim.Value, role, ThrottleTransportAdapter.Direction.Both).Wait();
                });
            }, _config.First);

            EnterBarrier("plug_in_victim");

            RunOn(() =>
            {
                // will shutdown ActorSystem of victim
                TestConductor.Shutdown(_victim.Value);
            }, _config.First);

            RunOn(() =>
            {
                var victimAddress = Sys.AsInstanceOf<ExtendedActorSystem>().Provider.DefaultAddress;
                Sys.WhenTerminated.Wait(TimeSpan.FromSeconds(10));

                // create new ActorSystem with same host:port
                var freshSystem = ActorSystem.Create(Sys.Name, ConfigurationFactory.ParseString(@"akka.remote.helios.tcp{
                    hostname = "+ victimAddress.Host + @"
                    port = "+ victimAddress.Port + @"
                }").WithFallback(Sys.Settings.Config));

                try
                {
                    Cluster.Get(freshSystem).Join(masterAddress);
                    Within(TimeSpan.FromSeconds(15), () =>
                    {
                        AwaitAssert(() => Assert.True(Cluster.Get(freshSystem).ReadView.Members.Select(x => x.Address).Contains(victimAddress)));
                        AwaitAssert(() => Assert.Equal(expectedNumberOfMembers,Cluster.Get(freshSystem).ReadView.Members.Count));
                        AwaitAssert(() => Assert.True(Cluster.Get(freshSystem).ReadView.Members.All(y => y.Status == MemberStatus.Up)));
                    });

                    // signal to master node that victim is done
                    var endProbe = CreateTestProbe(freshSystem);
                    var endActor = freshSystem.ActorOf(Props.Create(() => new EndActor(endProbe.Ref, masterAddress)),
                        "end");
                    endActor.Tell(EndActor.SendEnd.Instance);
                    endProbe.ExpectMsg<EndActor.EndAck>();
                }
                finally
                {
                    Shutdown(freshSystem);
                }
                // no barrier here, because it is not part of testConductor roles any more
            }, _victim.Value);

            RunOn(() =>
            {
                AwaitMembersUp(expectedNumberOfMembers);
                // don't end the test until the freshSystem is done
                RunOn(() =>
                {
                    ExpectMsg<EndActor.End>(TimeSpan.FromSeconds(20));
                }, _master.Value);
                EndBarrier();
            }, AllBut(_victim.Value).ToArray());
        }
    }