Examples with Range org.apache.geode.cache.management.MemoryThresholdsDUnitTest.Range used on opensource projects

Example 1 with Range

use of org.apache.geode.cache.management.MemoryThresholdsDUnitTest.Range in project geode by apache.

the class MemoryThresholdsOffHeapDUnitTest method prRemotePutRejection.

private void prRemotePutRejection(boolean cacheClose, boolean localDestroy, final boolean useTx) throws Exception {
    final Host host = Host.getHost(0);
    final VM accessor = host.getVM(0);
    final VM[] servers = new VM[3];
    servers[0] = host.getVM(1);
    servers[1] = host.getVM(2);
    servers[2] = host.getVM(3);
    final String regionName = "offHeapPRRemotePutRejection";
    final int redundancy = 1;
    startCacheServer(servers[0], 0f, 90f, regionName, true, /* createPR */
    false, /* notifyBySubscription */
    redundancy);
    startCacheServer(servers[1], 0f, 90f, regionName, true, /* createPR */
    false, /* notifyBySubscription */
    redundancy);
    startCacheServer(servers[2], 0f, 90f, regionName, true, /* createPR */
    false, /* notifyBySubscription */
    redundancy);
    accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            getSystem(getOffHeapProperties());
            getCache();
            AttributesFactory factory = new AttributesFactory();
            PartitionAttributesFactory paf = new PartitionAttributesFactory();
            paf.setRedundantCopies(redundancy);
            paf.setLocalMaxMemory(0);
            paf.setTotalNumBuckets(11);
            factory.setPartitionAttributes(paf.create());
            factory.setOffHeap(true);
            createRegion(regionName, factory.create());
            return null;
        }
    });
    doPuts(accessor, regionName, false, false);
    final Range r1 = Range.DEFAULT;
    doPutAlls(accessor, regionName, false, false, r1);
    servers[0].invoke(addExpectedException);
    servers[1].invoke(addExpectedException);
    servers[2].invoke(addExpectedException);
    setUsageAboveCriticalThreshold(servers[0], regionName);
    final Set<InternalDistributedMember> criticalMembers = (Set) servers[0].invoke(new SerializableCallable() {

        public Object call() throws Exception {
            final PartitionedRegion pr = (PartitionedRegion) getRootRegion().getSubregion(regionName);
            final int hashKey = PartitionedRegionHelper.getHashKey(pr, null, "oh5", null, null);
            return pr.getRegionAdvisor().getBucketOwners(hashKey);
        }
    });
    accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            final PartitionedRegion pr = (PartitionedRegion) getRootRegion().getSubregion(regionName);
            WaitCriterion wc = new WaitCriterion() {

                public String description() {
                    return "remote bucket not marked sick";
                }

                public boolean done() {
                    boolean keyFoundOnSickMember = false;
                    boolean caughtException = false;
                    for (int i = 0; i < 20; i++) {
                        Integer key = Integer.valueOf(i);
                        int hKey = PartitionedRegionHelper.getHashKey(pr, null, key, null, null);
                        Set<InternalDistributedMember> owners = pr.getRegionAdvisor().getBucketOwners(hKey);
                        final boolean hasCriticalOwners = owners.removeAll(criticalMembers);
                        if (hasCriticalOwners) {
                            keyFoundOnSickMember = true;
                            try {
                                if (useTx)
                                    getCache().getCacheTransactionManager().begin();
                                pr.getCache().getLogger().fine("SWAP:putting in tx:" + useTx);
                                pr.put(key, "value");
                                if (useTx)
                                    getCache().getCacheTransactionManager().commit();
                            } catch (LowMemoryException ex) {
                                caughtException = true;
                                if (useTx)
                                    getCache().getCacheTransactionManager().rollback();
                            }
                        } else {
                            // puts on healthy member should continue
                            pr.put(key, "value");
                        }
                    }
                    return keyFoundOnSickMember && caughtException;
                }
            };
            Wait.waitForCriterion(wc, 10000, 10, true);
            return null;
        }
    });
    {
        Range r2 = new Range(r1, r1.width() + 1);
        doPutAlls(accessor, regionName, false, true, r2);
    }
    // Find all VMs that have a critical region
    SerializableCallable getMyId = new SerializableCallable() {

        public Object call() throws Exception {
            return ((GemFireCacheImpl) getCache()).getMyId();
        }
    };
    final Set<VM> criticalServers = new HashSet<VM>();
    for (final VM server : servers) {
        DistributedMember member = (DistributedMember) server.invoke(getMyId);
        if (criticalMembers.contains(member)) {
            criticalServers.add(server);
        }
    }
    if (localDestroy) {
        // local destroy the region on sick members
        for (final VM vm : criticalServers) {
            vm.invoke(new SerializableCallable("local destroy sick member") {

                public Object call() throws Exception {
                    Region r = getRootRegion().getSubregion(regionName);
                    LogWriterUtils.getLogWriter().info("PRLocalDestroy");
                    r.localDestroyRegion();
                    return null;
                }
            });
        }
    } else if (cacheClose) {
        // close cache on sick members
        for (final VM vm : criticalServers) {
            vm.invoke(new SerializableCallable("close cache sick member") {

                public Object call() throws Exception {
                    getCache().close();
                    return null;
                }
            });
        }
    } else {
        setUsageBelowEviction(servers[0], regionName);
        servers[0].invoke(removeExpectedException);
        servers[1].invoke(removeExpectedException);
        servers[2].invoke(removeExpectedException);
    }
    // do put all in a loop to allow distribution of message
    accessor.invoke(new SerializableCallable("Put in a loop") {

        public Object call() throws Exception {
            final Region r = getRootRegion().getSubregion(regionName);
            WaitCriterion wc = new WaitCriterion() {

                public String description() {
                    return "pr should have gone un-critical";
                }

                public boolean done() {
                    boolean done = true;
                    for (int i = 0; i < 20; i++) {
                        try {
                            r.put(i, "value");
                        } catch (LowMemoryException e) {
                            // expected
                            done = false;
                        }
                    }
                    return done;
                }
            };
            Wait.waitForCriterion(wc, 10000, 10, true);
            return null;
        }
    });
    doPutAlls(accessor, regionName, false, false, r1);
}

