コード例 #1
0
 /// <summary>
 /// Shuts a cluster down repeatedly until it is down.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <param name="cluster">The cluster.</param>
 /// <returns>Whether the cluster was properly shut down.</returns>
 public static async Task ShutdownClusterDownAsync(this IRemoteControllerClient rc, Cluster cluster)
 {
     while (!await rc.ShutdownClusterAsync(cluster).CAF())
     {
         await Task.Delay(1_000).CAF();
     }
 }
コード例 #2
0
        /// <summary>
        /// Starts a new member and wait until it is added.
        /// </summary>
        /// <param name="rc">The remote controller.</param>
        /// <param name="client">The Hazelcast client.</param>
        /// <param name="cluster">The cluster.</param>
        /// <param name="expectedPartitionOwnersCount">The expected number of partition owners.</param>
        /// <returns>The new member.</returns>
        public static async Task <Member> StartMemberWaitAddedAsync(this IRemoteControllerClient rc, IHazelcastClient client, Cluster cluster, int expectedPartitionOwnersCount)
        {
            var clientInternal = (HazelcastClient)client;
            var added          = new SemaphoreSlim(0);
            var partitions     = new SemaphoreSlim(0);

            var subscriptionId = await clientInternal.SubscribeAsync(on => on
                                                                     .MembersUpdated((sender, args) =>
            {
                if (args.AddedMembers.Count > 0)
                {
                    added.Release();
                }
            })
                                                                     .PartitionsUpdated((sender, args) =>
            {
                partitions.Release();
            }))
                                 .CfAwait();

            var member = await rc.StartMemberAsync(cluster).CfAwait();

            await added.WaitAsync(TimeSpan.FromSeconds(120)).CfAwait();

            // trigger the partition table creation
            var map = await client.GetMapAsync <object, object>("default").CfAwait();

            _ = map.GetAsync(new object());

            await partitions.WaitAsync(TimeSpan.FromSeconds(120)).CfAwait();

            await clientInternal.UnsubscribeAsync(subscriptionId).CfAwait();

            var partitioner     = clientInternal.Cluster.Partitioner;
            var partitionsCount = partitioner.Count;
            var owners          = new HashSet <Guid>();

            for (var i = 0; i < partitionsCount; i++)
            {
                var owner = partitioner.GetPartitionOwner(i);
                if (owner != default)
                {
                    owners.Add(owner);
                }
            }

            Assert.AreEqual(expectedPartitionOwnersCount, owners.Count);

            return(member);
        }
コード例 #3
0
        /// <summary>
        /// Shuts a member down and wait until it is removed.
        /// </summary>
        /// <param name="rc">The remote controller.</param>
        /// <param name="client">The Hazelcast client.</param>
        /// <param name="cluster">The cluster.</param>
        /// <param name="member">The member.</param>
        public static async Task StopMemberWaitRemovedAsync(this IRemoteControllerClient rc, IHazelcastClient client, Cluster cluster, Member member)
        {
            var clientInternal = (HazelcastClient)client;
            var removed        = new SemaphoreSlim(0);

            var subscriptionId = await clientInternal.SubscribeAsync(on => on
                                                                     .MemberRemoved((sender, args) =>
            {
                removed.Release();
            }))
                                 .CAF();

            await rc.StopMemberAsync(cluster, member).CAF();

            await removed.WaitAsync(TimeSpan.FromSeconds(120)).CAF();

            await clientInternal.UnsubscribeAsync(subscriptionId).CAF();
        }
コード例 #4
0
        /// <summary>
        /// Shuts a member down and wait until its connection closes.
        /// </summary>
        /// <param name="rc">The remote controller.</param>
        /// <param name="client">The Hazelcast client.</param>
        /// <param name="cluster">The cluster.</param>
        /// <param name="member">The member.</param>
        /// <remarks>
        /// <para>This works even if the member is the last member of the cluster.</para>
        /// </remarks>
        public static async Task StopMemberWaitClosedAsync(this IRemoteControllerClient rc, IHazelcastClient client, Cluster cluster, Member member)
        {
            var clientInternal = (HazelcastClient)client;
            var closed         = new SemaphoreSlim(0);

            var memberId       = new Guid(member.Uuid);
            var subscriptionId = await clientInternal.SubscribeAsync(on => on
                                                                     .ConnectionClosed((sender, args) =>
            {
                // we don't have this yet, so just trust it's the ok connection
                //if (args.Connection.MemberId == memberId) closed.Release();
                closed.Release();
            }))
                                 .CfAwait();

            await rc.StopMemberAsync(cluster, member).CfAwait();

            await closed.WaitAsync(TimeSpan.FromSeconds(120)).CfAwait();

            await clientInternal.UnsubscribeAsync(subscriptionId).CfAwait();
        }
コード例 #5
0
 /// <summary>
 /// Starts a new member.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <param name="cluster">The cluster.</param>
 /// <returns>The new member.</returns>
 public static Task <Member> StartMemberAsync(this IRemoteControllerClient rc, Cluster cluster)
 => rc.StartMemberAsync(cluster.Id);
コード例 #6
0
 /// <summary>
 /// Shuts a cluster down.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <param name="cluster">The cluster.</param>
 /// <returns>Whether the cluster was properly shut down.</returns>
 public static Task <bool> ShutdownClusterAsync(this IRemoteControllerClient rc, Cluster cluster)
 => rc.ShutdownClusterAsync(cluster.Id);
コード例 #7
0
 /// <summary>
 /// Creates a new cluster.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <param name="serverConfiguration">The server Xml configuration.</param>
 /// <returns>The new cluster.</returns>
 public static Task <Cluster> CreateClusterAsync(this IRemoteControllerClient rc, string serverConfiguration)
 => rc.CreateClusterAsync(null, serverConfiguration);
コード例 #8
0
 /// <summary>
 /// Creates a new cluster.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <returns>The new cluster.</returns>
 public static Task <Cluster> CreateClusterAsync(this IRemoteControllerClient rc)
 => rc.CreateClusterAsync(null, Resources.hazelcast);
コード例 #9
0
 /// <summary>
 /// Resumes a member.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <param name="cluster">The cluster.</param>
 /// <param name="member">The member.</param>
 /// <returns>Whether the member was properly resumed.</returns>
 public static Task <bool> ResumeMemberAsync(this IRemoteControllerClient rc, Cluster cluster, Member member)
 => rc.ResumeMemberAsync(cluster.Id, member.Uuid);
コード例 #10
0
 /// <summary>
 /// Suspends a member.
 /// </summary>
 /// <param name="rc">The remote controller.</param>
 /// <param name="cluster">The cluster.</param>
 /// <param name="member">The member.</param>
 /// <returns>Whether the member was properly suspended.</returns>
 public static Task <bool> SuspendMemberAsync(IRemoteControllerClient rc, Cluster cluster, Member member)
 => rc.ShutdownMemberAsync(cluster.Id, member.Uuid);