Examples with InternalLocator org.apache.geode.distributed.internal.InternalLocator used on opensource projects

Example 21 with InternalLocator

use of org.apache.geode.distributed.internal.InternalLocator in project geode by apache.

the class ConfigCommandsDUnitTest method testAlterUpdatesSharedConfig.

/**
   * Asserts that altering the runtime config correctly updates the shared configuration.
   */
@Test
public void testAlterUpdatesSharedConfig() throws Exception {
    final String groupName = getName();
    final int[] ports = AvailablePortHelper.getRandomAvailableTCPPorts(2);
    jmxPort = ports[0];
    httpPort = ports[1];
    try {
        jmxHost = InetAddress.getLocalHost().getHostName();
    } catch (UnknownHostException ignore) {
        jmxHost = "localhost";
    }
    // Start the Locator and wait for shared configuration to be available
    final int locatorPort = getRandomAvailablePort(SOCKET);
    final String locatorDirectory = this.temporaryFolder.newFolder("Locator").getAbsolutePath();
    final Properties locatorProps = new Properties();
    locatorProps.setProperty(NAME, "Locator");
    locatorProps.setProperty(MCAST_PORT, "0");
    locatorProps.setProperty(ENABLE_CLUSTER_CONFIGURATION, "true");
    locatorProps.setProperty(CLUSTER_CONFIGURATION_DIR, locatorDirectory);
    locatorProps.setProperty(JMX_MANAGER, "true");
    locatorProps.setProperty(JMX_MANAGER_START, "true");
    locatorProps.setProperty(JMX_MANAGER_BIND_ADDRESS, String.valueOf(jmxHost));
    locatorProps.setProperty(JMX_MANAGER_PORT, String.valueOf(jmxPort));
    locatorProps.setProperty(HTTP_SERVICE_PORT, String.valueOf(httpPort));
    Host.getHost(0).getVM(0).invoke(new SerializableRunnable() {

        @Override
        public void run() {
            final File locatorLogFile = new File(locatorDirectory, "locator-" + locatorPort + ".log");
            try {
                final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locatorPort, locatorLogFile, null, locatorProps);
                WaitCriterion wc = new WaitCriterion() {

                    @Override
                    public boolean done() {
                        return locator.isSharedConfigurationRunning();
                    }

                    @Override
                    public String description() {
                        return "Waiting for shared configuration to be started";
                    }
                };
                waitForCriterion(wc, 5000, 500, true);
            } catch (IOException e) {
                fail("Unable to create a locator with a shared configuration", e);
            }
        }
    });
    connect(jmxHost, jmxPort, httpPort, getDefaultShell());
    // Create a cache in VM 1
    VM vm = Host.getHost(0).getVM(1);
    vm.invoke(new SerializableCallable() {

        @Override
        public Object call() throws Exception {
            Properties localProps = new Properties();
            localProps.setProperty(MCAST_PORT, "0");
            localProps.setProperty(LOCATORS, "localhost[" + locatorPort + "]");
            localProps.setProperty(LOG_LEVEL, "error");
            localProps.setProperty(GROUPS, groupName);
            getSystem(localProps);
            assertNotNull(getCache());
            assertEquals("error", basicGetSystem().getConfig().getAttribute(LOG_LEVEL));
            return null;
        }
    });
    // Test altering the runtime config
    CommandStringBuilder commandStringBuilder = new CommandStringBuilder(CliStrings.ALTER_RUNTIME_CONFIG);
    commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__GROUP, groupName);
    commandStringBuilder.addOption(CliStrings.ALTER_RUNTIME_CONFIG__LOG__LEVEL, "fine");
    CommandResult cmdResult = executeCommand(commandStringBuilder.toString());
    assertEquals(Result.Status.OK, cmdResult.getStatus());
    // Make sure the shared config was updated
    Host.getHost(0).getVM(0).invoke(new SerializableRunnable() {

        @Override
        public void run() {
            ClusterConfigurationService sharedConfig = ((InternalLocator) Locator.getLocator()).getSharedConfiguration();
            Properties gemfireProperties = null;
            try {
                gemfireProperties = sharedConfig.getConfiguration(groupName).getGemfireProperties();
            } catch (Exception e) {
                fail("Error occurred in cluster configuration service", e);
            }
            assertEquals("fine", gemfireProperties.get(LOG_LEVEL));
        }
    });
}