Example 2 with Range

use of org.apache.geode.cache.management.MemoryThresholdsDUnitTest.Range in project geode by apache.

the class MemoryThresholdsOffHeapDUnitTest method doDistributedRegionRemotePutRejection.

/**
   * test that puts in a server are rejected when a remote VM crosses critical threshold
   * 
   * @throws Exception
   */
private void doDistributedRegionRemotePutRejection(boolean localDestroy, boolean cacheClose) throws Exception {
    final Host host = Host.getHost(0);
    final VM server1 = host.getVM(0);
    final VM server2 = host.getVM(1);
    final String regionName = "offHeapDRRemotePutRejection";
    // set port to 0 in-order for system to pickup a random port.
    startCacheServer(server1, 0f, 0f, regionName, false, /* createPR */
    false, /* notifyBySubscription */
    0);
    startCacheServer(server2, 0f, 90f, regionName, false, /* createPR */
    false, /* notifyBySubscription */
    0);
    registerTestMemoryThresholdListener(server1);
    registerTestMemoryThresholdListener(server2);
    doPuts(server1, regionName, false, /* catchRejectedException */
    false);
    doPutAlls(server1, regionName, false, /* catchRejectedException */
    false, /* catchLowMemoryException */
    Range.DEFAULT);
    // make server2 critical
    setUsageAboveCriticalThreshold(server2, regionName);
    verifyListenerValue(server1, MemoryState.CRITICAL, 1, true);
    verifyListenerValue(server2, MemoryState.CRITICAL, 1, true);
    // make sure that local server1 puts are rejected
    doPuts(server1, regionName, false, /* catchRejectedException */
    true);
    Range r1 = new Range(Range.DEFAULT, Range.DEFAULT.width() + 1);
    doPutAlls(server1, regionName, false, /* catchRejectedException */
    true, /* catchLowMemoryException */
    r1);
    if (localDestroy) {
        // local destroy the region on sick member
        server2.invoke(new SerializableCallable("local destroy") {

            public Object call() throws Exception {
                Region r = getRootRegion().getSubregion(regionName);
                r.localDestroyRegion();
                return null;
            }
        });
    } else if (cacheClose) {
        server2.invoke(new SerializableCallable() {

            public Object call() throws Exception {
                getCache().close();
                return null;
            }
        });
    } else {
        setUsageBelowEviction(server2, regionName);
    }
    // wait for remote region destroyed message to be processed
    server1.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            WaitCriterion wc = new WaitCriterion() {

                public String description() {
                    return "remote localRegionDestroyed message not received";
                }

                public boolean done() {
                    DistributedRegion dr = (DistributedRegion) getRootRegion().getSubregion(regionName);
                    return dr.getMemoryThresholdReachedMembers().size() == 0;
                }
            };
            Wait.waitForCriterion(wc, 10000, 10, true);
            return null;
        }
    });
    // make sure puts succeed
    doPuts(server1, regionName, false, /* catchRejectedException */
    false);
    Range r2 = new Range(r1, r1.width() + 1);
    doPutAlls(server1, regionName, false, /* catchRejectedException */
    false, /* catchLowMemoryException */
    r2);
}

