Examples with FunctionContext org.apache.geode.cache.execute.FunctionContext used on opensource projects

Example 11 with FunctionContext

use of org.apache.geode.cache.execute.FunctionContext in project geode by apache.

the class RegionValue method testLocalDataSetIndexing.

@Test
public void testLocalDataSetIndexing() {
    final CacheSerializableRunnable createPRs = new CacheSerializableRunnable("create prs ") {

        public void run2() {
            AttributesFactory<Integer, RegionValue> factory = new AttributesFactory<Integer, RegionValue>();
            factory.setPartitionAttributes(new PartitionAttributesFactory<Integer, RegionValue>().setRedundantCopies(1).setTotalNumBuckets(8).create());
            final PartitionedRegion pr1 = (PartitionedRegion) createRootRegion("pr1", factory.create());
            factory = new AttributesFactory<Integer, RegionValue>();
            factory.setPartitionAttributes(new PartitionAttributesFactory<Integer, RegionValue>().setRedundantCopies(1).setTotalNumBuckets(8).setColocatedWith(pr1.getName()).create());
            final PartitionedRegion pr2 = (PartitionedRegion) createRootRegion("pr2", factory.create());
        }
    };
    final CacheSerializableRunnable createIndexesOnPRs = new CacheSerializableRunnable("create prs ") {

        public void run2() {
            try {
                QueryService qs = getCache().getQueryService();
                qs.createIndex("valueIndex1", IndexType.FUNCTIONAL, "e1.value", "/pr1 e1");
                qs.createIndex("valueIndex2", IndexType.FUNCTIONAL, "e2.value", "/pr2 e2");
            } catch (Exception e) {
                org.apache.geode.test.dunit.Assert.fail("Test failed due to Exception in index creation ", e);
            }
        }
    };
    final CacheSerializableRunnable execute = new CacheSerializableRunnable("execute function") {

        public void run2() {
            final PartitionedRegion pr1 = (PartitionedRegion) getRootRegion("pr1");
            final PartitionedRegion pr2 = (PartitionedRegion) getRootRegion("pr2");
            final Set<Integer> filter = new HashSet<Integer>();
            for (int i = 1; i <= 80; i++) {
                pr1.put(i, new RegionValue(i));
                if (i <= 20) {
                    pr2.put(i, new RegionValue(i));
                    if ((i % 5) == 0) {
                        filter.add(i);
                    }
                }
            }
            ArrayList<List> result = (ArrayList<List>) FunctionService.onRegion(pr1).withFilter(filter).execute(new FunctionAdapter() {

                public void execute(FunctionContext context) {
                    try {
                        RegionFunctionContext rContext = (RegionFunctionContext) context;
                        Region pr1 = rContext.getDataSet();
                        LocalDataSet localCust = (LocalDataSet) PartitionRegionHelper.getLocalDataForContext(rContext);
                        Map<String, Region<?, ?>> colocatedRegions = PartitionRegionHelper.getColocatedRegions(pr1);
                        Map<String, Region<?, ?>> localColocatedRegions = PartitionRegionHelper.getLocalColocatedRegions(rContext);
                        Region pr2 = colocatedRegions.get("/pr2");
                        LocalDataSet localOrd = (LocalDataSet) localColocatedRegions.get("/pr2");
                        QueryObserverImpl observer = new QueryObserverImpl();
                        QueryObserverHolder.setInstance(observer);
                        QueryService qs = pr1.getCache().getQueryService();
                        DefaultQuery query = (DefaultQuery) qs.newQuery("select distinct e1.value from /pr1 e1, /pr2  e2 where e1.value=e2.value");
                        GemFireCacheImpl.getInstance().getLogger().fine(" Num BUCKET SET: " + localCust.getBucketSet());
                        GemFireCacheImpl.getInstance().getLogger().fine("VALUES FROM PR1 bucket:");
                        for (Integer bId : localCust.getBucketSet()) {
                            BucketRegion br = ((PartitionedRegion) pr1).getDataStore().getLocalBucketById(bId);
                            String val = "";
                            for (Object e : br.values()) {
                                val += (e + ",");
                            }
                            GemFireCacheImpl.getInstance().getLogger().fine(": " + val);
                        }
                        GemFireCacheImpl.getInstance().getLogger().fine("VALUES FROM PR2 bucket:");
                        for (Integer bId : localCust.getBucketSet()) {
                            BucketRegion br = ((PartitionedRegion) pr2).getDataStore().getLocalBucketById(bId);
                            String val = "";
                            for (Object e : br.values()) {
                                val += (e + ",");
                            }
                            GemFireCacheImpl.getInstance().getLogger().fine(": " + val);
                        }
                        SelectResults r = (SelectResults) localCust.executeQuery(query, null, localCust.getBucketSet());
                        GemFireCacheImpl.getInstance().getLogger().fine("Result :" + r.asList());
                        Assert.assertTrue(observer.isIndexesUsed);
                        pr1.getCache().getLogger().fine("Index Used: " + observer.numIndexesUsed());
                        Assert.assertTrue(2 == observer.numIndexesUsed());
                        context.getResultSender().lastResult((Serializable) r.asList());
                    } catch (Exception e) {
                        context.getResultSender().lastResult(Boolean.TRUE);
                    }
                }

                @Override
                public String getId() {
                    return "ok";
                }

                @Override
                public boolean optimizeForWrite() {
                    return false;
                }
            }).getResult();
            int numResults = 0;
            for (List oneNodeResult : result) {
                GemFireCacheImpl.getInstance().getLogger().fine("Result :" + numResults + " oneNodeResult.size(): " + oneNodeResult.size() + " oneNodeResult :" + oneNodeResult);
                numResults = +oneNodeResult.size();
            }
            Assert.assertTrue(10 == numResults);
        }
    };
    dataStore1.invoke(createPRs);
    dataStore2.invoke(createPRs);
    dataStore1.invoke(createIndexesOnPRs);
    dataStore1.invoke(execute);
}