Example 22 with InternalLocator

use of org.apache.geode.distributed.internal.InternalLocator in project geode by apache.

the class ClusterConfigWithSecurityDUnitTest method testSecurityPropsInheritance.

@Test
@Ignore("GEODE-2315")
public void testSecurityPropsInheritance() throws Exception {
    locatorProps.clear();
    locatorProps.setProperty(LOCATORS, "localhost[" + locator0.getPort() + "]");
    locatorProps.setProperty("security-username", "cluster");
    locatorProps.setProperty("security-password", "cluster");
    MemberVM locator1 = lsRule.startLocatorVM(1, locatorProps);
    // the second locator should inherit the first locator's security props
    locator1.invoke(() -> {
        InternalLocator locator = LocatorServerStartupRule.locatorStarter.getLocator();
        ClusterConfigurationService sc = locator.getSharedConfiguration();
        Properties clusterConfigProps = sc.getConfiguration("cluster").getGemfireProperties();
        assertThat(clusterConfigProps.getProperty(SECURITY_MANAGER)).isEqualTo(SimpleTestSecurityManager.class.getName());
        assertThat(locator.getConfig().getSecurityManager()).isNotEmpty();
    });
}

Example 23 with InternalLocator

use of org.apache.geode.distributed.internal.InternalLocator in project geode by apache.

the class ClusterConfigurationServiceDUnitTest method testSharedConfigurationService.

