Examples with DistributedSystem org.apache.geode.distributed.DistributedSystem used on opensource projects

Example 11 with DistributedSystem

use of org.apache.geode.distributed.DistributedSystem in project geode by apache.

the class FunctionServiceStatsDUnitTest method testClientServerDistributedRegionFunctionExecutionStats.

/**
   * 1-client 3-Servers server1 : Replicate server2 : Replicate server3 : Replicate client : Empty
   * Function : TEST_FUNCTION2 Execution of the function on serverRegion with set multiple keys as
   * the routing object and using the name of the function
   * 
   * On server side, function execution calls should be equal to the no of function executions
   * completed.
   */
@Test
public void testClientServerDistributedRegionFunctionExecutionStats() {
    final String regionName = "FunctionServiceStatsDUnitTest";
    SerializableCallable createCahenServer = new SerializableCallable("createCahenServer") {

        public Object call() throws Exception {
            try {
                Properties props = new Properties();
                DistributedSystem ds = getSystem(props);
                assertNotNull(ds);
                ds.disconnect();
                ds = getSystem(props);
                cache = CacheFactory.create(ds);
                LogWriterUtils.getLogWriter().info("Created Cache on Server");
                assertNotNull(cache);
                AttributesFactory factory = new AttributesFactory();
                factory.setScope(Scope.DISTRIBUTED_ACK);
                factory.setDataPolicy(DataPolicy.REPLICATE);
                assertNotNull(cache);
                Region region = cache.createRegion(regionName, factory.create());
                LogWriterUtils.getLogWriter().info("Region Created :" + region);
                assertNotNull(region);
                for (int i = 1; i <= 200; i++) {
                    region.put("execKey-" + i, new Integer(i));
                }
                CacheServer server = cache.addCacheServer();
                assertNotNull(server);
                int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
                server.setPort(port);
                try {
                    server.start();
                } catch (IOException e) {
                    Assert.fail("Failed to start the Server", e);
                }
                assertTrue(server.isRunning());
                return new Integer(server.getPort());
            } catch (Exception e) {
                Assert.fail("FunctionServiceStatsDUnitTest#createCache() Failed while creating the cache", e);
                throw e;
            }
        }
    };
    final Integer port1 = (Integer) server1.invoke(createCahenServer);
    final Integer port2 = (Integer) server2.invoke(createCahenServer);
    final Integer port3 = (Integer) server3.invoke(createCahenServer);
    SerializableCallable createCaheInClient = new SerializableCallable("createCaheInClient") {

        public Object call() throws Exception {
            try {
                Properties props = new Properties();
                props.put(MCAST_PORT, "0");
                props.put(LOCATORS, "");
                DistributedSystem ds = getSystem(props);
                assertNotNull(ds);
                ds.disconnect();
                ds = getSystem(props);
                cache = CacheFactory.create(ds);
                LogWriterUtils.getLogWriter().info("Created Cache on Client");
                assertNotNull(cache);
                CacheServerTestUtil.disableShufflingOfEndpoints();
                Pool p;
                try {
                    p = PoolManager.createFactory().addServer("localhost", port1.intValue()).addServer("localhost", port2.intValue()).addServer("localhost", port3.intValue()).setPingInterval(250).setSubscriptionEnabled(false).setSubscriptionRedundancy(-1).setReadTimeout(2000).setSocketBufferSize(1000).setMinConnections(6).setMaxConnections(10).setRetryAttempts(3).create("FunctionServiceStatsDUnitTest_pool");
                } finally {
                    CacheServerTestUtil.enableShufflingOfEndpoints();
                }
                AttributesFactory factory = new AttributesFactory();
                factory.setScope(Scope.LOCAL);
                factory.setDataPolicy(DataPolicy.EMPTY);
                factory.setPoolName(p.getName());
                assertNotNull(cache);
                Region region = cache.createRegion(regionName, factory.create());
                LogWriterUtils.getLogWriter().info("Client Region Created :" + region);
                assertNotNull(region);
                for (int i = 1; i <= 200; i++) {
                    region.put("execKey-" + i, new Integer(i));
                }
                return Boolean.TRUE;
            } catch (Exception e) {
                Assert.fail("FunctionServiceStatsDUnitTest#createCache() Failed while creating the cache", e);
                throw e;
            }
        }
    };
    client.invoke(createCaheInClient);
    client.invoke(initializeStats);
    server1.invoke(initializeStats);
    server2.invoke(initializeStats);
    server3.invoke(initializeStats);
    Function function = new TestFunction(true, TestFunction.TEST_FUNCTION2);
    registerFunctionAtServer(function);
    function = new TestFunction(true, TestFunction.TEST_FUNCTION3);
    registerFunctionAtServer(function);
    SerializableCallable ExecuteFunctions = new SerializableCallable("PopulateRegionAndExecuteFunctions") {

        public Object call() throws Exception {
            Function function2 = new TestFunction(true, TestFunction.TEST_FUNCTION2);
            FunctionService.registerFunction(function2);
            Function function3 = new TestFunction(true, TestFunction.TEST_FUNCTION3);
            FunctionService.registerFunction(function3);
            Region region = cache.getRegion(regionName);
            Set filter = new HashSet();
            for (int i = 100; i < 120; i++) {
                filter.add("execKey-" + i);
            }
            try {
                noOfExecutionCalls_Aggregate++;
                noOfExecutionCalls_TESTFUNCTION2++;
                List list = (List) FunctionService.onRegion(region).withFilter(filter).execute(function2).getResult();
                noOfExecutionsCompleted_Aggregate++;
                noOfExecutionsCompleted_TESTFUNCTION2++;
                int size = list.size();
                resultReceived_Aggregate += size;
                resultReceived_TESTFUNCTION2 += size;
                noOfExecutionCalls_Aggregate++;
                noOfExecutionCalls_TESTFUNCTION2++;
                list = (List) FunctionService.onRegion(region).withFilter(filter).execute(function2).getResult();
                noOfExecutionsCompleted_Aggregate++;
                noOfExecutionsCompleted_TESTFUNCTION2++;
                size = list.size();
                resultReceived_Aggregate += size;
                resultReceived_TESTFUNCTION2 += size;
                return Boolean.TRUE;
            } catch (FunctionException e) {
                e.printStackTrace();
                Assert.fail("test failed due to", e);
                throw e;
            } catch (Exception e) {
                e.printStackTrace();
                Assert.fail("test failed due to", e);
                throw e;
            }
        }
    };
    client.invoke(ExecuteFunctions);
    SerializableCallable checkStatsOnClient = new SerializableCallable("checkStatsOnClient") {

        public Object call() throws Exception {
            // checks for the aggregate stats
            InternalDistributedSystem iDS = (InternalDistributedSystem) cache.getDistributedSystem();
            FunctionServiceStats functionServiceStats = iDS.getFunctionServiceStats();
            waitNoFunctionsRunning(functionServiceStats);
            assertEquals(noOfExecutionCalls_Aggregate, functionServiceStats.getFunctionExecutionCalls());
            assertEquals(noOfExecutionsCompleted_Aggregate, functionServiceStats.getFunctionExecutionsCompleted());
            assertEquals(resultReceived_Aggregate, functionServiceStats.getResultsReceived());
            FunctionStats functionStats = FunctionStats.getFunctionStats(TestFunction.TEST_FUNCTION2, iDS);
            assertEquals(noOfExecutionCalls_TESTFUNCTION2, functionStats.getFunctionExecutionCalls());
            assertEquals(noOfExecutionsCompleted_TESTFUNCTION2, functionStats.getFunctionExecutionsCompleted());
            assertEquals(resultReceived_TESTFUNCTION2, functionStats.getResultsReceived());
            return Boolean.TRUE;
        }
    };
    client.invoke(checkStatsOnClient);
}

