@Before public void before() throws Exception { command = spy(AlterAsyncEventQueueCommand.class); service = spy(InternalConfigurationPersistenceService.class); configRegion = mock(AbstractRegion.class); doReturn(service).when(command).getConfigurationPersistenceService(); groupSet.add("group1"); groupSet.add("group2"); doReturn(groupSet).when(service).getGroups(); CacheConfig config = new CacheConfig(); CacheConfig.AsyncEventQueue aeq1 = new CacheConfig.AsyncEventQueue(); aeq1.setId("queue1"); config.getAsyncEventQueues().add(aeq1); doReturn(config).when(service).getCacheConfig("group1"); doReturn(new CacheConfig()).when(service).getCacheConfig("group2"); doReturn(config).when(service).getCacheConfig("group1", true); doReturn(new CacheConfig()).when(service).getCacheConfig("group2", true); doReturn(true).when(service).lockSharedConfiguration(); doNothing().when(service).unlockSharedConfiguration(); doReturn(null).when(service).getConfiguration(any()); doReturn(configRegion).when(service).getConfigurationRegion(); doCallRealMethod().when(service).updateCacheConfig(any(), any()); }
@Test public void gatewayReceiverCanBeCreatedButIsNotPersistedWithoutConfigurationService() { doReturn(mock(Set.class)).when(command).getMembers(any(), any()); doReturn(null).when(command).getConfigurationPersistenceService(); result1 = new CliFunctionResult("member", CliFunctionResult.StatusState.OK, "result1"); functionResults.add(result1); gfsh.executeAndAssertThat(command, "create gateway-receiver").statusIsSuccess() .containsOutput( "Cluster configuration service is not running. Configuration change is not persisted"); verify(ccService, never()).addXmlEntity(any(), any()); verify(ccService, never()).updateCacheConfig(any(), any()); }
@Before public void setUp() throws Exception { service = spy(new InternalConfigurationPersistenceService(CacheConfig.class, ElementOne.class, ElementTwo.class)); service2 = spy(new InternalConfigurationPersistenceService(CacheConfig.class)); configuration = new Configuration("cluster"); doReturn(configuration).when(service).getConfiguration(any()); doReturn(configuration).when(service2).getConfiguration(any()); doReturn(mock(Region.class)).when(service).getConfigurationRegion(); doReturn(mock(Region.class)).when(service2).getConfigurationRegion(); doReturn(true).when(service).lockSharedConfiguration(); doReturn(true).when(service2).lockSharedConfiguration(); doNothing().when(service).unlockSharedConfiguration(); doNothing().when(service2).unlockSharedConfiguration(); }
TransformerException, SAXException, ParserConfigurationException { this.status.set(SharedConfigurationStatus.STARTED); Region<String, Configuration> configRegion = this.getConfigurationRegion(); lockSharedConfiguration(); removeInvalidXmlConfigurations(configRegion); try { if (loadSharedConfigFromDir) { logger.info("Reading cluster configuration from '{}' directory", InternalConfigurationPersistenceService.CLUSTER_CONFIG_ARTIFACTS_DIR_NAME); loadSharedConfigurationFromDir(new File(this.configDirPath)); } else { persistSecuritySettings(configRegion); Configuration config = stringConfigurationEntry.getValue(); for (String jar : config.getJarNames()) { if (!getPathToJarOnThisLocator(stringConfigurationEntry.getKey(), jar).toFile() .exists()) { downloadJarFromOtherLocators(stringConfigurationEntry.getKey(), jar); unlockSharedConfiguration();
@Override public void updateCacheConfig(String group, UnaryOperator<CacheConfig> mutator) { if (group == null) { group = CLUSTER_CONFIG; } lockSharedConfiguration(); try { CacheConfig cacheConfig = getCacheConfig(group, true); cacheConfig = mutator.apply(cacheConfig); if (cacheConfig == null) { // mutator returns a null config, indicating no change needs to be persisted return; } Configuration configuration = getConfiguration(group); if (configuration == null) { configuration = new Configuration(group); } configuration.setCacheXmlContent(jaxbService.marshall(cacheConfig)); getConfigurationRegion().put(group, configuration); } finally { unlockSharedConfiguration(); } } }
CacheConfig.AsyncEventQueue findAEQ(String aeqId) { CacheConfig.AsyncEventQueue queue = null; InternalConfigurationPersistenceService ccService = (InternalConfigurationPersistenceService) this.getConfigurationPersistenceService(); if (ccService == null) { return null; } Set<String> groups = ccService.getGroups(); for (String group : groups) { queue = CacheElement.findElement(ccService.getCacheConfig(group).getAsyncEventQueues(), aeqId); if (queue != null) { return queue; } } return queue; }
@Before public void setUp() { cache = mock(InternalCache.class); command = spy(DestroyDataSourceCommand.class); doReturn(cache).when(command).getCache(); cacheConfig = mock(CacheConfig.class); ccService = mock(InternalConfigurationPersistenceService.class); doReturn(Collections.emptySet()).when(command).findMembers(any(), any()); doReturn(ccService).when(command).getConfigurationPersistenceService(); when(ccService.getCacheConfig(any())).thenReturn(cacheConfig); doAnswer(invocation -> { UnaryOperator<CacheConfig> mutator = invocation.getArgument(1); mutator.apply(cacheConfig); return null; }).when(ccService).updateCacheConfig(any(), any()); when(ccService.getConfigurationRegion()).thenReturn(mock(Region.class)); when(ccService.getConfiguration(any())).thenReturn(mock(Configuration.class)); }
@Override public CacheConfig getCacheConfig(String group) { return getCacheConfig(group, false); }
public void loadSharedConfigurationFromDir(File configDir) throws SAXException, ParserConfigurationException, TransformerException, IOException { lockSharedConfiguration(); try { File[] groupNames = configDir.listFiles((FileFilter) DirectoryFileFilter.INSTANCE); boolean needToCopyJars = true; if (configDir.getAbsolutePath().equals(getSharedConfigurationDirPath())) { needToCopyJars = false; Map<String, Configuration> sharedConfiguration = new HashMap<>(); for (File groupName : groupNames) { Configuration configuration = readConfiguration(groupName); logger.info(configuration.getConfigName() + " xml content: \n" + configuration.getCacheXmlContent()); sharedConfiguration.put(groupName.getName(), configuration); if (needToCopyJars && configuration.getJarNames().size() > 0) { Path groupDirPath = createConfigDirIfNecessary(configuration.getConfigName()).toPath(); for (String jarName : configuration.getJarNames()) { Files.copy(groupName.toPath().resolve(jarName), groupDirPath.resolve(jarName)); Region<String, Configuration> clusterRegion = getConfigurationRegion(); clusterRegion.clear(); persistSecuritySettings(clusterRegion); unlockSharedConfiguration();
@Test public void configurationIsNotPersistedWhenCreationOnOnlyMemberFails() { doReturn(mock(Set.class)).when(command).getMembers(any(), any()); doReturn(ccService).when(command).getConfigurationPersistenceService(); result1 = new CliFunctionResult("member", CliFunctionResult.StatusState.ERROR, "result1"); functionResults.add(result1); // does not delete because command failed, so hasNoFailToPersistError should still be true gfsh.executeAndAssertThat(command, "create gateway-receiver").statusIsError(); verify(ccService, never()).updateCacheConfig(any(), any()); }
ccService.lockSharedConfiguration(); try { if (action == Action.APPLY && servers.size() > 0) { if (ccService.hasXmlConfiguration()) { return ResultModel.createError("Can not configure servers that are already configured."); ZipUtils.unzip(file.getAbsolutePath(), tempDir.toAbsolutePath().toString()); ccService.loadSharedConfigurationFromDir(tempDir.toFile()); FileUtils.deleteQuietly(tempDir.toFile()); infoSection.addLine("Cluster configuration successfully imported."); } else { Configuration configuration = ccService.getConfiguration(group); if (configuration == null) { configuration = new Configuration(group); ccService.setConfiguration(group, configuration); logger.info( configuration.getConfigName() + "xml content: \n" + configuration.getCacheXmlContent()); ccService.unlockSharedConfiguration();
@Test public void updateShouldInsertIfNotExist() { doCallRealMethod().when(service).updateCacheConfig(any(), any()); doCallRealMethod().when(service).getCacheConfig(any()); Region region = mock(Region.class); doReturn(region).when(service).getConfigurationRegion(); service.updateCacheConfig("non-existing-group", cc -> cc); verify(region).put(eq("non-existing-group"), any()); }
@Before public void before() { parseResult = mock(GfshParseResult.class); result = new ResultModel(); executor = spy(CommandExecutor.class); testCommand = mock(SingleGfshCommand.class, withSettings().extraInterfaces(UpdateAllConfigurationGroupsMarker.class)); ccService = spy(InternalConfigurationPersistenceService.class); configRegion = mock(AbstractRegion.class); doReturn(ccService).when(testCommand).getConfigurationPersistenceService(); doCallRealMethod().when(ccService).updateCacheConfig(any(), any()); doReturn(true).when(ccService).lockSharedConfiguration(); doNothing().when(ccService).unlockSharedConfiguration(); doReturn(configRegion).when(ccService).getConfigurationRegion(); }
@Test public void whenNoMembersFoundAndClusterConfigRunningThenUpdateClusterConfig() { InternalConfigurationPersistenceService clusterConfigService = mock(InternalConfigurationPersistenceService.class); CacheConfig cacheConfig = mock(CacheConfig.class); doReturn(Collections.emptySet()).when(command).findMembers(any(), any()); doReturn(clusterConfigService).when(command).getConfigurationPersistenceService(); doReturn(cacheConfig).when(clusterConfigService).getCacheConfig(any()); doAnswer(invocation -> { UnaryOperator<CacheConfig> mutator = invocation.getArgument(1); mutator.apply(cacheConfig); return null; }).when(clusterConfigService).updateCacheConfig(any(), any()); gfsh.executeAndAssertThat(command, COMMAND + " --type=SIMPLE --name=name --jdbc-driver-class=driver --connection-url=url") .statusIsSuccess().containsOutput("No members found.") .containsOutput("Changes to configuration for group 'cluster' are persisted."); verify(clusterConfigService).updateCacheConfig(any(), any()); verify(command).updateConfigForGroup(eq("cluster"), eq(cacheConfig), any()); }
lockSharedConfiguration(); boolean success = true; try { Region<String, Configuration> configRegion = getConfigurationRegion(); if (groups == null) { groups = configRegion.keySet().stream().toArray(String[]::new); File jar = this.getPathToJarOnThisLocator(group, jarRemoved).toFile(); if (jar.exists()) { try { success = false; } finally { unlockSharedConfiguration();
lockSharedConfiguration(); try { Region<String, Configuration> configRegion = getConfigurationRegion(); unlockSharedConfiguration();
lockSharedConfiguration(); try { Region<String, Configuration> configRegion = getConfigurationRegion(); if (groups == null || groups.length == 0) { groups = new String[] {ConfigurationPersistenceService.CLUSTER_CONFIG}; xmlContent = generateInitialXmlContent(); unlockSharedConfiguration();
lockSharedConfiguration(); try { if (groups == null) { groups = new String[] {ConfigurationPersistenceService.CLUSTER_CONFIG}; Region<String, Configuration> configRegion = getConfigurationRegion(); for (String group : groups) { Configuration configuration = configRegion.get(group); createConfigDirIfNecessary(group); unlockSharedConfiguration();
/** * Creates a ConfigurationResponse based on the configRequest, configuration response contains the * requested shared configuration This method locks the ConfigurationPersistenceService */ public ConfigurationResponse createConfigurationResponse(Set<String> groups) { ConfigurationResponse configResponse = null; boolean isLocked = lockSharedConfiguration(); try { if (isLocked) { configResponse = new ConfigurationResponse(); groups.add(ConfigurationPersistenceService.CLUSTER_CONFIG); logger.info("Building up configuration response with following configurations: {}", groups); for (String group : groups) { Configuration configuration = getConfiguration(group); configResponse.addConfiguration(configuration); if (configuration != null) { configResponse.addJar(group, configuration.getJarNames()); } } return configResponse; } } finally { unlockSharedConfiguration(); } return configResponse; }
@Test public void getExistingGroupConfigShouldReturnNullIfNoXml() { Configuration groupConfig = new Configuration("some-new-group"); doReturn(groupConfig).when(service).getConfiguration("some-new-group"); CacheConfig groupCacheConfig = service.getCacheConfig("some-new-group"); assertThat(groupCacheConfig).isNull(); }