Examples with SerializableRunnableIF org.apache.geode.test.dunit.SerializableRunnableIF used on opensource projects

Example 1 with SerializableRunnableIF

use of org.apache.geode.test.dunit.SerializableRunnableIF in project geode by apache.

the class PartitionedRegionQueryDUnitTest method createIndexDoesNotDerializePdxObjects.

private void createIndexDoesNotDerializePdxObjects(final SerializableRunnableIF createIndex, final String queryString, PdxAssetFactory valueSupplier) {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    SerializableRunnableIF createPR = () -> {
        Cache cache = getCache();
        PartitionAttributesFactory paf = new PartitionAttributesFactory();
        paf.setTotalNumBuckets(10);
        cache.createRegionFactory(RegionShortcut.PARTITION).setPartitionAttributes(paf.create()).create("region");
    };
    vm0.invoke(createPR);
    vm1.invoke(createPR);
    // Do Puts. These objects can't be deserialized because they throw
    // and exception from the constructor
    vm0.invoke(() -> {
        Cache cache = getCache();
        Region region = cache.getRegion("region");
        region.put(0, new PdxNotDeserializableAsset(0, "B"));
        region.put(10, new PdxNotDeserializableAsset(1, "B"));
        region.put(1, new PdxNotDeserializableAsset(1, "B"));
        IntStream.range(11, 100).forEach(i -> region.put(i, valueSupplier.getAsset(i)));
    });
    // If this tries to deserialize the assets, it will fail
    vm0.invoke(createIndex);
    vm0.invoke(() -> {
        QueryService qs = getCache().getQueryService();
        SelectResults<Struct> results = (SelectResults) qs.newQuery(queryString).execute();
        assertEquals(3, results.size());
        final Index index = qs.getIndex(getCache().getRegion("region"), "ContractDocumentIndex");
        assertEquals(1, index.getStatistics().getTotalUses());
    });
}

Example 2 with SerializableRunnableIF

use of org.apache.geode.test.dunit.SerializableRunnableIF in project geode by apache.

the class PartitionedRegionQueryDUnitTest method testHashIndexDoesNotDeserializePdxObjects.

@Test
public void testHashIndexDoesNotDeserializePdxObjects() {
    SerializableRunnableIF createIndex = () -> {
        Cache cache = getCache();
        cache.getQueryService().createHashIndex("ContractDocumentIndex", "document", "/region");
    };
    String queryString = "select assetId,document from /region where document='B' limit 1000";
    PdxAssetFactory value = i -> new PdxNotDeserializableAsset(i, Integer.toString(i));
    createIndexDoesNotDerializePdxObjects(createIndex, queryString, value);
}

Example 3 with SerializableRunnableIF

use of org.apache.geode.test.dunit.SerializableRunnableIF in project geode by apache.

the class RegionReliabilityTestCase method testCommitDistributionException.

