From 4a1a3bf64dff43722bccb9cc6a911fc8165c2c40 Mon Sep 17 00:00:00 2001 From: John Blum Date: Fri, 21 Nov 2014 19:48:11 -0800 Subject: [PATCH] SGF-289 - Enumeration restrictions (xsd:enumeration) should be avoided in the XML schema. Removed the XSD enumeration restriction on the 'index-update-type' attribute of the 'baseRegionType' element in the Spring GemFire XML Schema (XSD). --- .../data/gemfire/CacheFactoryBean.java | 14 ++- .../data/gemfire/DataPolicyConverter.java | 6 +- .../data/gemfire/IndexMaintenanceType.java | 81 ++++++++++++++ .../IndexMaintenanceTypeConverter.java | 71 ++++++++++++ .../gemfire/RegionAttributesFactoryBean.java | 14 ++- .../data/gemfire/config/ParsingUtils.java | 10 +- .../gemfire/config/spring-gemfire-1.6.xsd | 8 +- .../IndexMaintenanceTypeConverterTest.java | 81 ++++++++++++++ .../gemfire/IndexMaintenanceTypeTest.java | 103 ++++++++++++++++++ .../config/ReplicatedRegionNamespaceTest.java | 15 +++ .../data/gemfire/config/replicated-ns.xml | 17 ++- 11 files changed, 395 insertions(+), 25 deletions(-) create mode 100644 src/main/java/org/springframework/data/gemfire/IndexMaintenanceType.java create mode 100644 src/main/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverter.java create mode 100644 src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverterTest.java create mode 100644 src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeTest.java diff --git a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java index afc1811a..e776648f 100644 --- a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java @@ -33,6 +33,7 @@ import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.core.io.Resource; import org.springframework.dao.DataAccessException; import org.springframework.dao.support.PersistenceExceptionTranslator; @@ -908,6 +909,15 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, return lazyInitialize; } + /* (non-Javadoc) */ + private void initBeanFactory() { + if (getBeanFactory() instanceof ConfigurableBeanFactory) { + ((ConfigurableBeanFactory) getBeanFactory()).registerCustomEditor(IndexMaintenanceType.class, + IndexMaintenanceTypeConverter.class); + } + } + + /* (non-Javadoc) */ protected void postProcessPropertiesBeforeInitialization(Properties gemfireProperties) { if (GemfireUtils.isGemfireVersion8OrAbove()) { gemfireProperties.setProperty("disable-auto-reconnect", String.valueOf( @@ -917,11 +927,13 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, } } - /* (non-Javadoc) + /* + * (non-Javadoc) * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet() */ @Override public void afterPropertiesSet() throws Exception { + initBeanFactory(); postProcessPropertiesBeforeInitialization(getProperties()); if (!isLazyInitialize()) { diff --git a/src/main/java/org/springframework/data/gemfire/DataPolicyConverter.java b/src/main/java/org/springframework/data/gemfire/DataPolicyConverter.java index db587979..3e56159c 100644 --- a/src/main/java/org/springframework/data/gemfire/DataPolicyConverter.java +++ b/src/main/java/org/springframework/data/gemfire/DataPolicyConverter.java @@ -21,8 +21,12 @@ import org.springframework.core.convert.converter.Converter; import com.gemstone.gemfire.cache.DataPolicy; /** + * The DataPolicyConverter class converts String values into GemFire DataPolicy enumerated values. + * * @author David Turanski - * + * @author John Blum + * @see org.springframework.core.convert.converter.Converter + * @see com.gemstone.gemfire.cache.DataPolicy */ public class DataPolicyConverter implements Converter { diff --git a/src/main/java/org/springframework/data/gemfire/IndexMaintenanceType.java b/src/main/java/org/springframework/data/gemfire/IndexMaintenanceType.java new file mode 100644 index 00000000..21daee4a --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/IndexMaintenanceType.java @@ -0,0 +1,81 @@ +/* + * Copyright 2010-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire; + +import com.gemstone.gemfire.cache.AttributesFactory; +import com.gemstone.gemfire.cache.RegionFactory; + +/** + * The IndexMaintenanceType enum is a enumerated type of GemFire Index maintenance update options. + * + * @author John Blum + * @see com.gemstone.gemfire.cache.AttributesFactory#setIndexMaintenanceSynchronous(boolean) + * @see com.gemstone.gemfire.cache.RegionAttributes#getIndexMaintenanceSynchronous() + * @see com.gemstone.gemfire.cache.RegionFactory#setIndexMaintenanceSynchronous(boolean) + * @since 1.6.0 + */ +@SuppressWarnings("unused") +public enum IndexMaintenanceType { + SYNCHRONOUS, + ASYNCHRONOUS; + + /** + * Determines the appropriate IndexMaintenanceType given a String value. This method is null-safe + * and case-insensitive. + * + * @param value the String value indicating the type of Index maintenance (update). + * @return a IndexMaintenanceType enumerated value based on the given String value, or null + * if the String representation does not match a IndexMaintenanceType. + * @see java.lang.Enum#name() + * @see java.lang.String#equalsIgnoreCase(String) + */ + public static IndexMaintenanceType valueOfIgnoreCase(final String value) { + for (IndexMaintenanceType indexMaintenanceType : values()) { + if (indexMaintenanceType.name().equalsIgnoreCase(value)) { + return indexMaintenanceType; + } + } + + return null; + } + + /** + * Sets the GemFire AttributesFactory's 'indexMaintenanceSynchronous' property appropriately based on + * this IndexMaintenanceType. + * + * @param attributesFactory the AttributesFactory instance on which to set the indexMaintenanceProperty. + * @throws java.lang.NullPointerException if the AttributesFactory reference is null. + * @see #setIndexMaintenance(com.gemstone.gemfire.cache.RegionFactory) + */ + @SuppressWarnings("deprecation") + public void setIndexMaintenance(final AttributesFactory attributesFactory) { + attributesFactory.setIndexMaintenanceSynchronous(equals(SYNCHRONOUS)); + } + + /** + * Sets the GemFire RegionFactory's 'indexMaintenanceSynchronous' property appropriately based on + * this IndexMaintenanceType. + * + * @param regionFactory the RegionFactory instance on which to set the indexMaintenanceProperty. + * @throws java.lang.NullPointerException if the RegionFactory reference is null. + * @see #setIndexMaintenance(com.gemstone.gemfire.cache.AttributesFactory) + */ + public void setIndexMaintenance(final RegionFactory regionFactory) { + regionFactory.setIndexMaintenanceSynchronous(equals(SYNCHRONOUS)); + } + +} diff --git a/src/main/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverter.java b/src/main/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverter.java new file mode 100644 index 00000000..bb4c2e39 --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverter.java @@ -0,0 +1,71 @@ +/* + * Copyright 2010-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire; + +import java.beans.PropertyEditorSupport; + +import org.springframework.core.convert.converter.Converter; + +/** + * The IndexMaintenanceTypeConverter class... + * + * @author John Blum + * @see java.beans.PropertyEditorSupport + * @see org.springframework.core.convert.converter.Converter + * @since 1.5.0 + */ +@SuppressWarnings("unused") +public class IndexMaintenanceTypeConverter extends PropertyEditorSupport implements Converter { + + /* (non-Javadoc) */ + private IndexMaintenanceType assertConverted(final String source, final IndexMaintenanceType indexMaintenanceType) { + if (indexMaintenanceType == null) { + throw new IllegalArgumentException(String.format("Source (%1$s) is not a valid IndexMaintenanceType!", + source)); + } + + return indexMaintenanceType; + } + + /** + * Sets the IndexMaintenanceType by parsing a given String. May raise a java.lang.IllegalArgumentException + * if either the String is badly formatted or the text cannot be expressed as a IndexMaintenanceType. + * + * @param text the String value to express (convert) as a IndexMaintenanceType. + * @throws java.lang.IllegalArgumentException if the String value does not represent a valid IndexMaintenanceType. + * @see #convert(String) + * @see #setValue(Object) + */ + @Override + public void setAsText(final String text) throws IllegalArgumentException { + setValue(convert(text)); + } + + /** + * Converts the given String value into an appropriate IndexMaintenanceType. + * + * @param source the String value to convert into a IndexMaintenanceType. + * @return a IndexMaintenanceType for the given String value. + * @throws java.lang.IllegalArgumentException if the String value does not represent a valid IndexMaintenanceType. + * @see org.springframework.data.gemfire.IndexMaintenanceType#valueOfIgnoreCase(String) + */ + @Override + public IndexMaintenanceType convert(final String source) { + return assertConverted(source, IndexMaintenanceType.valueOfIgnoreCase(source)); + } + +} diff --git a/src/main/java/org/springframework/data/gemfire/RegionAttributesFactoryBean.java b/src/main/java/org/springframework/data/gemfire/RegionAttributesFactoryBean.java index aee84841..692485d6 100644 --- a/src/main/java/org/springframework/data/gemfire/RegionAttributesFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/RegionAttributesFactoryBean.java @@ -19,11 +19,11 @@ package org.springframework.data.gemfire; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; +import com.gemstone.gemfire.cache.AttributesFactory; import com.gemstone.gemfire.cache.RegionAttributes; /** - * Spring-friendly bean for creating {@link RegionAttributes}. Eliminates the need of using - * a XML 'factory-method' tag. + * Spring-friendly bean for creating {@link RegionAttributes}. Eliminates the need of using a XML 'factory-method' tag. * * @author Costin Leau * @author John Blum @@ -32,9 +32,9 @@ import com.gemstone.gemfire.cache.RegionAttributes; * @see com.gemstone.gemfire.cache.AttributesFactory * @see com.gemstone.gemfire.cache.RegionAttributes */ -@SuppressWarnings("deprecation") -public class RegionAttributesFactoryBean extends com.gemstone.gemfire.cache.AttributesFactory - implements FactoryBean, InitializingBean { +@SuppressWarnings({ "deprecation", "unused" }) +public class RegionAttributesFactoryBean extends AttributesFactory implements FactoryBean, + InitializingBean { private RegionAttributes attributes; @@ -53,6 +53,10 @@ public class RegionAttributesFactoryBean extends com.gemstone.gemfire.cache.Attr return true; } + public void setIndexUpdateType(final IndexMaintenanceType indexUpdateType) { + indexUpdateType.setIndexMaintenance(this); + } + @Override public void afterPropertiesSet() throws Exception { attributes = super.create(); diff --git a/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java b/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java index fd195dc6..3c6cb109 100644 --- a/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java +++ b/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java @@ -307,6 +307,7 @@ abstract class ParsingUtils { setPropertyValue(element, regionAttributesBuilder, "enable-async-conflation"); setPropertyValue(element, regionAttributesBuilder, "enable-subscription-conflation"); setPropertyValue(element, regionAttributesBuilder, "ignore-jta", "ignoreJTA"); + setPropertyValue(element, regionAttributesBuilder, "index-update-type"); setPropertyValue(element, regionAttributesBuilder, "initial-capacity"); setPropertyValue(element, regionAttributesBuilder, "is-lock-grantor", "lockGrantor"); setPropertyValue(element, regionAttributesBuilder, "key-constraint"); @@ -315,18 +316,11 @@ abstract class ParsingUtils { setPropertyValue(element, regionAttributesBuilder, "publisher"); setPropertyValue(element, regionAttributesBuilder, "value-constraint"); - String indexUpdateType = element.getAttribute("index-update-type"); - - if (StringUtils.hasText(indexUpdateType)) { - regionAttributesBuilder.addPropertyValue("indexMaintenanceSynchronous", - "synchronous".equals(indexUpdateType)); - } - String concurrencyChecksEnabled = element.getAttribute("concurrency-checks-enabled"); if (StringUtils.hasText(concurrencyChecksEnabled)) { if (!GemfireUtils.isGemfireVersion7OrAbove()) { - log.warn("Setting 'concurrency-checks-enabled' is only available in Gemfire 7.0 or above"); + log.warn("Setting 'concurrency-checks-enabled' is only available in Gemfire 7.0 or above!"); } else { ParsingUtils.setPropertyValue(element, regionAttributesBuilder, "concurrency-checks-enabled"); diff --git a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd index 7306344c..3a47dc58 100644 --- a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd +++ b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd @@ -896,19 +896,13 @@ Specifies if WAN Gateway hub id if enable-gateway is true. (Deprecated since Gem ]]> - + - - - - - - diff --git a/src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverterTest.java b/src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverterTest.java new file mode 100644 index 00000000..c9890172 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeConverterTest.java @@ -0,0 +1,81 @@ +/* + * Copyright 2010-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.After; +import org.junit.Test; + +/** + * The IndexMaintenanceTypeConverterTest class is a test suite of test case testing the contract and functionality + * of the IndexMaintenanceTypeConverter. + * + * @author John Blum + * @see org.junit.Test + * @see org.mockito.Mockito + * @see org.springframework.data.gemfire.IndexMaintenanceTypeConverter + * @since 1.6.0 + */ +public class IndexMaintenanceTypeConverterTest { + + private final IndexMaintenanceTypeConverter converter = new IndexMaintenanceTypeConverter(); + + @After + public void tearDown() { + converter.setValue(null); + } + + @Test + public void testConvert() { + assertEquals(IndexMaintenanceType.SYNCHRONOUS, converter.convert("Synchronous")); + assertEquals(IndexMaintenanceType.ASYNCHRONOUS, converter.convert("asynchronous")); + } + + @Test(expected = IllegalArgumentException.class) + public void testConvertThrowsIllegalArgumentExceptionForInvalidStringValue() { + try { + converter.convert("sync"); + } + catch (IllegalArgumentException expected) { + assertEquals("Source (sync) is not a valid IndexMaintenanceType!", expected.getMessage()); + throw expected; + } + } + + @Test + public void testSetAsText() { + converter.setAsText("aSynchronous"); + assertEquals(IndexMaintenanceType.ASYNCHRONOUS, converter.getValue()); + converter.setAsText("synchronous"); + assertEquals(IndexMaintenanceType.SYNCHRONOUS, converter.getValue()); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetAsTextThrowsIllegalArgumentException() { + try { + assertNull(converter.getValue()); + converter.setAsText("async"); + } + catch (IllegalArgumentException expected) { + assertEquals("Source (async) is not a valid IndexMaintenanceType!", expected.getMessage()); + throw expected; + } + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeTest.java b/src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeTest.java new file mode 100644 index 00000000..63923e41 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/IndexMaintenanceTypeTest.java @@ -0,0 +1,103 @@ +/* + * Copyright 2010-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import org.junit.Test; + +import com.gemstone.gemfire.cache.AttributesFactory; +import com.gemstone.gemfire.cache.RegionFactory; + +/** + * The IndexMaintenanceTypeTest class is a test suite of test cases testing the contract and functionality of the + * IndexMaintenanceType enum type. + * + * @author John Blum + * @see org.junit.Test + * @see org.mockito.Mockito + * @see org.springframework.data.gemfire.IndexMaintenanceType + * @since 1.6.0 + */ +public class IndexMaintenanceTypeTest { + + @Test + public void testValueOfIgnoreCase() { + assertEquals(IndexMaintenanceType.SYNCHRONOUS, IndexMaintenanceType.valueOfIgnoreCase("SYNCHRONOUS")); + assertEquals(IndexMaintenanceType.SYNCHRONOUS, IndexMaintenanceType.valueOfIgnoreCase("Synchronous")); + assertEquals(IndexMaintenanceType.SYNCHRONOUS, IndexMaintenanceType.valueOfIgnoreCase("synchronous")); + assertEquals(IndexMaintenanceType.SYNCHRONOUS, IndexMaintenanceType.valueOfIgnoreCase("SynCHrOnOus")); + assertEquals(IndexMaintenanceType.ASYNCHRONOUS, IndexMaintenanceType.valueOfIgnoreCase("ASYNChronous")); + } + + @Test + public void testValueOfIgnoreCaseIsNull() { + assertNull(IndexMaintenanceType.valueOfIgnoreCase("synchronicity")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase("SYNC")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase("ASYNC")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase("CONCURRENT")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase("parallel")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase(" ")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase("")); + assertNull(IndexMaintenanceType.valueOfIgnoreCase(null)); + } + + @Test + @SuppressWarnings("deprecation") + public void testAttributesFactorySetIndexMaintenanceAsynchronous() { + AttributesFactory mockAttributesFactory = mock(AttributesFactory.class, + "testAttributesFactorySetIndexMaintenanceAsynchronous"); + + IndexMaintenanceType.ASYNCHRONOUS.setIndexMaintenance(mockAttributesFactory); + + verify(mockAttributesFactory).setIndexMaintenanceSynchronous(eq(false)); + } + + @Test + @SuppressWarnings("deprecation") + public void testAttributesFactorySetIndexMaintenanceSynchronous() { + AttributesFactory mockAttributesFactory = mock(AttributesFactory.class, + "testAttributesFactorySetIndexMaintenanceAsynchronous"); + + IndexMaintenanceType.SYNCHRONOUS.setIndexMaintenance(mockAttributesFactory); + + verify(mockAttributesFactory).setIndexMaintenanceSynchronous(eq(true)); + } + + @Test + public void testRegionFactorySetIndexMaintenanceAsynchronous() { + RegionFactory mockRegionFactory = mock(RegionFactory.class, "testRegionFactorySetIndexMaintenanceAsynchronous"); + + IndexMaintenanceType.ASYNCHRONOUS.setIndexMaintenance(mockRegionFactory); + + verify(mockRegionFactory).setIndexMaintenanceSynchronous(eq(false)); + } + + @Test + public void testRegionFactorySetIndexMaintenanceSynchronous() { + RegionFactory mockRegionFactory = mock(RegionFactory.class, "testRegionFactorySetIndexMaintenanceSynchronous"); + + IndexMaintenanceType.SYNCHRONOUS.setIndexMaintenance(mockRegionFactory); + + verify(mockRegionFactory).setIndexMaintenanceSynchronous(eq(true)); + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/config/ReplicatedRegionNamespaceTest.java b/src/test/java/org/springframework/data/gemfire/config/ReplicatedRegionNamespaceTest.java index 147dbc64..bc7a3505 100644 --- a/src/test/java/org/springframework/data/gemfire/config/ReplicatedRegionNamespaceTest.java +++ b/src/test/java/org/springframework/data/gemfire/config/ReplicatedRegionNamespaceTest.java @@ -147,6 +147,21 @@ public class ReplicatedRegionNamespaceTest { assertEquals(String.class, regionAttributes.getValueConstraint()); } + @Test + public void testReplicatedWithSynchronousIndexUpdates() { + assertTrue(context.containsBean("replicated-with-synchronous-index-updates")); + + Region region = context.getBean("replicated-with-synchronous-index-updates", Region.class); + + assertNotNull(String.format("The '%1$s' Region was not properly configured and initialized!", + "replicated-with-synchronous-index-updates"), region); + + RegionAttributes regionAttributes = region.getAttributes(); + + assertNotNull(regionAttributes); + assertTrue(regionAttributes.getIndexMaintenanceSynchronous()); + } + @Test @SuppressWarnings("rawtypes") public void testRegionLookup() throws Exception { diff --git a/src/test/resources/org/springframework/data/gemfire/config/replicated-ns.xml b/src/test/resources/org/springframework/data/gemfire/config/replicated-ns.xml index 14391315..8036b27b 100644 --- a/src/test/resources/org/springframework/data/gemfire/config/replicated-ns.xml +++ b/src/test/resources/org/springframework/data/gemfire/config/replicated-ns.xml @@ -1,11 +1,13 @@ @@ -31,6 +33,10 @@ + + + + + + synchronous + + + + + + - - -