Examples with PartitionRegionInfo org.apache.geode.cache.partition.PartitionRegionInfo used on opensource projects

Example 16 with PartitionRegionInfo

use of org.apache.geode.cache.partition.PartitionRegionInfo in project geode by apache.

the class RebalanceOperationDUnitTest method testEnforceZoneWithMultipleRegions.

@Test
public void testEnforceZoneWithMultipleRegions() {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    try {
        setRedundancyZone(vm0, "A");
        setRedundancyZone(vm1, "A");
        final DistributedMember zoneBMember = setRedundancyZone(vm2, "B");
        SerializableRunnable setRebalanceObserver = new SerializableRunnable("RebalanceObserver") {

            @Override
            public void run() {
                InternalResourceManager.setResourceObserver(new ParallelRecoveryObserver(2));
            }
        };
        SerializableRunnable createPrRegion = new SerializableRunnable("createRegion") {

            public void run() {
                ParallelRecoveryObserver ob = (ParallelRecoveryObserver) InternalResourceManager.getResourceObserver();
                ob.observeRegion("region1");
                ob.observeRegion("region2");
                createPR("region1");
                createPR("region2");
            }
        };
        vm0.invoke(setRebalanceObserver);
        // Create the region in only 1 VM
        vm0.invoke(createPrRegion);
        // Create some buckets
        vm0.invoke(new SerializableRunnable("createSomeBuckets") {

            public void run() {
                doPuts("region1");
                doPuts("region2");
            }
        });
        SerializableRunnable checkLowRedundancy = new SerializableRunnable("checkLowRedundancy") {

            public void run() {
                Cache cache = getCache();
                Region region = cache.getRegion("region1");
                PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(region);
                assertEquals(6, details.getCreatedBucketCount());
                assertEquals(0, details.getActualRedundantCopies());
                assertEquals(6, details.getLowRedundancyBucketCount());
                region = cache.getRegion("region2");
                details = PartitionRegionHelper.getPartitionRegionInfo(region);
                assertEquals(6, details.getCreatedBucketCount());
                assertEquals(0, details.getActualRedundantCopies());
                assertEquals(6, details.getLowRedundancyBucketCount());
            }
        };
        // make sure we can tell that the buckets have low redundancy
        vm0.invoke(checkLowRedundancy);
        // Create the region in the other VMs (should have no effect)
        vm1.invoke(setRebalanceObserver);
        vm1.invoke(createPrRegion);
        vm2.invoke(setRebalanceObserver);
        vm2.invoke(createPrRegion);
        // Make sure we still have low redundancy
        vm0.invoke(checkLowRedundancy);
        // Now do a rebalance
        vm0.invoke(new SerializableRunnable("simulateRebalance") {

            public void run() {
                Cache cache = getCache();
                ResourceManager manager = cache.getResourceManager();
                RebalanceResults results = doRebalance(false, manager);
                // We expect to satisfy redundancy with the zone B member
                assertEquals(12, results.getTotalBucketCreatesCompleted());
                // 2 primaries will go to vm2, leaving vm0 and vm1 with 2 primaries each
                assertEquals(4, results.getTotalPrimaryTransfersCompleted());
                // We actually *will* transfer 3 buckets to the other member in zone A, because that
                // improves
                // the balance
                assertEquals(6, results.getTotalBucketTransfersCompleted());
                Set<PartitionRebalanceInfo> detailSet = results.getPartitionRebalanceDetails();
                assertEquals(2, detailSet.size());
                for (PartitionRebalanceInfo details : detailSet) {
                    assertEquals(6, details.getBucketCreatesCompleted());
                    assertEquals(2, details.getPrimaryTransfersCompleted());
                    assertEquals(3, details.getBucketTransfersCompleted());
                    Set<PartitionMemberInfo> afterDetails = details.getPartitionMemberDetailsAfter();
                    for (PartitionMemberInfo info : afterDetails) {
                        if (info.getDistributedMember().equals(zoneBMember)) {
                            assertEquals(6, info.getBucketCount());
                        } else {
                            assertEquals(3, info.getBucketCount());
                        }
                        assertEquals(2, info.getPrimaryCount());
                    }
                }
                // assertIndexDetailsEquals(0, details.getBucketTransferBytes());
                verifyStats(manager, results);
            }
        });
        vm0.invoke(new SerializableRunnable() {

            @Override
            public void run() {
                assertTrue(((ParallelRecoveryObserver) InternalResourceManager.getResourceObserver()).isObserverCalled());
            }
        });
        checkBucketCount(vm0, "region1", 3);
        checkBucketCount(vm1, "region1", 3);
        checkBucketCount(vm2, "region1", 6);
        checkBucketCount(vm0, "region2", 3);
        checkBucketCount(vm1, "region2", 3);
        checkBucketCount(vm2, "region2", 6);
    } finally {
        disconnectFromDS();
        Invoke.invokeInEveryVM(new SerializableRunnable() {

            public void run() {
                // clear the redundancy zone setting
                disconnectFromDS();
            }
        });
    }
}

