@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()); }
CacheConfig.AsyncEventQueue config = new CacheConfig.AsyncEventQueue(); config.setAsyncEventListener(new DeclarableType(listener, listenerProperties)); config.setBatchSize(String.valueOf(batchSize)); config.setBatchTimeInterval(String.valueOf(batchTimeInterval)); config.setDiskStoreName(diskStore); config.setDiskSynchronous(diskSynchronous); config.setDispatcherThreads(String.valueOf(dispatcherThreads)); config.setEnableBatchConflation(enableBatchConflation); config.setForwardExpirationDestroy(forwardExpirationDestroy); if (gatewayEventFilters != null) { config.getGatewayEventFilters().addAll(Arrays.stream(gatewayEventFilters) .map(classname -> new DeclarableType((classname))).collect(Collectors.toList())); config.setGatewayEventSubstitutionFilter(new DeclarableType(gatewaySubstitutionListener)); config.setId(id); config.setMaximumQueueMemory(String.valueOf(maxQueueMemory)); config.setOrderPolicy(orderPolicy); config.setParallel(parallel); config.setPersistent(persistent);
cache.createAsyncEventQueueFactory().setParallel(config.isParallel()) .setBatchConflationEnabled(config.isEnableBatchConflation()) .setBatchSize(Integer.parseInt(config.getBatchSize())) .setBatchTimeInterval(Integer.parseInt(config.getBatchTimeInterval())) .setPersistent(config.isPersistent()).setDiskStoreName(config.getDiskStoreName()) .setDiskSynchronous(config.isDiskSynchronous()) .setForwardExpirationDestroy(config.isForwardExpirationDestroy()) .setMaximumQueueMemory(Integer.parseInt(config.getMaximumQueueMemory())) .setDispatcherThreads(Integer.parseInt(config.getDispatcherThreads())) .setOrderPolicy(OrderPolicy.valueOf(config.getOrderPolicy())); String[] gatewayEventFilters = config.getGatewayEventFilters().stream() .map(ClassNameType::getClassName).toArray(String[]::new); DeclarableType gatewayEventSubstitutionFilter = config.getGatewayEventSubstitutionFilter(); String listenerClassName = config.getAsyncEventListener().getClassName(); Object listenerInstance; Class<?> listenerClass = InternalDataSerializer.getCachedClass(listenerClassName); listenerInstance = listenerClass.newInstance(); List<ParameterType> parameters = config.getAsyncEventListener().getParameters(); Properties listenerProperties = new Properties(); for (ParameterType p : parameters) { asyncEventQueueFactory.create(config.getId(), (AsyncEventListener) listenerInstance);
assertThat(asyncEventQueue.getAsyncEventListener()).isEqualTo(declarableWithString); assertThat(asyncEventQueue.getGatewayEventFilters().get(0)).isEqualTo(declarableWithString); assertThat(asyncEventQueue.getGatewayEventSubstitutionFilter()).isEqualTo(declarableWithString);
CacheConfig.AsyncEventQueue aeqConfiguration = new CacheConfig.AsyncEventQueue(); aeqConfiguration.setId(id); aeqConfiguration.setBatchSize(batchSize + ""); aeqConfiguration.setBatchTimeInterval(batchTimeInterval + ""); aeqConfiguration.setMaximumQueueMemory(maxQueueMemory + "");
@Test public void createsMappingReturnsStatusERRORWhenAsycnEventQueueAlreadyExists() { 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); when(loaderAttribute.getCacheLoader()).thenReturn(null); when(matchingRegion.getRegionAttributes()).thenReturn(loaderAttribute); List<AsyncEventQueue> asyncEventQueues = new ArrayList<>(); AsyncEventQueue matchingQueue = mock(AsyncEventQueue.class); String queueName = createRegionMappingCommand.createAsyncEventQueueName(regionName); when(matchingQueue.getId()).thenReturn(queueName); asyncEventQueues.add(matchingQueue); when(cacheConfig.getAsyncEventQueues()).thenReturn(asyncEventQueues); ResultModel result = createRegionMappingCommand.createMapping(regionName, dataSourceName, tableName, pdxClass, false, null, null, null); assertThat(result.getStatus()).isSameAs(Result.Status.ERROR); assertThat(result.toString()) .contains("An async-event-queue named " + queueName + " must not already exist."); }
@Override public boolean updateConfigForGroup(String group, CacheConfig config, Object configObject) { boolean aeqConfigsHaveBeenUpdated = false; List<CacheConfig.AsyncEventQueue> queues = config.getAsyncEventQueues(); if (queues.isEmpty()) { return false; } CacheConfig.AsyncEventQueue aeqConfiguration = ((CacheConfig.AsyncEventQueue) configObject); String aeqId = aeqConfiguration.getId(); for (CacheConfig.AsyncEventQueue queue : queues) { if (aeqId.equals(queue.getId())) { if (StringUtils.isNotBlank(aeqConfiguration.getBatchSize())) { queue.setBatchSize(aeqConfiguration.getBatchSize()); } if (StringUtils.isNotBlank(aeqConfiguration.getBatchTimeInterval())) { queue.setBatchTimeInterval(aeqConfiguration.getBatchTimeInterval()); } if (StringUtils.isNotBlank(aeqConfiguration.getMaximumQueueMemory())) { queue.setMaximumQueueMemory(aeqConfiguration.getMaximumQueueMemory()); } aeqConfigsHaveBeenUpdated = true; } } return aeqConfigsHaveBeenUpdated; }
@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 createMappingWithSynchronousReturnsStatusOKWhenAsycnEventQueueAlreadyExists() { 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); when(loaderAttribute.getCacheLoader()).thenReturn(null); when(matchingRegion.getRegionAttributes()).thenReturn(loaderAttribute); List<AsyncEventQueue> asyncEventQueues = new ArrayList<>(); AsyncEventQueue matchingQueue = mock(AsyncEventQueue.class); String queueName = createRegionMappingCommand.createAsyncEventQueueName(regionName); when(matchingQueue.getId()).thenReturn(queueName); asyncEventQueues.add(matchingQueue); when(cacheConfig.getAsyncEventQueues()).thenReturn(asyncEventQueues); ResultModel result = createRegionMappingCommand.createMapping(regionName, dataSourceName, tableName, pdxClass, true, null, null, null); assertThat(result.getStatus()).isSameAs(Result.Status.OK); }
@Test public void updateClusterConfigWithOneMatchingRegionAndJdbcAsyncQueueRemovesTheQueue() { 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); AsyncEventQueue queue = mock(AsyncEventQueue.class); String queueName = CreateMappingCommand.createAsyncEventQueueName(regionName); when(queue.getId()).thenReturn(queueName); List<AsyncEventQueue> queueList = new ArrayList<>(); queueList.add(queue); when(cacheConfig.getAsyncEventQueues()).thenReturn(queueList); boolean modified = destroyRegionMappingCommand.updateConfigForGroup(null, cacheConfig, regionName); assertThat(queueList).isEmpty(); assertThat(modified).isTrue(); }
@Test public void updateClusterConfigWithOneMatchingPartitionedRegionCreatesParallelAsyncEventQueue() { 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); when(matchingRegionAttributes.getDataPolicy()) .thenReturn(RegionAttributesDataPolicy.PARTITION); createRegionMappingCommand.updateConfigForGroup(null, cacheConfig, arguments); assertThat(queueList.get(0).isParallel()).isTrue(); }
private void checkForAsyncQueue(String regionName, boolean synchronous, CacheConfig cacheConfig) throws PreconditionException { if (!synchronous) { String queueName = createAsyncEventQueueName(regionName); AsyncEventQueue asyncEventQueue = cacheConfig.getAsyncEventQueues().stream() .filter(queue -> queue.getId().equals(queueName)).findFirst().orElse(null); if (asyncEventQueue != null) { throw new PreconditionException( "An async-event-queue named " + queueName + " must not already exist."); } } }
private boolean removeJdbcQueueFromCache(CacheConfig cacheConfig, String regionName) { String queueName = CreateMappingCommand.createAsyncEventQueueName(regionName); Iterator<AsyncEventQueue> iterator = cacheConfig.getAsyncEventQueues().iterator(); while (iterator.hasNext()) { AsyncEventQueue queue = iterator.next(); if (queueName.equals(queue.getId())) { iterator.remove(); return true; } } return false; }
private void createAsyncQueue(CacheConfig cacheConfig, RegionAttributesType attributes, String queueName) { AsyncEventQueue asyncEventQueue = new AsyncEventQueue(); asyncEventQueue.setId(queueName); boolean isPartitioned = attributes.getDataPolicy().equals(RegionAttributesDataPolicy.PARTITION) || attributes.getDataPolicy().equals(RegionAttributesDataPolicy.PERSISTENT_PARTITION); asyncEventQueue.setParallel(isPartitioned); DeclarableType listener = new DeclarableType(); listener.setClassName(JdbcAsyncWriter.class.getName()); asyncEventQueue.setAsyncEventListener(listener); cacheConfig.getAsyncEventQueues().add(asyncEventQueue); }