Example 12 with FunctionContext

use of org.apache.geode.cache.execute.FunctionContext in project geode by apache.

the class MemberFunctionExecutionDUnitTest method excuteOnMembers_InlineFunction.

/*
   * Execute Function
   */
public static void excuteOnMembers_InlineFunction(Integer noOfMembers) {
    assertNotNull(ds);
    Execution memberExcution = null;
    if (noOfMembers.intValue() == 1) {
        // Local VM
        DistributedMember localmember = ds.getDistributedMember();
        memberExcution = FunctionService.onMember(localmember);
    } else if (noOfMembers.intValue() == 5) {
        memberExcution = FunctionService.onMembers();
    } else {
        Set memberSet = new HashSet(ds.getDistributionManager().getNormalDistributionManagerIds());
        InternalDistributedMember localVM = ds.getDistributionManager().getDistributionManagerId();
        memberSet.remove(localVM);
        memberExcution = FunctionService.onMembers(memberSet);
    }
    Execution executor = memberExcution.setArguments("Key");
    try {
        ResultCollector rc = executor.execute(new FunctionAdapter() {

            @Override
            public void execute(FunctionContext context) {
                if (context.getArguments() instanceof String) {
                    context.getResultSender().lastResult("Success");
                } else {
                    context.getResultSender().lastResult("Failure");
                }
            }

            @Override
            public String getId() {
                return getClass().getName();
            }

            @Override
            public boolean hasResult() {
                return true;
            }
        });
        List li = (ArrayList) rc.getResult();
        LogWriterUtils.getLogWriter().info("MemberFunctionExecutionDUnitTest#excuteOnMembers: Result : " + li);
        assertEquals(li.size(), noOfMembers.intValue());
        for (Object obj : li) {
            assertEquals(obj, "Success");
        }
    } catch (Exception e) {
        LogWriterUtils.getLogWriter().info("Exception Occurred : " + e.getMessage());
        e.printStackTrace();
        Assert.fail("Test failed", e);
    }
}

Example 13 with FunctionContext

use of org.apache.geode.cache.execute.FunctionContext in project geode by apache.

the class MemberFunctionExecutionDUnitTest method testOnMembersWithoutCache.

@Test
public void testOnMembersWithoutCache() throws Exception {
    DistributedMember member1Id = (DistributedMember) member1.invoke(new SerializableCallable() {

        @Override
        public Object call() {
            disconnectFromDS();
            return getSystem().getDistributedMember();
        }
    });
    member2.invoke(new SerializableRunnable() {

        @Override
        public void run() {
            getSystem();
            ResultCollector<?, ?> rc = FunctionService.onMember(member1Id).execute(new FunctionAdapter() {

                @Override
                public String getId() {
                    return getClass().getName();
                }

                @Override
                public void execute(FunctionContext context) {
                    // This will throw an exception because the cache is not yet created.
                    CacheFactory.getAnyInstance();
                }
            });
            try {
                rc.getResult(30, TimeUnit.SECONDS);
                fail("Should have seen an exception");
            } catch (Exception e) {
                if (!(e.getCause() instanceof FunctionInvocationTargetException)) {
                    Assert.fail("failed", e);
                }
            }
        }
    });
}

Example 14 with FunctionContext

use of org.apache.geode.cache.execute.FunctionContext in project geode by apache.

the class RemoteTransactionDUnitTest method testDRFunctionExecution.