@Test
public void testSharedConfigurationService() throws Exception {
    // Start the Locator and wait for shared configuration to be available
    final String testGroup = "G1";
    final String clusterLogLevel = "error";
    final String groupLogLevel = "fine";
    final String testName = getName();
    final VM locator1Vm = getHost(0).getVM(1);
    final VM dataMemberVm = getHost(0).getVM(2);
    final VM locator2Vm = getHost(0).getVM(3);
    final int[] ports = getRandomAvailableTCPPorts(3);
    final int locator1Port = ports[0];
    locator1Vm.invoke(() -> {
        final File locatorLogFile = new File(testName + "-locator-" + locator1Port + ".log");
        final Properties locatorProps = new Properties();
        locatorProps.setProperty(NAME, "Locator1");
        locatorProps.setProperty(MCAST_PORT, "0");
        locatorProps.setProperty(LOG_LEVEL, "info");
        locatorProps.setProperty(ENABLE_CLUSTER_CONFIGURATION, "true");
        try {
            final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locator1Port, locatorLogFile, null, locatorProps);
            WaitCriterion wc = new WaitCriterion() {

                @Override
                public boolean done() {
                    return locator.isSharedConfigurationRunning();
                }

                @Override
                public String description() {
                    return "Waiting for shared configuration to be started";
                }
            };
            waitForCriterion(wc, TIMEOUT, INTERVAL, true);
        } catch (IOException e) {
            fail("Unable to create a locator with a shared configuration", e);
        }
    });
    XmlEntity xmlEntity = dataMemberVm.invoke(() -> {
        Properties localProps = new Properties();
        localProps.setProperty(MCAST_PORT, "0");
        localProps.setProperty(LOCATORS, "localhost[" + locator1Port + "]");
        localProps.setProperty(GROUPS, testGroup);
        getSystem(localProps);
        Cache cache = getCache();
        assertNotNull(cache);
        DiskStoreFactory dsFactory = cache.createDiskStoreFactory();
        File dsDir = new File("dsDir");
        if (!dsDir.exists()) {
            dsDir.mkdir();
        }
        dsFactory.setDiskDirs(new File[] { dsDir });
        dsFactory.create(DISKSTORENAME);
        RegionFactory regionFactory = getCache().createRegionFactory(RegionShortcut.REPLICATE);
        regionFactory.create(REGION1);
        return new XmlEntity(CacheXml.REGION, "name", REGION1);
    });
    locator1Vm.invoke(() -> {
        ClusterConfigurationService sc = InternalLocator.getLocator().getSharedConfiguration();
        sc.addXmlEntity(xmlEntity, new String[] { testGroup });
        // Modify property and cache attributes
        Properties clusterProperties = new Properties();
        clusterProperties.setProperty(LOG_LEVEL, clusterLogLevel);
        XmlEntity cacheEntity = XmlEntity.builder().withType(CacheXml.CACHE).build();
        Map<String, String> cacheAttributes = new HashMap<String, String>();
        cacheAttributes.put(CacheXml.COPY_ON_READ, "true");
        sc.modifyXmlAndProperties(clusterProperties, cacheEntity, null);
        clusterProperties.setProperty(LOG_LEVEL, groupLogLevel);
        sc.modifyXmlAndProperties(clusterProperties, cacheEntity, new String[] { testGroup });
        // Add a jar
        byte[][] jarBytes = new byte[1][];
        jarBytes[0] = "Hello".getBytes();
        assertTrue(sc.addJarsToThisLocator(new String[] { "foo.jar" }, jarBytes, null));
        // Add a jar for the group
        jarBytes = new byte[1][];
        jarBytes[0] = "Hello".getBytes();
        assertTrue(sc.addJarsToThisLocator(new String[] { "bar.jar" }, jarBytes, new String[] { testGroup }));
    });
    final int locator2Port = ports[1];
    // Create another locator in VM2
    locator2Vm.invoke(() -> {
        final File locatorLogFile = new File(testName + "-locator-" + locator2Port + ".log");
        final Properties locatorProps = new Properties();
        locatorProps.setProperty(NAME, "Locator2");
        locatorProps.setProperty(MCAST_PORT, "0");
        locatorProps.setProperty(LOG_LEVEL, "info");
        locatorProps.setProperty(ENABLE_CLUSTER_CONFIGURATION, "true");
        locatorProps.setProperty(LOCATORS, "localhost[" + locator1Port + "]");
        try {
            final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locator2Port, locatorLogFile, null, locatorProps);
            WaitCriterion wc = new WaitCriterion() {

                @Override
                public boolean done() {
                    return locator.isSharedConfigurationRunning();
                }

                @Override
                public String description() {
                    return "Waiting for shared configuration to be started";
                }
            };
            waitForCriterion(wc, TIMEOUT, INTERVAL, true);
        } catch (IOException e) {
            fail("Unable to create a locator with a shared configuration", e);
        }
        InternalLocator locator = (InternalLocator) Locator.getLocator();
        ClusterConfigurationService sharedConfig = locator.getSharedConfiguration();
        Map<String, Configuration> entireConfiguration = sharedConfig.getEntireConfiguration();
        Configuration clusterConfig = entireConfiguration.get(ClusterConfigurationService.CLUSTER_CONFIG);
        assertNotNull(clusterConfig);
        assertNotNull(clusterConfig.getJarNames());
        assertTrue(clusterConfig.getJarNames().contains("foo.jar"));
        assertTrue(clusterConfig.getGemfireProperties().getProperty(LOG_LEVEL).equals(clusterLogLevel));
        assertNotNull(clusterConfig.getCacheXmlContent());
        Configuration testGroupConfiguration = entireConfiguration.get(testGroup);
        assertNotNull(testGroupConfiguration);
        assertNotNull(testGroupConfiguration.getJarNames());
        assertTrue(testGroupConfiguration.getJarNames().contains("bar.jar"));
        assertTrue(testGroupConfiguration.getGemfireProperties().getProperty(LOG_LEVEL).equals(groupLogLevel));
        assertNotNull(testGroupConfiguration.getCacheXmlContent());
        assertTrue(testGroupConfiguration.getCacheXmlContent().contains(REGION1));
        Map<String, byte[]> jarData = sharedConfig.getAllJarsFromThisLocator(entireConfiguration.keySet());
        String[] jarNames = jarData.keySet().stream().toArray(String[]::new);
        byte[][] jarBytes = jarData.values().toArray(new byte[jarNames.length][]);
        assertNotNull(jarNames);
        assertNotNull(jarBytes);
        sharedConfig.deleteXmlEntity(new XmlEntity(CacheXml.REGION, "name", REGION1), new String[] { testGroup });
        sharedConfig.removeJars(new String[] { "foo.jar" }, null);
        sharedConfig.removeJars(null, null);
    });
    dataMemberVm.invoke(() -> {
        Set<String> groups = new HashSet<String>();
        groups.add(testGroup);
        ConfigurationRequest configRequest = new ConfigurationRequest(groups);
        ConfigurationResponse configResponse = (ConfigurationResponse) new TcpClient().requestToServer(InetAddress.getByName("localhost"), locator2Port, configRequest, 1000);
        assertNotNull(configResponse);
        Map<String, Configuration> requestedConfiguration = configResponse.getRequestedConfiguration();
        Configuration clusterConfiguration = requestedConfiguration.get(ClusterConfigurationService.CLUSTER_CONFIG);
        assertNotNull(clusterConfiguration);
        assertTrue(configResponse.getJarNames().length == 0);
        assertTrue(configResponse.getJars().length == 0);
        assertTrue(clusterConfiguration.getJarNames().isEmpty());
        assertTrue(clusterConfiguration.getGemfireProperties().getProperty(LOG_LEVEL).equals(clusterLogLevel));
        Configuration testGroupConfiguration = requestedConfiguration.get(testGroup);
        assertNotNull(testGroupConfiguration);
        assertFalse(testGroupConfiguration.getCacheXmlContent().contains(REGION1));
        assertTrue(testGroupConfiguration.getJarNames().isEmpty());
        assertTrue(testGroupConfiguration.getGemfireProperties().getProperty(LOG_LEVEL).equals(groupLogLevel));
        GemFireCacheImpl cache = (GemFireCacheImpl) getCache();
        Map<InternalDistributedMember, Collection<String>> locatorsWithSharedConfiguration = cache.getDistributionManager().getAllHostedLocatorsWithSharedConfiguration();
        assertFalse(locatorsWithSharedConfiguration.isEmpty());
        assertTrue(locatorsWithSharedConfiguration.size() == 2);
        Set<InternalDistributedMember> locatorMembers = locatorsWithSharedConfiguration.keySet();
        for (InternalDistributedMember locatorMember : locatorMembers) {
            System.out.println(locatorMember);
        }
        return null;
    });
}