Example 17 with PartitionRegionInfo

use of org.apache.geode.cache.partition.PartitionRegionInfo in project geode by apache.

the class RebalanceOperationDUnitTest method testCancelOperation.

@Test
public void testCancelOperation() {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    SerializableRunnable createPrRegion = new SerializableRunnable("createRegion") {

        public void run() {
            Cache cache = getCache();
            AttributesFactory attr = new AttributesFactory();
            PartitionAttributesFactory paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(1);
            paf.setRecoveryDelay(-1);
            paf.setStartupRecoveryDelay(-1);
            PartitionAttributes prAttr = paf.create();
            attr.setPartitionAttributes(prAttr);
            cache.createRegion("region1", attr.create());
        }
    };
    // Create the region in only 1 VM
    vm0.invoke(createPrRegion);
    // Create some buckets
    vm0.invoke(new SerializableRunnable("createSomeBuckets") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            region.put(Integer.valueOf(1), "A");
        }
    });
    SerializableRunnable checkLowRedundancy = new SerializableRunnable("checkLowRedundancy") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(region);
            assertEquals(1, details.getCreatedBucketCount());
            assertEquals(0, details.getActualRedundantCopies());
            assertEquals(1, details.getLowRedundancyBucketCount());
        }
    };
    // make sure we can tell that the buckets have low redundancy
    vm0.invoke(checkLowRedundancy);
    // Create the region in the other VM (should have no effect)
    vm1.invoke(createPrRegion);
    // Make sure we still have low redundancy
    vm0.invoke(checkLowRedundancy);
    // Now do a rebalance, but cancel it in the middle
    vm0.invoke(new SerializableCallable("D rebalance") {

        public Object call() throws Exception {
            GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
            InternalResourceManager manager = cache.getInternalResourceManager();
            final CountDownLatch rebalancingCancelled = new CountDownLatch(1);
            final CountDownLatch rebalancingFinished = new CountDownLatch(1);
            InternalResourceManager.setResourceObserver(new ResourceObserverAdapter() {

                @Override
                public void rebalancingOrRecoveryStarted(Region region) {
                    try {
                        rebalancingCancelled.await();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }

                @Override
                public void rebalancingOrRecoveryFinished(Region region) {
                    rebalancingFinished.countDown();
                }
            });
            RebalanceOperation op = manager.createRebalanceFactory().start();
            assertFalse(op.isCancelled());
            assertFalse(op.isDone());
            assertEquals(Collections.singleton(op), manager.getRebalanceOperations());
            try {
                op.getResults(5, TimeUnit.SECONDS);
                fail("Should have received a timeout exception");
            } catch (TimeoutException expected) {
            }
            assertTrue(op.cancel());
            rebalancingCancelled.countDown();
            assertTrue(op.isCancelled());
            assertTrue(op.isDone());
            rebalancingFinished.await();
            try {
                op.getResults(60, TimeUnit.SECONDS);
                fail("Should have received a cancellation exception");
            } catch (CancellationException expected) {
            }
            assertEquals(Collections.emptySet(), manager.getRebalanceOperations());
            return null;
        }
    });
    // We should still have low redundancy, because the rebalancing was cancelled
    vm0.invoke(checkLowRedundancy);
}

Example 18 with PartitionRegionInfo

use of org.apache.geode.cache.partition.PartitionRegionInfo in project geode by apache.

the class RebalanceOperationDUnitTest method moveBucketsNoRedundancy.