Example 12 with DistributedSystem

use of org.apache.geode.distributed.DistributedSystem in project geode by apache.

the class OnGroupsFunctionExecutionDUnitTest method testP2PMemberFailure.

@Test
public void testP2PMemberFailure() {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    final String regionName = getName();
    initVM(vm0, "g0,mg", regionName, false);
    initVM(vm1, "g1", regionName, false);
    initVM(vm2, "g0,g1,g2", regionName, false);
    vm0.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            DistributedSystem ds = getSystem();
            Execution e1 = FunctionService.onMembers("g1");
            ArrayList<String> args = new ArrayList<String>();
            args.add("shutdown");
            e1 = e1.setArguments(args);
            try {
                e1.execute(new OnGroupsExceptionFunction()).getResult();
                fail("expected exception not thrown");
            } catch (FunctionException ex) {
                assertTrue(ex.getCause() instanceof FunctionInvocationTargetException);
            }
            return null;
        }
    });
}

Example 13 with DistributedSystem

use of org.apache.geode.distributed.DistributedSystem in project geode by apache.

the class OnGroupsFunctionExecutionDUnitTest method testP2PException.

@Test
public void testP2PException() {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    final String regionName = getName();
    // The test function deliberately throws a null pointer exception.
    // which is logged.
    IgnoredException.addIgnoredException(NullPointerException.class.getSimpleName());
    initVM(vm0, "g0,mg", regionName, false);
    initVM(vm1, "g1", regionName, false);
    initVM(vm2, "g0,g1,g2", regionName, false);
    vm0.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            DistributedSystem ds = getSystem();
            Execution e = FunctionService.onMembers("mg");
            ArrayList<String> args = new ArrayList<String>();
            args.add("runtime");
            e = e.setArguments(args);
            try {
                e.execute(new OnGroupsExceptionFunction()).getResult();
                fail("expected exception not thrown");
            } catch (FunctionException ex) {
                assertTrue(ex.getCause() instanceof NullPointerException);
            }
            Execution e1 = FunctionService.onMembers("g1");
            e1 = e1.setArguments(args);
            try {
                e1.execute(new OnGroupsExceptionFunction()).getResult();
                fail("expected exception not thrown");
            } catch (FunctionException ex) {
                assertTrue(ex.getCause() instanceof NullPointerException);
            }
            // fail on only one member
            Execution e2 = FunctionService.onMembers("g1");
            args.add("g2");
            e2 = e2.setArguments(args);
            try {
                e2.execute(new OnGroupsExceptionFunction()).getResult();
                fail("expected exception not thrown");
            } catch (FunctionException ex) {
                assertTrue(ex.getCause() instanceof NullPointerException);
            }
            return null;
        }
    });
}