@Test
public void testCommitDistributionException() throws Exception {
    if (getRegionScope().isGlobal())
        // skip test under Global
        return;
    if (getRegionScope().isDistributedNoAck())
        // skip test under DistributedNoAck
        return;
    final String name = this.getUniqueName();
    final String roleA = name + "-A";
    final String[] requiredRoles = { roleA };
    Set requiredRolesSet = new HashSet();
    for (int i = 0; i < requiredRoles.length; i++) {
        requiredRolesSet.add(InternalRole.getRole(requiredRoles[i]));
    }
    assertEquals(requiredRoles.length, requiredRolesSet.size());
    // connect controller to system...
    Properties config = new Properties();
    config.setProperty(ROLES, "");
    getSystem(config);
    GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
    RegionMembershipListener listener = new RegionMembershipListenerAdapter() {

        public void afterRemoteRegionDeparture(RegionEvent event) {
            synchronized (detectedDeparture_testCommitDistributionException) {
                detectedDeparture_testCommitDistributionException[0] = Boolean.TRUE;
                detectedDeparture_testCommitDistributionException.notify();
            }
        }
    };
    // create region in controller...
    MembershipAttributes ra = new MembershipAttributes(requiredRoles, LossAction.NO_ACCESS, ResumptionAction.NONE);
    AttributesFactory fac = new AttributesFactory();
    fac.setMembershipAttributes(ra);
    fac.setScope(getRegionScope());
    fac.addCacheListener(listener);
    RegionAttributes attr = fac.create();
    Region region = createRootRegion(name, attr);
    // use vm1 to create role
    Host.getHost(0).getVM(1).invoke(new CacheSerializableRunnable("Create Region") {

        public void run2() throws CacheException {
            createConnection(new String[] { roleA });
            AttributesFactory fac = new AttributesFactory();
            fac.setScope(getRegionScope());
            RegionAttributes attr = fac.create();
            createRootRegion(name, attr);
        }
    });
    // define the afterReleaseLocalLocks callback
    SerializableRunnableIF removeRequiredRole = new SerializableRunnableIF() {

        public void run() {
            Host.getHost(0).getVM(1).invoke(new SerializableRunnable("Close Region") {

                public void run() {
                    getRootRegion(name).close();
                }
            });
            try {
                synchronized (detectedDeparture_testCommitDistributionException) {
                    while (detectedDeparture_testCommitDistributionException[0] == Boolean.FALSE) {
                        detectedDeparture_testCommitDistributionException.wait();
                    }
                }
            } catch (InterruptedException e) {
                fail("interrupted");
            }
        }
    };
    // define the add and remove expected exceptions
    final String expectedExceptions = "org.apache.geode.internal.cache.CommitReplyException";
    SerializableRunnable addExpectedExceptions = new CacheSerializableRunnable("addExpectedExceptions") {

        public void run2() throws CacheException {
            getCache().getLogger().info("<ExpectedException action=add>" + expectedExceptions + "</ExpectedException>");
        }
    };
    SerializableRunnable removeExpectedExceptions = new CacheSerializableRunnable("removeExpectedExceptions") {

        public void run2() throws CacheException {
            getCache().getLogger().info("<ExpectedException action=remove>" + expectedExceptions + "</ExpectedException>");
        }
    };
    // perform the actual test...
    CacheTransactionManager ctm = cache.getCacheTransactionManager();
    ctm.begin();
    TXStateInterface txStateProxy = ((TXManagerImpl) ctm).getTXState();
    ((TXStateProxyImpl) txStateProxy).forceLocalBootstrap();
    TXState txState = (TXState) ((TXStateProxyImpl) txStateProxy).getRealDeal(null, null);
    txState.setBeforeSend(() -> {
        try {
            removeRequiredRole.run();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });
    // now start a transaction and commit it
    region.put("KEY", "VAL");
    addExpectedExceptions.run();
    Host.getHost(0).getVM(1).invoke(addExpectedExceptions);
    try {
        ctm.commit();
        fail("Should have thrown CommitDistributionException");
    } catch (CommitDistributionException e) {
    // pass
    } finally {
        removeExpectedExceptions.run();
        Host.getHost(0).getVM(1).invoke(removeExpectedExceptions);
    }
}

Example 4 with SerializableRunnableIF

use of org.apache.geode.test.dunit.SerializableRunnableIF in project geode by apache.

the class MixedObjectIndexDUnitTest method luceneMustIndexFieldsWithMixedObjects.

@Test
@Parameters(method = "getPartitionRegionTypes")
public void luceneMustIndexFieldsWithMixedObjects(RegionTestableType regionTestableType) {
    SerializableRunnableIF createIndexOnTextAndDataField = getSerializableRunnableIFCreateIndexOnFieldData();
    dataStore1.invoke(() -> initDataStore(createIndexOnTextAndDataField, regionTestableType));
    dataStore2.invoke(() -> initDataStore(createIndexOnTextAndDataField, regionTestableType));
    accessor.invoke(() -> initDataStore(createIndexOnTextAndDataField, regionTestableType));
    accessor.invoke(() -> {
        Region region = getCache().getRegion(REGION_NAME);
        IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
        IntStream.range(NUM_BUCKETS, 2 * NUM_BUCKETS).forEach(i -> region.put(i, new TestObjectWithSameFieldName("hello world")));
        IntStream.range(2 * NUM_BUCKETS, 3 * NUM_BUCKETS).forEach(i -> region.put(i, new TestObjectWithNoCommonField("hello world")));
    });
    waitForFlushBeforeExecuteTextSearch(accessor, 60000);
    accessor.invoke(() -> {
        LuceneService luceneService = LuceneServiceProvider.get(getCache());
        LuceneQuery luceneQueryForTextField = luceneService.createLuceneQueryFactory().setLimit(100).create(INDEX_NAME, REGION_NAME, "world", "text");
        List luceneResults = luceneQueryForTextField.findResults();
        validateObjectResultCounts(luceneResults, TestObject.class, NUM_BUCKETS, TestObjectWithSameFieldName.class, NUM_BUCKETS, TestObjectWithNoCommonField.class, 0);
        luceneQueryForTextField = luceneService.createLuceneQueryFactory().setLimit(100).create(INDEX_NAME, REGION_NAME, "world", "data");
        luceneResults = luceneQueryForTextField.findResults();
        validateObjectResultCounts(luceneResults, TestObject.class, 0, TestObjectWithSameFieldName.class, 0, TestObjectWithNoCommonField.class, NUM_BUCKETS);
    });
}

Example 5 with SerializableRunnableIF

use of org.apache.geode.test.dunit.SerializableRunnableIF in project geode by apache.

the class MixedObjectIndexDUnitTest method luceneCanIndexFieldsWithSameNameButInDifferentObjects.

@Test
@Parameters(method = "getPartitionRegionTypes")
public void luceneCanIndexFieldsWithSameNameButInDifferentObjects(RegionTestableType regionTestType) {
    SerializableRunnableIF createIndex = getSerializableRunnableIFCreateIndexOnFieldText();
    dataStore1.invoke(() -> initDataStore(createIndex, regionTestType));
    dataStore2.invoke(() -> initDataStore(createIndex, regionTestType));
    accessor.invoke(() -> initDataStore(createIndex, regionTestType));
    accessor.invoke(() -> {
        Region region = getCache().getRegion(REGION_NAME);
        IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
        IntStream.range(NUM_BUCKETS, (2 * NUM_BUCKETS)).forEach(i -> region.put(i, new TestObjectWithSameFieldName("hello world 2")));
    });
    waitForFlushBeforeExecuteTextSearch(accessor, 60000);
    accessor.invoke(() -> {
        LuceneService luceneService = LuceneServiceProvider.get(getCache());
        LuceneQuery luceneQuery = luceneService.createLuceneQueryFactory().setLimit(100).create(INDEX_NAME, REGION_NAME, "world", "text");
        List resultList = luceneQuery.findResults();
        int objectType_1_count = 0;
        int objectType_2_count = 0;
        for (Object luceneResultStruct : resultList) {
            if (((LuceneResultStruct) luceneResultStruct).getValue() instanceof TestObject) {
                objectType_1_count++;
            } else if (((LuceneResultStruct) luceneResultStruct).getValue() instanceof TestObjectWithSameFieldName) {
                objectType_2_count++;
            }
        }
        assertEquals(NUM_BUCKETS, objectType_1_count);
        assertEquals(NUM_BUCKETS, objectType_2_count);
    });
}