Example 3 with Range

use of org.apache.geode.cache.management.MemoryThresholdsDUnitTest.Range in project geode by apache.

the class MemoryThresholdsOffHeapDUnitTest method testDistributedRegionRemoteClientPutRejection.

/**
   * test that puts in a client are rejected when a remote VM crosses critical threshold
   */
@Test
public void testDistributedRegionRemoteClientPutRejection() throws Exception {
    final Host host = Host.getHost(0);
    final VM server1 = host.getVM(0);
    final VM server2 = host.getVM(1);
    final VM client = host.getVM(2);
    final String regionName = "offHeapDRRemoteClientPutReject";
    final int port1 = startCacheServer(server1, 0f, 0f, regionName, false, /* createPR */
    false, /* notifyBySubscription */
    0);
    startCacheServer(server2, 0f, 90f, regionName, false, /* createPR */
    false, /* notifyBySubscription */
    0);
    startClient(client, server1, port1, regionName);
    registerTestMemoryThresholdListener(server1);
    registerTestMemoryThresholdListener(server2);
    doPuts(client, regionName, false, /* catchRejectedException */
    false);
    doPutAlls(client, regionName, false, /* catchRejectedException */
    false, /* catchLowMemoryException */
    Range.DEFAULT);
    // make server2 critical
    setUsageAboveCriticalThreshold(server2, regionName);
    verifyListenerValue(server1, MemoryState.CRITICAL, 1, true);
    verifyListenerValue(server2, MemoryState.CRITICAL, 1, true);
    // make sure that client puts are rejected
    doPuts(client, regionName, true, /* catchRejectedException */
    false);
    doPutAlls(client, regionName, true, /* catchRejectedException */
    false, /* catchLowMemoryException */
    new Range(Range.DEFAULT, Range.DEFAULT.width() + 1));
    setUsageBelowEviction(server2, regionName);
}

Example 4 with Range

use of org.apache.geode.cache.management.MemoryThresholdsDUnitTest.Range in project geode by apache.

the class MemoryThresholdsOffHeapDUnitTest method doClientServerTest.