Example 14 with DistributedSystem

use of org.apache.geode.distributed.DistributedSystem in project geode by apache.

the class OnGroupsFunctionExecutionDUnitTest method testP2POneMemberFailure.

@Test
public void testP2POneMemberFailure() {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    VM vm2 = host.getVM(2);
    final String regionName = getName();
    initVM(vm0, "g0,mg", regionName, false);
    initVM(vm1, "g1", regionName, false);
    initVM(vm2, "g0,g1,g2", regionName, false);
    vm0.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            DistributedSystem ds = getSystem();
            Execution e1 = FunctionService.onMembers("g1");
            ArrayList<String> args = new ArrayList<String>();
            args.add("shutdown");
            args.add("g2");
            e1 = e1.setArguments(args);
            try {
                e1.execute(new OnGroupsExceptionFunction()).getResult();
                fail("expected exception not thrown");
            } catch (FunctionException ex) {
                assertTrue(ex.getCause() instanceof FunctionInvocationTargetException);
            }
            return null;
        }
    });
}

Example 15 with DistributedSystem

use of org.apache.geode.distributed.DistributedSystem in project geode by apache.

the class TimeKeeper method createCache.

private void createCache(Properties props) throws Exception {
    DistributedSystem ds = getSystem(props);
    assertNotNull(ds);
    ds.disconnect();
    ds = getSystem(props);
    cache = CacheFactory.create(ds);
    assertNotNull(cache);
}