/**
   * Check to make sure that we balance buckets between two hosts with no redundancy.
   * 
   * @param simulate
   */
public void moveBucketsNoRedundancy(final boolean simulate) {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    SerializableRunnable createPrRegion = new SerializableRunnable("createRegion") {

        public void run() {
            Cache cache = getCache();
            AttributesFactory attr = new AttributesFactory();
            PartitionAttributesFactory paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(0);
            paf.setRecoveryDelay(-1);
            paf.setStartupRecoveryDelay(-1);
            PartitionAttributes prAttr = paf.create();
            attr.setPartitionAttributes(prAttr);
            attr.setCacheLoader(new Bug40228Loader());
            cache.createRegion("region1", attr.create());
        }
    };
    // Create the region in only 1 VM
    vm0.invoke(createPrRegion);
    // Create some buckets
    vm0.invoke(new SerializableRunnable("createSomeBuckets") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            region.put(Integer.valueOf(1), "A");
            region.put(Integer.valueOf(2), "A");
            region.put(Integer.valueOf(3), "A");
            region.put(Integer.valueOf(4), "A");
            region.put(Integer.valueOf(5), "A");
            region.put(Integer.valueOf(6), "A");
        }
    });
    // Create the region in the other VM (should have no effect)
    vm1.invoke(createPrRegion);
    // Now simulate a rebalance
    vm0.invoke(new SerializableRunnable("simulateRebalance") {

        public void run() {
            Cache cache = getCache();
            ResourceManager manager = cache.getResourceManager();
            RebalanceResults results = doRebalance(simulate, manager);
            assertEquals(0, results.getTotalBucketCreatesCompleted());
            assertEquals(0, results.getTotalPrimaryTransfersCompleted());
            assertEquals(3, results.getTotalBucketTransfersCompleted());
            assertTrue(0 < results.getTotalBucketTransferBytes());
            Set<PartitionRebalanceInfo> detailSet = results.getPartitionRebalanceDetails();
            assertEquals(1, detailSet.size());
            PartitionRebalanceInfo details = detailSet.iterator().next();
            assertEquals(0, details.getBucketCreatesCompleted());
            assertEquals(0, details.getPrimaryTransfersCompleted());
            assertTrue(0 < details.getBucketTransferBytes());
            assertEquals(3, details.getBucketTransfersCompleted());
            Set<PartitionMemberInfo> afterDetails = details.getPartitionMemberDetailsAfter();
            assertEquals(2, afterDetails.size());
            for (PartitionMemberInfo memberDetails : afterDetails) {
                assertEquals(3, memberDetails.getBucketCount());
                assertEquals(3, memberDetails.getPrimaryCount());
            }
            if (!simulate) {
                verifyStats(manager, results);
            }
        }
    });
    if (!simulate) {
        SerializableRunnable checkRedundancyFixed = new SerializableRunnable("checkRedundancyFixed") {

            public void run() {
                Cache cache = getCache();
                Region region = cache.getRegion("region1");
                PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(region);
                assertEquals(6, details.getCreatedBucketCount());
                assertEquals(0, details.getActualRedundantCopies());
                assertEquals(0, details.getLowRedundancyBucketCount());
                assertEquals(2, details.getPartitionMemberInfo().size());
                for (PartitionMemberInfo memberDetails : details.getPartitionMemberInfo()) {
                    assertEquals(3, memberDetails.getBucketCount());
                    assertEquals(3, memberDetails.getPrimaryCount());
                }
                // check to make sure that moving buckets didn't close the cache loader
                Bug40228Loader loader = (Bug40228Loader) cache.getRegion("region1").getAttributes().getCacheLoader();
                assertFalse(loader.isClosed());
            }
        };
        vm0.invoke(checkRedundancyFixed);
        vm1.invoke(checkRedundancyFixed);
        SerializableRunnable checkBug40228Fixed = new SerializableRunnable("checkBug40228Fixed") {

            public void run() {
                Cache cache = getCache();
                Bug40228Loader loader = (Bug40228Loader) cache.getRegion("region1").getAttributes().getCacheLoader();
                assertFalse(loader.isClosed());
                // check to make sure that closing the PR closes the cache loader
                cache.getRegion("region1").close();
                assertTrue(loader.isClosed());
            }
        };
        vm0.invoke(checkBug40228Fixed);
        vm1.invoke(checkBug40228Fixed);
    }
}

