예제 #1
0
        public void TestMultiMember()
        {
            Guid?oldMemberUUID0 = null;
            Guid?oldMemberUUID1 = null;

            SetupCluster(() =>
            {
                oldMemberUUID0 = StartNewMember();
                oldMemberUUID1 = StartNewMember();
            });

            var memberAdded   = new CountdownEvent(2);
            var memberRemoved = new CountdownEvent(2);

            var addedMemberUUIDs   = new ConcurrentBag <Guid>();
            var removedMemberUUIDs = new ConcurrentBag <Guid>();

            Client.Cluster.AddMembershipListener(new MembershipListener
            {
                OnMemberAdded = membershipEvent =>
                {
                    addedMemberUUIDs.Add(membershipEvent.GetMember().Uuid);
                    memberAdded.Signal();
                },
                OnMemberRemoved = membershipEvent =>
                {
                    removedMemberUUIDs.Add(membershipEvent.GetMember().Uuid);
                    memberRemoved.Signal();
                }
            });
            while (!ShutdownCluster())
            {
                Thread.Sleep(1000);
            }
            var newMemberUUID0 = StartNewMember();
            var newMemberUUID1 = StartNewMember();

            TestSupport.AssertOpenEventually(memberRemoved);
            Assert.AreEqual(2, removedMemberUUIDs.Count);
            Assert.Contains(oldMemberUUID0, removedMemberUUIDs);
            Assert.Contains(oldMemberUUID1, removedMemberUUIDs);

            TestSupport.AssertOpenEventually(memberAdded);
            Assert.AreEqual(2, addedMemberUUIDs.Count);
            Assert.Contains(newMemberUUID0, addedMemberUUIDs);
            Assert.Contains(newMemberUUID1, addedMemberUUIDs);

            var members = Client.Cluster.Members;

            Assert.AreEqual(2, members.Count);
            Assert.True(members.Any(member => member.Uuid == newMemberUUID0));
            Assert.True(members.Any(member => member.Uuid == newMemberUUID1));
        }
예제 #2
0
        public void TestDistributedObjectListener()
        {
            var createdLatch   = new CountdownEvent(1);
            var destroyedLatch = new CountdownEvent(1);
            var regId          = Client.AddDistributedObjectListener(new DistributedObjectListener(createdLatch, destroyedLatch));

            Assert.IsNotNull(regId, "regisrationId");

            var name  = TestSupport.RandomString();
            var topic = Client.GetTopic <object>(name);

            TestSupport.AssertOpenEventually(createdLatch, 10);
            topic.Destroy();
            TestSupport.AssertOpenEventually(destroyedLatch, 10);

            Assert.IsTrue(Client.RemoveDistributedObjectListener(regId), "Client.RemoveDistributedObjectListener(regId)");
        }
예제 #3
0
        public void TestSingleMember()
        {
            Guid?oldMemberUUID = null;

            SetupCluster(() =>
            {
                oldMemberUUID = StartNewMember();
            });

            var memberAdded   = new CountdownEvent(1);
            var memberRemoved = new CountdownEvent(1);

            var addedMemberReferenceUUID   = new Guid?();
            var removedMemberReferenceUUID = new Guid?();

            Client.Cluster.AddMembershipListener(new MembershipListener
            {
                OnMemberAdded = membershipEvent =>
                {
                    addedMemberReferenceUUID = membershipEvent.GetMember().Uuid;
                    memberAdded.Signal();
                },
                OnMemberRemoved = membershipEvent =>
                {
                    removedMemberReferenceUUID = membershipEvent.GetMember().Uuid;
                    memberRemoved.Signal();
                }
            });

            ShutdownMember(oldMemberUUID.Value);

            var newMemberUUID = StartNewMember();

            TestSupport.AssertOpenEventually(memberRemoved, "Failed to receive MemberRemoved event!");
            Assert.AreEqual(oldMemberUUID, removedMemberReferenceUUID);

            TestSupport.AssertOpenEventually(memberAdded, "Failed to receive MemberAdded event!");
            Assert.AreEqual(newMemberUUID, addedMemberReferenceUUID);

            var members = Client.Cluster.Members;

            Assert.True(members.Any(member => member.Uuid == newMemberUUID));
            Assert.AreEqual(1, members.Count);
        }
예제 #4
0
        public void TestSingleMember()
        {
            string oldMemberUUID = null;

            SetupCluster(() =>
            {
                oldMemberUUID = StartNewMember();
            });

            var memberAdded   = new CountdownEvent(1);
            var memberRemoved = new CountdownEvent(1);

            string addedMemberReferenceUUID   = null;
            string removedMemberReferenceUUID = null;

            Client.GetCluster().AddMembershipListener(new MembershipListener
            {
                OnMemberAdded = membershipEvent =>
                {
                    Interlocked.Exchange(ref addedMemberReferenceUUID, membershipEvent.GetMember().GetUuid());
                    memberAdded.Signal();
                },
                OnMemberRemoved = membershipEvent =>
                {
                    Interlocked.Exchange(ref removedMemberReferenceUUID, membershipEvent.GetMember().GetUuid());
                    memberRemoved.Signal();
                }
            });

            ShutdownMember(oldMemberUUID);
            var newMemberUUID = StartNewMember();

            TestSupport.AssertOpenEventually(memberRemoved);
            Assert.AreEqual(oldMemberUUID, removedMemberReferenceUUID);

            TestSupport.AssertOpenEventually(memberAdded);
            Assert.AreEqual(newMemberUUID, addedMemberReferenceUUID);

            var members = Client.GetCluster().GetMembers();

            Assert.True(members.Any(member => member.GetUuid() == newMemberUUID));
            Assert.AreEqual(1, members.Count);
        }