Example 24 with InternalLocator

use of org.apache.geode.distributed.internal.InternalLocator in project geode by apache.

the class ClusterConfigurationServiceDUnitTest method testGetHostedLocatorsWithSharedConfiguration.

@Test
public void testGetHostedLocatorsWithSharedConfiguration() throws Exception {
    final VM locator1Vm = getHost(0).getVM(1);
    final VM locator2Vm = getHost(0).getVM(2);
    final String testName = getName();
    final int[] ports = getRandomAvailableTCPPorts(3);
    final int locator1Port = ports[0];
    final String locator1Name = "locator1" + locator1Port;
    locator1Vm.invoke(() -> {
        final File locatorLogFile = new File(testName + "-locator-" + locator1Port + ".log");
        final Properties locatorProps = new Properties();
        locatorProps.setProperty(NAME, locator1Name);
        locatorProps.setProperty(MCAST_PORT, "0");
        locatorProps.setProperty(LOG_LEVEL, "fine");
        locatorProps.setProperty(ENABLE_CLUSTER_CONFIGURATION, "true");
        try {
            final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locator1Port, locatorLogFile, null, locatorProps);
            WaitCriterion wc = new WaitCriterion() {

                @Override
                public boolean done() {
                    return locator.isSharedConfigurationRunning();
                }

                @Override
                public String description() {
                    return "Waiting for shared configuration to be started";
                }
            };
            waitForCriterion(wc, TIMEOUT, INTERVAL, true);
        } catch (IOException e) {
            fail("Unable to create a locator with a shared configuration", e);
        }
        GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
        InternalDistributedMember me = cache.getMyId();
        DM dm = cache.getDistributionManager();
        Map<InternalDistributedMember, Collection<String>> hostedLocators = dm.getAllHostedLocators();
        assertFalse(hostedLocators.isEmpty());
        Map<InternalDistributedMember, Collection<String>> hostedLocatorsWithSharedConfiguration = dm.getAllHostedLocatorsWithSharedConfiguration();
        assertFalse(hostedLocatorsWithSharedConfiguration.isEmpty());
        assertNotNull(hostedLocators.get(me));
        assertNotNull(hostedLocatorsWithSharedConfiguration.get(me));
        return null;
    });
    final int locator2Port = ports[1];
    final String locator2Name = "locator2" + locator2Port;
    locator2Vm.invoke(() -> {
        final File locatorLogFile = new File(testName + "-locator-" + locator2Port + ".log");
        final Properties locatorProps = new Properties();
        locatorProps.setProperty(NAME, locator2Name);
        locatorProps.setProperty(MCAST_PORT, "0");
        locatorProps.setProperty(LOG_LEVEL, "fine");
        locatorProps.setProperty(LOCATORS, "localhost[" + locator1Port + "]");
        locatorProps.setProperty(ENABLE_CLUSTER_CONFIGURATION, "false");
        final InternalLocator locator = (InternalLocator) Locator.startLocatorAndDS(locator2Port, locatorLogFile, null, locatorProps);
        GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
        InternalDistributedMember me = cache.getMyId();
        DM dm = cache.getDistributionManager();
        Map<InternalDistributedMember, Collection<String>> hostedLocators = dm.getAllHostedLocators();
        assertFalse(hostedLocators.isEmpty());
        Map<InternalDistributedMember, Collection<String>> hostedLocatorsWithSharedConfiguration = dm.getAllHostedLocatorsWithSharedConfiguration();
        assertFalse(hostedLocatorsWithSharedConfiguration.isEmpty());
        assertNotNull(hostedLocators.get(me));
        assertNull(hostedLocatorsWithSharedConfiguration.get(me));
        assertTrue(hostedLocators.size() == 2);
        assertTrue(hostedLocatorsWithSharedConfiguration.size() == 1);
        Set<InternalDistributedMember> locatorsWithSharedConfig = hostedLocatorsWithSharedConfiguration.keySet();
        Set<String> locatorsWithSharedConfigNames = new HashSet<String>();
        for (InternalDistributedMember locatorWithSharedConfig : locatorsWithSharedConfig) {
            locatorsWithSharedConfigNames.add(locatorWithSharedConfig.getName());
        }
        assertTrue(locatorsWithSharedConfigNames.contains(locator1Name));
        return null;
    });
    locator1Vm.invoke(() -> {
        InternalLocator locator = (InternalLocator) Locator.getLocator();
        ClusterConfigurationService sharedConfig = locator.getSharedConfiguration();
        sharedConfig.destroySharedConfiguration();
        locator.stop();
        return null;
    });
    locator2Vm.invoke(() -> {
        GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
        InternalDistributedMember me = cache.getMyId();
        DM dm = cache.getDistributionManager();
        Map<InternalDistributedMember, Collection<String>> hostedLocators = dm.getAllHostedLocators();
        assertFalse(hostedLocators.isEmpty());
        Map<InternalDistributedMember, Collection<String>> hostedLocatorsWithSharedConfiguration = dm.getAllHostedLocatorsWithSharedConfiguration();
        assertTrue(hostedLocatorsWithSharedConfiguration.isEmpty());
        assertNotNull(hostedLocators.get(me));
        assertNull(hostedLocatorsWithSharedConfiguration.get(me));
        assertTrue(hostedLocators.size() == 1);
        assertTrue(hostedLocatorsWithSharedConfiguration.size() == 0);
        return null;
    });
}

Example 25 with InternalLocator

use of org.apache.geode.distributed.internal.InternalLocator in project geode by apache.

the class ClusterConfigurationServiceUsingDirDUnitTest method stopLocator.

private void stopLocator(final VM vm) {
    vm.invoke("Stopping locator on " + vm, () -> {
        InternalLocator locator = InternalLocator.getLocator();
        assertNotNull("No locator found", locator);
        locator.stop();
        disconnectAllFromDS();
    });
}