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

Example 1 with FunctionAdapter

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

the class FunctionServiceStatsDUnitTest method testP2PMembersFunctionExecutionStats.

/**
   * Test the execution of function on all memebers haveResults = true
   * 
   * member1 calls for the function executions sp the results received on memeber 1 should be equal
   * to the no of function execution calls. Function Execution should happen on all other members
   * too. so the no of function execution calls and no of function executions completed should be
   * equal tio the no of functions from member 1
   */
@Test
public void testP2PMembersFunctionExecutionStats() throws Exception {
    Host host = Host.getHost(0);
    VM member1 = host.getVM(0);
    VM member2 = host.getVM(1);
    VM member3 = host.getVM(2);
    VM member4 = host.getVM(3);
    SerializableCallable connectToDistributedSystem = new SerializableCallable("connectToDistributedSystem") {

        public Object call() throws Exception {
            Properties props = new Properties();
            try {
                ds = getSystem(props);
                assertNotNull(ds);
            } catch (Exception e) {
                Assert.fail("Failed while creating the Distribued System", e);
            }
            return Boolean.TRUE;
        }
    };
    member1.invoke(connectToDistributedSystem);
    member2.invoke(connectToDistributedSystem);
    member3.invoke(connectToDistributedSystem);
    member4.invoke(connectToDistributedSystem);
    member1.invoke(initializeStats);
    member2.invoke(initializeStats);
    member3.invoke(initializeStats);
    member4.invoke(initializeStats);
    final int noOfMembers = 1;
    final Function inlineFunction = new FunctionAdapter() {

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

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

        public boolean hasResult() {
            return true;
        }
    };
    member1.invoke(new SerializableCallable("excuteOnMembers_InlineFunction") {

        public Object call() throws Exception {
            assertNotNull(ds);
            Execution memberExecution = null;
            DistributedMember localmember = ds.getDistributedMember();
            memberExecution = FunctionService.onMember(localmember);
            memberExecution.setArguments("Key");
            try {
                ResultCollector rc = memberExecution.execute(inlineFunction);
                int size = ((List) rc.getResult()).size();
                resultReceived_Aggregate += size;
                noOfExecutionCalls_Aggregate++;
                noOfExecutionsCompleted_Aggregate++;
                resultReceived_Inline += size;
                noOfExecutionCalls_Inline++;
                noOfExecutionsCompleted_Inline++;
            } catch (Exception e) {
                LogWriterUtils.getLogWriter().info("Exception Occurred : " + e.getMessage());
                e.printStackTrace();
                Assert.fail("Test failed", e);
            }
            return Boolean.TRUE;
        }
    });
    member1.invoke(new SerializableCallable("checkFunctionExecutionStatsForMember1") {

        public Object call() throws Exception {
            FunctionServiceStats functionServiceStats = ds.getFunctionServiceStats();
            waitNoFunctionsRunning(functionServiceStats);
            assertEquals(noOfExecutionCalls_Aggregate, functionServiceStats.getFunctionExecutionCalls());
            assertEquals(noOfExecutionsCompleted_Aggregate, functionServiceStats.getFunctionExecutionsCompleted());
            assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
            FunctionStats functionStats = FunctionStats.getFunctionStats(inlineFunction.getId(), ds);
            assertEquals(noOfExecutionCalls_Inline, functionStats.getFunctionExecutionCalls());
            assertEquals(noOfExecutionsCompleted_Inline, functionStats.getFunctionExecutionsCompleted());
            assertEquals(resultReceived_Inline, functionStats.getResultsReceived());
            return Boolean.TRUE;
        }
    });
    SerializableCallable checkFunctionExecutionStatsForOtherMember = new SerializableCallable("checkFunctionExecutionStatsForOtherMember") {

        public Object call() throws Exception {
            FunctionServiceStats functionServiceStats = ds.getFunctionServiceStats();
            waitNoFunctionsRunning(functionServiceStats);
            // One function Execution took place on there members
            // noOfExecutionCalls_Aggregate++;
            // noOfExecutionsCompleted_Aggregate++;
            assertEquals(noOfExecutionCalls_Aggregate, functionServiceStats.getFunctionExecutionCalls());
            assertEquals(noOfExecutionsCompleted_Aggregate, functionServiceStats.getFunctionExecutionsCompleted());
            FunctionStats functionStats = FunctionStats.getFunctionStats(inlineFunction.getId(), ds);
            // noOfExecutionCalls_Inline++;
            // noOfExecutionsCompleted_Inline++;
            assertEquals(noOfExecutionCalls_Inline, functionStats.getFunctionExecutionCalls());
            assertEquals(noOfExecutionsCompleted_Inline, functionStats.getFunctionExecutionsCompleted());
            return Boolean.TRUE;
        }
    };
    member2.invoke(checkFunctionExecutionStatsForOtherMember);
    member3.invoke(checkFunctionExecutionStatsForOtherMember);
    member4.invoke(checkFunctionExecutionStatsForOtherMember);
    SerializableCallable closeDistributedSystem = new SerializableCallable("closeDistributedSystem") {

        public Object call() throws Exception {
            if (getCache() != null && !getCache().isClosed()) {
                getCache().close();
                getCache().getDistributedSystem().disconnect();
            }
            return Boolean.TRUE;
        }
    };
    member1.invoke(closeDistributedSystem);
    member2.invoke(closeDistributedSystem);
    member3.invoke(closeDistributedSystem);
    member4.invoke(closeDistributedSystem);
}

Example 2 with FunctionAdapter

use of org.apache.geode.cache.execute.FunctionAdapter 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 3 with FunctionAdapter

use of org.apache.geode.cache.execute.FunctionAdapter 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 4 with FunctionAdapter

use of org.apache.geode.cache.execute.FunctionAdapter 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 5 with FunctionAdapter

use of org.apache.geode.cache.execute.FunctionAdapter 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;
        }
    });
}