Example 19 with PartitionRegionInfo

use of org.apache.geode.cache.partition.PartitionRegionInfo in project geode by apache.

the class RebalanceOperationDUnitTest method recoverRedundancyColocatedRegions.

public void recoverRedundancyColocatedRegions(final boolean simulate) {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    final DistributedMember member1 = createPrRegion(vm0, "region1", 200, null);
    createPrRegion(vm0, "region2", 200, "region1");
    // Create some buckets.
    vm0.invoke(new SerializableRunnable("createSomeBuckets") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            Region region2 = cache.getRegion("region2");
            for (int i = 0; i < 12; i++) {
                region.put(Integer.valueOf(i), "A");
                region2.put(Integer.valueOf(i), "A");
            }
        }
    });
    // check to make sure our redundancy is impaired
    SerializableRunnable checkLowRedundancy = new SerializableRunnable("checkLowRedundancy") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(region);
            assertEquals(12, details.getCreatedBucketCount());
            assertEquals(0, details.getActualRedundantCopies());
            assertEquals(12, details.getLowRedundancyBucketCount());
            region = cache.getRegion("region2");
            details = PartitionRegionHelper.getPartitionRegionInfo(region);
            assertEquals(12, details.getCreatedBucketCount());
            assertEquals(0, details.getActualRedundantCopies());
            assertEquals(12, details.getLowRedundancyBucketCount());
        }
    };
    vm0.invoke(checkLowRedundancy);
    // Now create the region in 2 more vms, each which
    // has local max memory of 1/2 that of the original VM.
    createPrRegion(vm1, "region1", 100, null);
    createPrRegion(vm2, "region1", 100, null);
    createPrRegion(vm1, "region2", 100, "region1");
    createPrRegion(vm2, "region2", 100, "region1");
    vm0.invoke(checkLowRedundancy);
    // Now simulate a rebalance
    vm0.invoke(new SerializableRunnable("rebalance") {

        public void run() {
            Cache cache = getCache();
            ResourceManager manager = cache.getResourceManager();
            RebalanceResults results = doRebalance(simulate, manager);
            assertEquals(24, results.getTotalBucketCreatesCompleted());
            assertEquals(12, results.getTotalPrimaryTransfersCompleted());
            assertEquals(0, results.getTotalBucketTransferBytes());
            assertEquals(0, results.getTotalBucketTransfersCompleted());
            Set<PartitionRebalanceInfo> detailSet = results.getPartitionRebalanceDetails();
            assertEquals(2, detailSet.size());
            for (PartitionRebalanceInfo details : detailSet) {
                assertEquals(12, details.getBucketCreatesCompleted());
                assertEquals(6, details.getPrimaryTransfersCompleted());
                assertEquals(0, details.getBucketTransferBytes());
                assertEquals(0, details.getBucketTransfersCompleted());
                Set<PartitionMemberInfo> afterDetails = details.getPartitionMemberDetailsAfter();
                assertEquals(3, afterDetails.size());
                for (PartitionMemberInfo memberDetails : afterDetails) {
                    if (memberDetails.getDistributedMember().equals(member1)) {
                        assertEquals(12, memberDetails.getBucketCount());
                        assertEquals(6, memberDetails.getPrimaryCount());
                    } else {
                        assertEquals(6, memberDetails.getBucketCount());
                        assertEquals(3, memberDetails.getPrimaryCount());
                    }
                }
                if (!simulate) {
                    verifyStats(manager, results);
                }
            }
        }
    });
    if (!simulate) {
        SerializableRunnable checkRedundancyFixed = new SerializableRunnable("checkLowRedundancy") {

            public void run() {
                Cache cache = getCache();
                PartitionedRegion region1 = (PartitionedRegion) cache.getRegion("region1");
                PartitionedRegion region2 = (PartitionedRegion) cache.getRegion("region2");
                PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(cache.getRegion("region1"));
                assertEquals(12, details.getCreatedBucketCount());
                assertEquals(1, details.getActualRedundantCopies());
                assertEquals(0, details.getLowRedundancyBucketCount());
                details = PartitionRegionHelper.getPartitionRegionInfo(cache.getRegion("region2"));
                assertEquals(12, details.getCreatedBucketCount());
                assertEquals(1, details.getActualRedundantCopies());
                assertEquals(0, details.getLowRedundancyBucketCount());
                assertEquals(region1.getLocalPrimaryBucketsListTestOnly(), region2.getLocalPrimaryBucketsListTestOnly());
                assertEquals(region1.getLocalBucketsListTestOnly(), region2.getLocalBucketsListTestOnly());
            }
        };
        vm0.invoke(checkRedundancyFixed);
        vm1.invoke(checkRedundancyFixed);
        vm2.invoke(checkRedundancyFixed);
    }
}