@Test
public void testDRFunctionExecution() {
    Host host = Host.getHost(0);
    VM accessor = host.getVM(0);
    VM datastore1 = host.getVM(1);
    VM datastore2 = host.getVM(2);
    class CreateDR extends SerializableCallable {

        private final boolean isAccessor;

        public CreateDR(boolean isAccessor) {
            this.isAccessor = isAccessor;
        }

        public Object call() throws Exception {
            AttributesFactory af = new AttributesFactory();
            af.setDataPolicy(isAccessor ? DataPolicy.EMPTY : DataPolicy.REPLICATE);
            af.setScope(Scope.DISTRIBUTED_ACK);
            af.setConcurrencyChecksEnabled(getConcurrencyChecksEnabled());
            getCache().createRegion(CUSTOMER, af.create());
            if (isAccessor) {
                Region custRegion = getCache().getRegion(CUSTOMER);
                for (int i = 0; i < 5; i++) {
                    CustId custId = new CustId(i);
                    Customer customer = new Customer("customer" + i, "address" + i);
                    custRegion.put(custId, customer);
                }
            }
            return null;
        }
    }
    datastore1.invoke(new CreateDR(false));
    datastore2.invoke(new CreateDR(false));
    accessor.invoke(new CreateDR(true));
    SerializableCallable registerFunction = new SerializableCallable() {

        public Object call() throws Exception {
            FunctionService.registerFunction(new TXFunction());
            return null;
        }
    };
    accessor.invoke(registerFunction);
    datastore1.invoke(registerFunction);
    datastore2.invoke(registerFunction);
    accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            Region custRegion = getGemfireCache().getRegion(CUSTOMER);
            TXManagerImpl mgr = getGemfireCache().getTXMgr();
            mgr.begin();
            FunctionService.onRegion(custRegion).execute(TXFunction.id).getResult();
            assertNotNull(mgr.getTXState());
            TXStateProxy tx = mgr.internalSuspend();
            assertNull(mgr.getTXState());
            getGemfireCache().getLogger().fine("SWAP:callingget");
            assertNull("expected null but was:" + custRegion.get(expectedCustId), custRegion.get(expectedCustId));
            mgr.internalResume(tx);
            mgr.commit();
            assertEquals(expectedCustomer, custRegion.get(expectedCustId));
            return null;
        }
    });
    datastore1.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            final Region custRegion = getGemfireCache().getRegion(CUSTOMER);
            TXManagerImpl mgr = getGemfireCache().getTXMgr();
            mgr.begin();
            FunctionService.onRegion(custRegion).execute(new FunctionAdapter() {

                @Override
                public String getId() {
                    return "LocalDS";
                }

                @Override
                public void execute(FunctionContext context) {
                    assertNotNull(getGemfireCache().getTxManager().getTXState());
                    custRegion.destroy(expectedCustId);
                    context.getResultSender().lastResult(Boolean.TRUE);
                }
            }).getResult();
            TXStateProxy tx = mgr.internalSuspend();
            assertEquals(custRegion.get(expectedCustId), expectedCustomer);
            mgr.internalResume(tx);
            mgr.commit();
            assertNull(custRegion.get(expectedCustId));
            return null;
        }
    });
}

Example 15 with FunctionContext

use of org.apache.geode.cache.execute.FunctionContext in project geode by apache.

the class RemoteTransactionDUnitTest method testNestedTxFunction.

@Test
public void testNestedTxFunction() {
    Host host = Host.getHost(0);
    VM accessor = host.getVM(0);
    VM datastore1 = host.getVM(1);
    VM datastore2 = host.getVM(2);
    initAccessorAndDataStore(accessor, datastore1, datastore2, 0);
    class NestedTxFunction2 extends FunctionAdapter {

        static final String id = "NestedTXFunction2";

        @Override
        public void execute(FunctionContext context) {
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            assertNotNull(mgr.getTXState());
            try {
                mgr.commit();
                fail("expected exceptio not thrown");
            } catch (UnsupportedOperationInTransactionException e) {
            }
            context.getResultSender().lastResult(Boolean.TRUE);
        }

        @Override
        public String getId() {
            return id;
        }
    }
    class NestedTxFunction extends FunctionAdapter {

        static final String id = "NestedTXFunction";

        @Override
        public void execute(FunctionContext context) {
            Region r = null;
            if (context instanceof RegionFunctionContext) {
                r = PartitionRegionHelper.getLocalDataForContext((RegionFunctionContext) context);
            } else {
                r = getGemfireCache().getRegion(CUSTOMER);
            }
            assertNotNull(getGemfireCache().getTxManager().getTXState());
            PartitionedRegion pr = (PartitionedRegion) getGemfireCache().getRegion(CUSTOMER);
            Set filter = new HashSet();
            filter.add(expectedCustId);
            LogWriterUtils.getLogWriter().info("SWAP:inside NestedTxFunc calling func2:");
            r.put(expectedCustId, expectedCustomer);
            FunctionService.onRegion(pr).withFilter(filter).execute(new NestedTxFunction2()).getResult();
            assertNotNull(getGemfireCache().getTxManager().getTXState());
            context.getResultSender().lastResult(Boolean.TRUE);
        }

        @Override
        public boolean optimizeForWrite() {
            return true;
        }

        @Override
        public String getId() {
            return id;
        }
    }
    accessor.invoke(new SerializableCallable() {

        public Object call() throws Exception {
            TXManagerImpl mgr = getGemfireCache().getTxManager();
            PartitionedRegion pr = (PartitionedRegion) getGemfireCache().getRegion(CUSTOMER);
            mgr.begin();
            Set filter = new HashSet();
            filter.add(expectedCustId);
            FunctionService.onRegion(pr).withFilter(filter).execute(new NestedTxFunction()).getResult();
            assertNotNull(getGemfireCache().getTxManager().getTXState());
            mgr.commit();
            assertEquals(expectedCustomer, pr.get(expectedCustId));
            return null;
        }
    });
}