private List<DeclarableType> stringsToDeclarableTypes(String[] objects) { return Arrays.stream(objects).map(fullyQualifiedClassName -> { DeclarableType thisFilter = new DeclarableType(); thisFilter.setClassName(fullyQualifiedClassName); return thisFilter; }).collect(Collectors.toList()); }
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; }
@Test public void declarableWithDeclarableParam() { DeclarableType declarable = new DeclarableType("className"); ParameterType param = new ParameterType("param1"); param.setDeclarable(new DeclarableType("anotherClassName", "{'k':'v'}")); declarable.getParameters().add(param); assertThat(declarable.toString()).isEqualTo("className{param1:anotherClassName{k:v}}"); DeclarableType d2 = new DeclarableType("className"); ParameterType p2 = new ParameterType("param1"); p2.setDeclarable(new DeclarableType("anotherClassName", "{'k':'v'}")); d2.getParameters().add(p2); assertThat(declarable).isEqualTo(d2); DeclarableType d3 = new DeclarableType("className"); ParameterType p3 = new ParameterType("param1"); p3.setDeclarable(new DeclarableType("anotherClassName", "{'k':'v2'}")); d3.getParameters().add(p3); assertThat(declarable).isNotEqualTo(d3); }
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); } }
@Test public void emptyDeclarable() { assertThat(new DeclarableType("")) .isEqualTo(new DeclarableType("", (Properties) null)) .isEqualTo(new DeclarableType("", "")) .isEqualTo(new DeclarableType("", "{}")) .isEqualTo(new DeclarableType(" ", "{}")) .isEqualTo(new DeclarableType(null, "{}")) .isEqualTo(DeclarableType.EMPTY); } }
@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 createDeclarableInstancedFromNestedDeclarableType() { DeclarableType declarableType = new DeclarableType(MyDeclarable.class.getName(), "{\"value1\":5,\"value2\":\"some string\"}"); ParameterType parameterType = new ParameterType("inner-prop", declarableType); DeclarableType outerDeclarable = new DeclarableType(MyOuterDeclarable.class.getName()); outerDeclarable.getParameters().add(parameterType); MyOuterDeclarable result = DeclarableTypeInstantiator.newInstance(outerDeclarable, cache); assertThat(result.props).isNotNull(); MyDeclarable innerDeclarable = (MyDeclarable) result.props.get("inner-prop"); assertThat(innerDeclarable.props.getProperty("value1")).isEqualTo("5"); assertThat(innerDeclarable.props.getProperty("value2")).isEqualTo("some string"); } }
@Override public String toString() { if (string != null) { return string; } if (declarable != null) { return declarable.toString(); } return ""; }
if (newCustomExpiry.equals(DeclarableType.EMPTY)) { mutator2.accept(null); } else {
public ExpirationAttributesType(Integer timeout, ExpirationAction action, String expiry, Properties iniProps) { expirationAttributes.setTimeout(Objects.toString(timeout, null)); if (action != null) { expirationAttributes.setAction(action.toXmlString()); } if (expiry != null) { expirationAttributes.setCustomExpiry(new DeclarableType(expiry, iniProps)); } }
@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"); }
@Before public void setUp() throws Exception { cacheConfig = new CacheConfig("1.0"); cacheXml = "<cache version=\"1.0\" xsi:schemaLocation=\"http://geode.apache.org/schema/cache http://geode.apache.org/schema/cache/cache-1.0.xsd\" xmlns=\"http://geode.apache.org/schema/cache\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">"; service = new JAXBService(CacheConfig.class); service.validateWithLocalCacheXSD(); regionConfig = new RegionConfig(); regionConfig.setName("regionA"); regionConfig.setType("REPLICATE"); regionXml = "<region name=\"regionA\" refid=\"REPLICATE\">"; classNameTypeXml = "<class-name>my.className</class-name>"; declarableWithString = new DeclarableType("my.className", "{'key':'value'}"); declarableWithStringXml = classNameTypeXml + "<parameter name=\"key\"><string>value</string></parameter>"; declarableWithParam = new DeclarableType("my.className"); ParameterType param = new ParameterType("key"); param.setDeclarable(declarableWithString); declarableWithParam.getParameters().add(param); declarableWithParamXml = classNameTypeXml + "<parameter name=\"key\"><declarable>" + declarableWithStringXml + "</declarable></parameter>"; }
String gatewaySubstitutionFilter = gatewayEventSubstitutionFilter.getClassName(); asyncEventQueueFactory.setGatewayEventSubstitutionListener( (GatewayEventSubstitutionFilter<?, ?>) newInstance(gatewaySubstitutionFilter)); 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) {
if (!newCacheListener.equals(DeclarableType.EMPTY)) { mutator.addCacheListener(DeclarableTypeInstantiator.newInstance(newCacheListener, cache)); if (cacheLoader.equals(DeclarableType.EMPTY)) { mutator.setCacheLoader(null); } else { if (cacheWriter.equals(DeclarableType.EMPTY)) { mutator.setCacheWriter(null); } else {
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 void setCacheWriter(RegionAttributesType attributes) { DeclarableType writer = new DeclarableType(); writer.setClassName(JdbcWriter.class.getName()); attributes.setCacheWriter(writer); } }
@Test public void createDeclarableInstanceFromDeclarableType() { DeclarableType declarableType = new DeclarableType(MyDeclarable.class.getName(), "{\"value1\":5,\"value2\":\"some string\"}"); MyDeclarable result = DeclarableTypeInstantiator.newInstance(declarableType, cache); assertThat(result).isNotNull().isInstanceOf(MyDeclarable.class); assertThat(result.props).isNotNull(); assertThat(result.props.getProperty("value1")).isEqualTo("5"); assertThat(result.props.getProperty("value2")).isEqualTo("some string"); }
@Test public void declarableWithStringParam() { DeclarableType declarable = new DeclarableType("className"); assertThat(declarable).isEqualTo(declarable); assertThat(declarable).isEqualTo(new DeclarableType("className")); assertThat(declarable).isNotEqualTo(new DeclarableType("anotherClassName")); ParameterType parameter = new ParameterType("name", "value"); declarable.getParameters().add(parameter); DeclarableType d2 = new DeclarableType("className"); assertThat(declarable).isNotEqualTo(d2); d2.getParameters().add(parameter); assertThat(declarable).isEqualTo(d2); // has one common parameter, but d2 has additional param d2.getParameters().add(new ParameterType("name1", "value1")); assertThat(declarable).isNotEqualTo(d2); // same size, but different param value DeclarableType d3 = new DeclarableType("className"); d3.getParameters().add(new ParameterType("name", "value1")); assertThat(declarable).isNotEqualTo(d3); assertThat(declarable.toString()).isEqualTo("className{name:value}"); }
ExpirationAttributesType combine(ExpirationAttributesType existing, ExpirationAttributesType delta) { if (delta == null) { return existing; } if (existing == null) { existing = new ExpirationAttributesType(); existing.setAction(ExpirationAction.INVALIDATE.toXmlString()); existing.setTimeout("0"); } if (delta.getTimeout() != null) { existing.setTimeout(delta.getTimeout()); } if (delta.getAction() != null) { existing.setAction(delta.getAction()); } if (delta.getCustomExpiry() != null) { if (delta.getCustomExpiry().equals(DeclarableType.EMPTY)) { existing.setCustomExpiry(null); } else { existing.setCustomExpiry(delta.getCustomExpiry()); } } return existing; }
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()); } } }