Example 20 with PartitionRegionInfo

use of org.apache.geode.cache.partition.PartitionRegionInfo in project geode by apache.

the class RebalanceOperationDUnitTest method testMoveBucketsOverflowToDisk.

/**
   * A test that the stats when overflowing entries to disk are correct and we still rebalance
   * correctly
   */
@Test
public void testMoveBucketsOverflowToDisk() throws Throwable {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    VM vm3 = host.getVM(3);
    SerializableRunnable createPrRegion = new SerializableRunnable("createRegion") {

        public void run() {
            Cache cache = getCache();
            AttributesFactory attr = new AttributesFactory();
            PartitionAttributesFactory paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(1);
            paf.setRecoveryDelay(-1);
            paf.setStartupRecoveryDelay(-1);
            PartitionAttributes prAttr = paf.create();
            attr.setPartitionAttributes(prAttr);
            attr.setEvictionAttributes(EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK));
            cache.createRegion("region1", attr.create());
        }
    };
    // Create the region in two VMs
    vm0.invoke(createPrRegion);
    vm1.invoke(createPrRegion);
    // Create some buckets
    vm0.invoke(new SerializableRunnable("createSomeBuckets") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            for (int i = 0; i < 12; i++) {
                Map m = new HashMap();
                for (int j = 0; j < 200; j++) {
                    m.put(Integer.valueOf(i + 113 * j), "A");
                }
                region.putAll(m);
            }
        }
    });
    // Do some puts and gets, to trigger eviction
    SerializableRunnable doOps = new SerializableRunnable("doOps") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            Random rand = new Random();
            for (int count = 0; count < 5000; count++) {
                int bucket = (int) (count % 12);
                int key = rand.nextInt(20);
                region.put(Integer.valueOf(bucket + 113 * key), "B");
            }
            for (int count = 0; count < 500; count++) {
                int bucket = (int) (count % 12);
                int key = rand.nextInt(20);
                region.get(Integer.valueOf(bucket + 113 * key));
            }
        }
    };
    // Do some operations
    vm0.invoke(doOps);
    // Create the region in one more VM.
    vm2.invoke(createPrRegion);
    // Now do a rebalance
    final Long totalSize = (Long) vm0.invoke(new SerializableCallable("simulateRebalance") {

        public Object call() {
            Cache cache = getCache();
            ResourceManager manager = cache.getResourceManager();
            RebalanceResults results = doRebalance(false, manager);
            assertEquals(0, results.getTotalBucketCreatesCompleted());
            // We don't know how many primaries will move, it depends on
            // if the move bucket code moves the primary or a redundant bucket
            // assertIndexDetailsEquals(0, results.getTotalPrimaryTransfersCompleted());
            assertEquals(8, results.getTotalBucketTransfersCompleted());
            assertTrue(0 < results.getTotalBucketTransferBytes());
            Set<PartitionRebalanceInfo> detailSet = results.getPartitionRebalanceDetails();
            assertEquals(1, detailSet.size());
            PartitionRebalanceInfo details = detailSet.iterator().next();
            assertEquals(0, details.getBucketCreatesCompleted());
            assertTrue(0 < details.getBucketTransferBytes());
            assertEquals(8, details.getBucketTransfersCompleted());
            long totalSize = 0;
            Set<PartitionMemberInfo> beforeDetails = details.getPartitionMemberDetailsAfter();
            for (PartitionMemberInfo memberDetails : beforeDetails) {
                totalSize += memberDetails.getSize();
            }
            long afterSize = 0;
            Set<PartitionMemberInfo> afterDetails = details.getPartitionMemberDetailsAfter();
            assertEquals(3, afterDetails.size());
            for (PartitionMemberInfo memberDetails : afterDetails) {
                assertEquals(8, memberDetails.getBucketCount());
                assertEquals(4, memberDetails.getPrimaryCount());
                afterSize += memberDetails.getSize();
            }
            assertEquals(totalSize, afterSize);
            verifyStats(manager, results);
            return Long.valueOf(totalSize);
        }
    });
    SerializableRunnable checkBalance = new SerializableRunnable("checkBalance") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(region);
            assertEquals(12, details.getCreatedBucketCount());
            assertEquals(1, details.getActualRedundantCopies());
            assertEquals(0, details.getLowRedundancyBucketCount());
            LogWriterUtils.getLogWriter().info("details=" + details.getPartitionMemberInfo());
            long afterSize = 0;
            for (PartitionMemberInfo memberDetails : details.getPartitionMemberInfo()) {
                assertEquals(8, memberDetails.getBucketCount());
                assertEquals(4, memberDetails.getPrimaryCount());
                afterSize += memberDetails.getSize();
            }
        // assertIndexDetailsEquals(totalSize.longValue(), afterSize);
        }
    };
    vm0.invoke(checkBalance);
    vm1.invoke(checkBalance);
    vm2.invoke(checkBalance);
    // Create the region in one more VM.
    vm3.invoke(createPrRegion);
    // Do another rebalance
    vm0.invoke(new SerializableCallable("simulateRebalance") {

        public Object call() {
            Cache cache = getCache();
            ResourceManager manager = cache.getResourceManager();
            RebalanceResults results = doRebalance(false, manager);
            assertEquals(0, results.getTotalBucketCreatesCompleted());
            // We don't know how many primaries will move, it depends on
            // if the move bucket code moves the primary or a redundant bucket
            // assertIndexDetailsEquals(0, results.getTotalPrimaryTransfersCompleted());
            assertEquals(6, results.getTotalBucketTransfersCompleted());
            assertTrue(0 < results.getTotalBucketTransferBytes());
            Set<PartitionRebalanceInfo> detailSet = results.getPartitionRebalanceDetails();
            assertEquals(1, detailSet.size());
            PartitionRebalanceInfo details = detailSet.iterator().next();
            assertEquals(0, details.getBucketCreatesCompleted());
            assertTrue(0 < details.getBucketTransferBytes());
            assertEquals(6, details.getBucketTransfersCompleted());
            long totalSize = 0;
            Set<PartitionMemberInfo> beforeDetails = details.getPartitionMemberDetailsAfter();
            for (PartitionMemberInfo memberDetails : beforeDetails) {
                totalSize += memberDetails.getSize();
            }
            long afterSize = 0;
            Set<PartitionMemberInfo> afterDetails = details.getPartitionMemberDetailsAfter();
            assertEquals(4, afterDetails.size());
            for (PartitionMemberInfo memberDetails : afterDetails) {
                assertEquals(6, memberDetails.getBucketCount());
                // assertIndexDetailsEquals(3, memberDetails.getPrimaryCount());
                afterSize += memberDetails.getSize();
            }
            assertEquals(totalSize, afterSize);
            return Long.valueOf(totalSize);
        }
    });
    checkBalance = new SerializableRunnable("checkBalance") {

        public void run() {
            Cache cache = getCache();
            Region region = cache.getRegion("region1");
            PartitionRegionInfo details = PartitionRegionHelper.getPartitionRegionInfo(region);
            assertEquals(12, details.getCreatedBucketCount());
            assertEquals(1, details.getActualRedundantCopies());
            assertEquals(0, details.getLowRedundancyBucketCount());
            LogWriterUtils.getLogWriter().info("details=" + details.getPartitionMemberInfo());
            long afterSize = 0;
            for (PartitionMemberInfo memberDetails : details.getPartitionMemberInfo()) {
                assertEquals(6, memberDetails.getBucketCount());
                // assertIndexDetailsEquals(3, memberDetails.getPrimaryCount());
                afterSize += memberDetails.getSize();
            }
        // assertIndexDetailsEquals(totalSize.longValue(), afterSize);
        }
    };
    vm0.invoke(checkBalance);
    vm1.invoke(checkBalance);
    vm2.invoke(checkBalance);
}