Example #1
0
        public void TestAliveAfterAllReplicaDead()
        {
            using (var poolManager = new ReplicaSetPoolManager(2, new PoolSettings {
                DeadHealth = 0.01, MaxCheckInterval = TimeSpan.FromSeconds(1), CheckIntervalIncreaseBasis = TimeSpan.FromMilliseconds(100)
            }))
            {
                SimulateLoad(poolManager, threads: 10, operations: 1000);

                poolManager.MakeDeadReplica(0);
                poolManager.MakeDeadReplica(1);
                poolManager.ResetCounters();
                for (var i = 0; i < 1000; i++)
                {
                    Assert.Throws <AllItemsIsDeadExceptions>(() => poolManager.Acquire());
                }

                poolManager.MakeLiveReplica(0);
                poolManager.MakeLiveReplica(1);
                poolManager.ResetCounters();
                SimulateLoad(poolManager, threads: 10, operations: 1000);
                Assert.That(poolManager.GetCreateCount(0), Is.InRange(7, 17));
                Assert.That(poolManager.GetCreateCount(1), Is.InRange(7, 17));
                Assert.That(poolManager.GetAcquiredCount(0), Is.InRange(1000 * 3, 1000 * 7));
                Assert.That(poolManager.GetAcquiredCount(1), Is.InRange(1000 * 3, 1000 * 7));
            }
        }
Example #2
0
        private void SimulateLoad(ReplicaSetPoolManager poolManager, int threads, int operations, TimeSpan?interval = null)
        {
            var operationsInterval = interval == null ? (TimeSpan?)null : TimeSpan.FromTicks(interval.Value.Ticks / operations);

            for (var i = 0; i < operations; i++)
            {
                var acquiredItems = Enumerable.Range(0, threads).Select(x => poolManager.Acquire()).ToArray();
                if (operationsInterval != null)
                {
                    Thread.Sleep(operationsInterval.Value);
                }
                foreach (var acquiredItem in acquiredItems)
                {
                    poolManager.Good(acquiredItem);
                    poolManager.Release(acquiredItem);
                }
            }
        }
Example #3
0
        public void TestAllReplicaDeadCauseSynchronousConnect()
        {
            using (var poolManager = new ReplicaSetPoolManager(2, new PoolSettings {
                DeadHealth = 0.01, MaxCheckInterval = TimeSpan.FromSeconds(1), CheckIntervalIncreaseBasis = TimeSpan.FromMilliseconds(100)
            }))
            {
                SimulateLoad(poolManager, threads: 10, operations: 1000);

                poolManager.MakeDeadReplica(0);
                poolManager.MakeDeadReplica(1);
                poolManager.ResetCounters();
                Assert.Throws <AllItemsIsDeadExceptions>(() => poolManager.Acquire());
                Assert.Throws <AllItemsIsDeadExceptions>(() => poolManager.Acquire());
                Assert.Throws <AllItemsIsDeadExceptions>(() => poolManager.Acquire());
                Assert.Throws <AllItemsIsDeadExceptions>(() => poolManager.Acquire());

                Assert.That(poolManager.GetCreateCount(0), Is.InRange(4, 4 * 2));
                Assert.That(poolManager.GetCreateCount(1), Is.InRange(4, 4 * 2));
            }
        }
Example #4
0
        public void TestOneReplicaAliveAfterDead()
        {
            using (var poolManager = new ReplicaSetPoolManager(2, new PoolSettings {
                DeadHealth = 0.01, MaxCheckInterval = TimeSpan.FromSeconds(1), CheckIntervalIncreaseBasis = TimeSpan.FromMilliseconds(100)
            }))
            {
                SimulateLoad(poolManager, threads: 10, operations: 1000);
                Assert.That(poolManager.GetCreateCount(0), Is.InRange(5, 10));
                Assert.That(poolManager.GetCreateCount(1), Is.InRange(5, 10));

                poolManager.MakeDeadReplica(0);
                SimulateLoad(poolManager, threads: 10, operations: 1000, interval: TimeSpan.FromSeconds(10));

                poolManager.MakeLiveReplica(0);
                poolManager.ResetCounters();
                SimulateLoad(poolManager, threads: 10, operations: 1000, interval: TimeSpan.FromSeconds(20));
                Assert.That(poolManager.GetCreateCount(0), Is.InRange(7, 17));
                Assert.That(poolManager.GetAcquiredCount(0), Is.InRange(1000 * 3, 1000 * 7));
                Assert.That(poolManager.GetAcquiredCount(1), Is.InRange(1000 * 3, 1000 * 7));
            }
        }
Example #5
0
        public void TestOneDeadReplicaDoCreateConnectionsWhenAcquire()
        {
            using (var poolManager = new ReplicaSetPoolManager(2, new PoolSettings {
                DeadHealth = 0.01, MaxCheckInterval = TimeSpan.FromSeconds(1), CheckIntervalIncreaseBasis = TimeSpan.FromMilliseconds(100)
            }))
            {
                SimulateLoad(poolManager, threads: 10, operations: 1000);
                Assert.That(poolManager.GetCreateCount(0), Is.InRange(5, 10));
                Assert.That(poolManager.GetCreateCount(1), Is.InRange(5, 10));

                poolManager.MakeDeadReplica(0);
                SimulateLoad(poolManager, threads: 10, operations: 1000);

                poolManager.ResetCounters();
                SimulateLoad(poolManager, threads: 10, operations: 1000);
                Assert.That(poolManager.GetCreateCount(0), Is.InRange(0, 1));
                Assert.That(poolManager.GetCreateCount(1), Is.InRange(0, 10));
                Assert.That(poolManager.GetAcquiredCount(0), Is.EqualTo(0));
                Assert.That(poolManager.GetAcquiredCount(1), Is.EqualTo(1000 * 10));
            }
        }