private boolean removeJdbcLoader(RegionAttributesType attributes) { DeclarableType cacheLoader = attributes.getCacheLoader(); if (cacheLoader != null) { if (JdbcLoader.class.getName().equals(cacheLoader.getClassName())) { attributes.setCacheLoader(null); return true; } } return false; }
private boolean removeJdbcWriter(RegionAttributesType attributes) { DeclarableType cacheWriter = attributes.getCacheWriter(); if (cacheWriter != null) { if (JdbcWriter.class.getName().equals(cacheWriter.getClassName())) { attributes.setCacheWriter(null); return true; } } return false; }
public static <T extends Declarable> T newInstance(DeclarableType declarableType, Cache cache) { try { Class<T> loadedClass = (Class<T>) ClassPathLoader.getLatest().forName(declarableType.getClassName()); T declarable = loadedClass.newInstance(); Properties initProperties = new Properties(); for (ParameterType parameter : declarableType.getParameters()) { initProperties.put(parameter.getName(), newInstance(parameter, cache)); } declarable.initialize(cache, initProperties); return declarable; } catch (Exception e) { throw new RuntimeException( "Error instantiating class: <" + declarableType.getClassName() + ">", e); } }
private void checkForCacheLoader(String regionName, RegionConfig regionConfig) throws PreconditionException { RegionAttributesType regionAttributes = regionConfig.getRegionAttributes(); if (regionAttributes != null) { DeclarableType loaderDeclarable = regionAttributes.getCacheLoader(); if (loaderDeclarable != null) { throw new PreconditionException("The existing region " + regionName + " must not already have a cache-loader, but it has " + loaderDeclarable.getClassName()); } } }
private void checkForCacheWriter(String regionName, boolean synchronous, RegionConfig regionConfig) throws PreconditionException { if (synchronous) { RegionAttributesType writerAttributes = regionConfig.getRegionAttributes(); if (writerAttributes != null) { DeclarableType writerDeclarable = writerAttributes.getCacheWriter(); if (writerDeclarable != null) { throw new PreconditionException("The existing region " + regionName + " must not already have a cache-writer, but it has " + writerDeclarable.getClassName()); } } } }
@Test public void updateClusterConfigWithOneMatchingRegionAndJdbcWriterRemovesTheWriter() { List<RegionConfig> list = new ArrayList<>(); List<CacheElement> listCacheElements = new ArrayList<>(); RegionMapping matchingMapping = mock(RegionMapping.class); listCacheElements.add(matchingMapping); when(matchingRegion.getCustomRegionElements()).thenReturn(listCacheElements); list.add(matchingRegion); when(cacheConfig.getRegions()).thenReturn(list); DeclarableType cacheWriter = mock(DeclarableType.class); when(cacheWriter.getClassName()).thenReturn(JdbcWriter.class.getName()); when(matchingRegionAttributes.getCacheWriter()).thenReturn(cacheWriter); boolean modified = destroyRegionMappingCommand.updateConfigForGroup(null, cacheConfig, regionName); verify(matchingRegionAttributes, times(1)).setCacheWriter(null); assertThat(modified).isTrue(); }
@Test public void updateWithCacheListeners() { // suppose region has one cacheListener, and we want to replace the oldOne one with the new one CacheListener oldOne = mock(CacheListener.class); when(region.getCacheListeners()).thenReturn(new CacheListener[] {oldOne}); DeclarableType newCacheListenerType = mock(DeclarableType.class); when(newCacheListenerType.getClassName()).thenReturn(MyCacheListener.class.getName()); regionAttributes.getCacheListeners().add(newCacheListenerType); ArgumentCaptor<CacheListener> argument = ArgumentCaptor.forClass(CacheListener.class); function.alterRegion(cache, config); verify(mutator).removeCacheListener(oldOne); verify(mutator).addCacheListener(argument.capture()); assertThat(argument.getValue()).isInstanceOf(MyCacheListener.class); }
@Test public void updateWithCacheWriter() { DeclarableType newCacheWriterDeclarable = mock(DeclarableType.class); when(newCacheWriterDeclarable.getClassName()).thenReturn(MyCacheWriter.class.getName()); regionAttributes.setCacheWriter(newCacheWriterDeclarable); function.alterRegion(cache, config); verify(mutator).setCacheWriter(notNull()); verify(mutator, times(0)).setCacheLoader(any()); }
@Test public void updateClusterConfigWithOneMatchingRegionCreatesAsyncEventQueue() { List<RegionConfig> list = new ArrayList<>(); List<CacheElement> listCacheElements = new ArrayList<>(); when(matchingRegion.getCustomRegionElements()).thenReturn(listCacheElements); list.add(matchingRegion); when(cacheConfig.getRegions()).thenReturn(list); List<CacheConfig.AsyncEventQueue> queueList = new ArrayList<>(); when(cacheConfig.getAsyncEventQueues()).thenReturn(queueList); createRegionMappingCommand.updateConfigForGroup(null, cacheConfig, arguments); assertThat(queueList.size()).isEqualTo(1); String queueName = CreateMappingCommand.createAsyncEventQueueName(regionName); AsyncEventQueue createdQueue = queueList.get(0); assertThat(createdQueue.getId()).isEqualTo(queueName); assertThat(createdQueue.isParallel()).isFalse(); assertThat(createdQueue.getAsyncEventListener().getClassName()) .isEqualTo(JdbcAsyncWriter.class.getName()); }
@Test public void updateWithCustomExpiry() { RegionAttributesType.ExpirationAttributesType expiration = new RegionAttributesType.ExpirationAttributesType(); regionAttributes.setEntryIdleTime(expiration); DeclarableType mockExpiry = mock(DeclarableType.class); when(mockExpiry.getClassName()).thenReturn(MyCustomExpiry.class.getName()); expiration.setCustomExpiry(mockExpiry); function.alterRegion(cache, config); verify(mutator, times(0)).setEntryIdleTimeout(any()); verify(mutator).setCustomEntryIdleTimeout(notNull()); }
@Test public void alterWithCacheListener() { RegionConfig deltaConfig = getDeltaRegionConfig("alter region --name=regionA --cache-listener=abc,def"); List<DeclarableType> cacheListeners = deltaConfig.getRegionAttributes().getCacheListeners(); assertThat(cacheListeners).hasSize(2); assertThat(cacheListeners.get(0).getClassName()).isEqualTo("abc"); assertThat(cacheListeners.get(1).getClassName()).isEqualTo("def"); // check that the combined the configuration is created as expected RegionAttributesType existingAttributes = new RegionAttributesType(); existingAttributes.getCacheListeners().add(new DeclarableType("ghi")); existingRegionConfig.setRegionAttributes(existingAttributes); command.updateConfigForGroup("cluster", cacheConfig, deltaConfig); List<DeclarableType> updatedCacheListeners = existingRegionConfig.getRegionAttributes().getCacheListeners(); assertThat(updatedCacheListeners).hasSize(2); assertThat(updatedCacheListeners.get(0).getClassName()).isEqualTo("abc"); assertThat(updatedCacheListeners.get(1).getClassName()).isEqualTo("def"); assertThat(existingRegionConfig.getRegionAttributes().getEntryIdleTime()).isNull(); }
@Test public void generatesWithCacheClasses() { cacheListeners = new HashSet<>(); cacheListeners.add(new ClassName<>("java.lang.String")); cacheLoader = new ClassName("java.lang.String"); cacheWriter = new ClassName("java.lang.String"); generate(); List<DeclarableType> cacheListeners = config.getRegionAttributes().getCacheListeners(); assertThat(cacheListeners).isNotNull(); assertThat(cacheListeners.get(0).getClassName()).isEqualTo("java.lang.String"); assertThat( config.getRegionAttributes().getCacheLoader().getClassName()) .isEqualTo("java.lang.String"); assertThat( config.getRegionAttributes().getCacheWriter().getClassName()) .isEqualTo("java.lang.String"); }
@Test public void createsMappingReturnsStatusERRORWhenClusterConfigRegionHasLoader() { results.add(successFunctionResult); ConfigurationPersistenceService configurationPersistenceService = mock(ConfigurationPersistenceService.class); doReturn(configurationPersistenceService).when(createRegionMappingCommand) .getConfigurationPersistenceService(); when(configurationPersistenceService.getCacheConfig(null)).thenReturn(cacheConfig); List<RegionConfig> list = new ArrayList<>(); list.add(matchingRegion); when(cacheConfig.getRegions()).thenReturn(list); RegionAttributesType loaderAttribute = mock(RegionAttributesType.class); DeclarableType loaderDeclarable = mock(DeclarableType.class); when(loaderDeclarable.getClassName()).thenReturn("MyCacheLoaderClass"); when(loaderAttribute.getCacheLoader()).thenReturn(loaderDeclarable); when(matchingRegion.getRegionAttributes()).thenReturn(loaderAttribute); ResultModel result = createRegionMappingCommand.createMapping(regionName, dataSourceName, tableName, pdxClass, false, null, null, null); assertThat(result.getStatus()).isSameAs(Result.Status.ERROR); assertThat(result.toString()).contains("The existing region " + regionName + " must not already have a cache-loader, but it has MyCacheLoaderClass"); }
@Test public void createsMappingReturnsStatusERRORWhenRegionMappingExists() { results.add(successFunctionResult); ConfigurationPersistenceService configurationPersistenceService = mock(ConfigurationPersistenceService.class); doReturn(configurationPersistenceService).when(createRegionMappingCommand) .getConfigurationPersistenceService(); when(configurationPersistenceService.getCacheConfig(null)).thenReturn(cacheConfig); List<RegionConfig> list = new ArrayList<>(); list.add(matchingRegion); when(cacheConfig.getRegions()).thenReturn(list); RegionAttributesType loaderAttribute = mock(RegionAttributesType.class); DeclarableType loaderDeclarable = mock(DeclarableType.class); when(loaderDeclarable.getClassName()).thenReturn(null); when(loaderAttribute.getCacheLoader()).thenReturn(loaderDeclarable); when(matchingRegion.getRegionAttributes()).thenReturn(loaderAttribute); List<CacheElement> customList = new ArrayList<>(); RegionMapping existingMapping = mock(RegionMapping.class); customList.add(existingMapping); when(matchingRegion.getCustomRegionElements()).thenReturn(customList); ResultModel result = createRegionMappingCommand.createMapping(regionName, dataSourceName, tableName, pdxClass, false, null, null, null); assertThat(result.getStatus()).isSameAs(Result.Status.ERROR); assertThat(result.toString()).contains("A JDBC mapping for " + regionName + " already exists."); }
@Test public void createMappingWithSynchronousReturnsStatusERRORWhenClusterConfigRegionHasWriter() { results.add(successFunctionResult); ConfigurationPersistenceService configurationPersistenceService = mock(ConfigurationPersistenceService.class); doReturn(configurationPersistenceService).when(createRegionMappingCommand) .getConfigurationPersistenceService(); when(configurationPersistenceService.getCacheConfig(null)).thenReturn(cacheConfig); List<RegionConfig> list = new ArrayList<>(); list.add(matchingRegion); when(cacheConfig.getRegions()).thenReturn(list); RegionAttributesType writerAttribute = mock(RegionAttributesType.class); DeclarableType writerDeclarable = mock(DeclarableType.class); when(writerDeclarable.getClassName()).thenReturn("MyCacheWriterClass"); when(writerAttribute.getCacheWriter()).thenReturn(writerDeclarable); when(matchingRegion.getRegionAttributes()).thenReturn(writerAttribute); ResultModel result = createRegionMappingCommand.createMapping(regionName, dataSourceName, tableName, pdxClass, true, null, null, null); assertThat(result.getStatus()).isSameAs(Result.Status.ERROR); assertThat(result.toString()).contains("The existing region " + regionName + " must not already have a cache-writer, but it has MyCacheWriterClass"); }
@Test public void generatesWithPrAttributes() { partitionArgs = new PartitionArgs("colo-with", 100, 100L, 100, 100L, 100L, 100, "java.lang.String"); generate(); RegionAttributesType.PartitionAttributes partitionAttributes = config.getRegionAttributes().getPartitionAttributes(); assertThat(partitionAttributes).isNotNull(); assertThat(partitionAttributes.getColocatedWith()).isEqualTo("colo-with"); assertThat(partitionAttributes.getLocalMaxMemory()).isEqualTo("100"); assertThat(partitionAttributes.getRecoveryDelay()).isEqualTo("100"); assertThat(partitionAttributes.getRedundantCopies()).isEqualTo("100"); assertThat(partitionAttributes.getStartupRecoveryDelay()).isEqualTo("100"); assertThat(partitionAttributes.getTotalMaxMemory()).isEqualTo("100"); assertThat(partitionAttributes.getTotalNumBuckets()).isEqualTo("100"); DeclarableType partitionResolverType = partitionAttributes.getPartitionResolver(); assertThat(partitionResolverType.getClassName()).isEqualTo("java.lang.String"); }
@Test public void alterWithCacheLoader() { RegionConfig deltaConfig = getDeltaRegionConfig("alter region --name=regionA --cache-loader=abc"); RegionAttributesType deltaAttributes = deltaConfig.getRegionAttributes(); assertThat(deltaAttributes.getCacheWriter()).isNull(); assertThat(deltaAttributes.getCacheLoader().getClassName()).isEqualTo("abc"); assertThat(deltaAttributes.getCacheListeners()).isNotNull().isEmpty(); RegionAttributesType existingAttributes = new RegionAttributesType(); existingAttributes.getCacheListeners().add(new DeclarableType("def")); existingAttributes.setCacheLoader(new DeclarableType("def")); existingAttributes.setCacheWriter(new DeclarableType("def")); existingRegionConfig.setRegionAttributes(existingAttributes); command.updateConfigForGroup("cluster", cacheConfig, deltaConfig); // after update, the cache listeners remains the same assertThat(existingAttributes.getCacheListeners()).hasSize(1); assertThat(existingAttributes.getCacheListeners().get(0).getClassName()).isEqualTo("def"); // after update the cache writer remains the same assertThat(existingAttributes.getCacheWriter().getClassName()).isEqualTo("def"); // after update the cache loader is changed assertThat(existingAttributes.getCacheLoader().getClassName()).isEqualTo("abc"); }
assertThat(entryTimeToLive.getTimeout()).isEqualTo("10"); assertThat(entryTimeToLive.getAction()).isEqualTo("destroy"); assertThat(entryTimeToLive.getCustomExpiry().getClassName()).isEqualTo("foo"); RegionAttributesType.ExpirationAttributesType regionTimeToLive = regionConfig.getRegionAttributes().getRegionTimeToLive(); assertThat(regionTimeToLive.getTimeout()).isEqualTo("20"); assertThat(regionTimeToLive.getAction()).isEqualTo("invalidate"); assertThat(regionTimeToLive.getCustomExpiry().getClassName()).isEqualTo("bar");
@Test public void alterWithEntryIdleTimeOutCustomExpiry() { RegionConfig deltaConfig = getDeltaRegionConfig("alter region --name=regionA --entry-idle-time-custom-expiry=abc"); RegionAttributesType.ExpirationAttributesType entryIdleTime = deltaConfig.getRegionAttributes().getEntryIdleTime(); assertThat(entryIdleTime).isNotNull(); assertThat(entryIdleTime.getTimeout()).isNull(); assertThat(entryIdleTime.getCustomExpiry().getClassName()).isEqualTo("abc"); assertThat(entryIdleTime.getAction()).isNull(); // check that the combined the configuration is created as expected RegionAttributesType existingAttributes = new RegionAttributesType(); RegionAttributesType.ExpirationAttributesType expirationAttributesType = new RegionAttributesType.ExpirationAttributesType(10, ExpirationAction.INVALIDATE, null, null); existingAttributes.setEntryIdleTime(expirationAttributesType); existingRegionConfig.setRegionAttributes(existingAttributes); command.updateConfigForGroup("cluster", cacheConfig, deltaConfig); RegionAttributesType.ExpirationAttributesType combinedExpirationAttributes = existingRegionConfig.getRegionAttributes().getEntryIdleTime(); assertThat(combinedExpirationAttributes.getTimeout()).isEqualTo("10"); assertThat(combinedExpirationAttributes.getAction()).isEqualTo("invalidate"); assertThat(combinedExpirationAttributes.getCustomExpiry().getClassName()).isEqualTo("abc"); }
@Test public void generatesWithExpirationIdleTimeAttributes() { regionExpirationTTL = 10; regionExpirationTTLAction = ExpirationAction.DESTROY; regionExpirationIdleTime = 3; regionExpirationIdleAction = ExpirationAction.INVALIDATE; entryExpirationTTL = 1; entryExpirationTTLAction = ExpirationAction.LOCAL_DESTROY; entryExpirationIdleTime = 12; entryExpirationIdleAction = ExpirationAction.LOCAL_DESTROY; entryIdleTimeCustomExpiry = new ClassName<>("java.lang.String"); generate(); RegionAttributesType.ExpirationAttributesType regionTimeToLive = config.getRegionAttributes().getRegionTimeToLive(); assertThat(regionTimeToLive.getTimeout()).isEqualTo("10"); RegionAttributesType.ExpirationAttributesType entryTimeToLive = config.getRegionAttributes().getEntryTimeToLive(); assertThat(entryTimeToLive.getAction()) .isEqualTo(ExpirationAction.LOCAL_DESTROY.toXmlString()); RegionAttributesType.ExpirationAttributesType entryIdleTime = config.getRegionAttributes().getEntryIdleTime(); DeclarableType customExpiry = entryIdleTime.getCustomExpiry(); assertThat(customExpiry.getClassName()).isEqualTo("java.lang.String"); assertThat(entryIdleTime.getAction()) .isEqualTo(ExpirationAction.LOCAL_DESTROY.toXmlString()); assertThat(entryIdleTime.getTimeout()) .isEqualTo("12"); }