private void doClientServerTest(final String regionName, boolean createPR) throws Exception {
    // create region on the server
    final Host host = Host.getHost(0);
    final VM server = host.getVM(0);
    final VM client = host.getVM(1);
    final Object bigKey = -1;
    final Object smallKey = -2;
    final int port = startCacheServer(server, 0f, 90f, regionName, createPR, false, 0);
    startClient(client, server, port, regionName);
    doPuts(client, regionName, false, /* catchServerException */
    false);
    doPutAlls(client, regionName, false, /* catchServerException */
    false, /* catchLowMemoryException */
    Range.DEFAULT);
    // make the region sick in the server
    final long bytesUsedAfterSmallKey = (long) server.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            InternalResourceManager irm = ((GemFireCacheImpl) getCache()).getInternalResourceManager();
            final OffHeapMemoryMonitor ohm = irm.getOffHeapMonitor();
            assertTrue(ohm.getState().isNormal());
            getCache().getLoggerI18n().fine(addExpectedExString);
            final LocalRegion r = (LocalRegion) getRootRegion().getSubregion(regionName);
            final long bytesUsedAfterSmallKey;
            {
                OffHeapMemoryMonitorObserverImpl _testHook = new OffHeapMemoryMonitorObserverImpl();
                ohm.testHook = _testHook;
                try {
                    r.put(smallKey, "1234567890");
                    bytesUsedAfterSmallKey = _testHook.verifyBeginUpdateMemoryUsed(false);
                } finally {
                    ohm.testHook = null;
                }
            }
            {
                final OffHeapMemoryMonitorObserverImpl th = new OffHeapMemoryMonitorObserverImpl();
                ohm.testHook = th;
                try {
                    r.put(bigKey, new byte[943720]);
                    th.verifyBeginUpdateMemoryUsed(bytesUsedAfterSmallKey + 943720 + 8, true);
                    WaitCriterion waitForCritical = new WaitCriterion() {

                        public boolean done() {
                            return th.checkUpdateStateAndSendEventBeforeProcess(bytesUsedAfterSmallKey + 943720 + 8, MemoryState.EVICTION_DISABLED_CRITICAL);
                        }

                        @Override
                        public String description() {
                            return null;
                        }
                    };
                    Wait.waitForCriterion(waitForCritical, 30 * 1000, 9, false);
                    th.validateUpdateStateAndSendEventBeforeProcess(bytesUsedAfterSmallKey + 943720 + 8, MemoryState.EVICTION_DISABLED_CRITICAL);
                } finally {
                    ohm.testHook = null;
                }
            }
            WaitCriterion wc;
            if (r instanceof PartitionedRegion) {
                final PartitionedRegion pr = (PartitionedRegion) r;
                final int bucketId = PartitionedRegionHelper.getHashKey(pr, null, bigKey, null, null);
                wc = new WaitCriterion() {

                    @Override
                    public String description() {
                        return "Expected to go critical: isCritical=" + ohm.getState().isCritical();
                    }

                    @Override
                    public boolean done() {
                        if (!ohm.getState().isCritical())
                            return false;
                        // Only done once the bucket has been marked sick
                        try {
                            pr.getRegionAdvisor().checkIfBucketSick(bucketId, bigKey);
                            return false;
                        } catch (LowMemoryException ignore) {
                            return true;
                        }
                    }
                };
            } else {
                wc = new WaitCriterion() {

                    @Override
                    public String description() {
                        return "Expected to go critical: isCritical=" + ohm.getState().isCritical() + " memoryThresholdReached=" + r.memoryThresholdReached.get();
                    }

                    @Override
                    public boolean done() {
                        return ohm.getState().isCritical() && r.memoryThresholdReached.get();
                    }
                };
            }
            Wait.waitForCriterion(wc, 30000, 9, true);
            getCache().getLoggerI18n().fine(removeExpectedExString);
            return bytesUsedAfterSmallKey;
        }
    });
    // make sure client puts are rejected
    doPuts(client, regionName, true, /* catchServerException */
    false);
    doPutAlls(client, regionName, true, /* catchServerException */
    false, /* catchLowMemoryException */
    new Range(Range.DEFAULT, Range.DEFAULT.width() + 1));
    // make the region healthy in the server
    server.invoke(new SerializableRunnable() {

        public void run() {
            InternalResourceManager irm = ((GemFireCacheImpl) getCache()).getInternalResourceManager();
            final OffHeapMemoryMonitor ohm = irm.getOffHeapMonitor();
            assertTrue(ohm.getState().isCritical());
            getCache().getLogger().fine(MemoryThresholdsOffHeapDUnitTest.this.addExpectedBelow);
            OffHeapMemoryMonitorObserverImpl _testHook = new OffHeapMemoryMonitorObserverImpl();
            ohm.testHook = _testHook;
            try {
                getRootRegion().getSubregion(regionName).destroy(bigKey);
                _testHook.verifyBeginUpdateMemoryUsed(bytesUsedAfterSmallKey, true);
            } finally {
                ohm.testHook = null;
            }
            WaitCriterion wc = new WaitCriterion() {

                @Override
                public String description() {
                    return "Expected to go normal";
                }

                @Override
                public boolean done() {
                    return ohm.getState().isNormal();
                }
            };
            Wait.waitForCriterion(wc, 30000, 9, true);
            getCache().getLogger().fine(MemoryThresholdsOffHeapDUnitTest.this.removeExpectedBelow);
            return;
        }
    });
}