diff --git a/src/main/java/org/springframework/data/gemfire/config/AsyncEventQueueParser.java b/src/main/java/org/springframework/data/gemfire/config/AsyncEventQueueParser.java index 1bd4213e..84a0bf50 100644 --- a/src/main/java/org/springframework/data/gemfire/config/AsyncEventQueueParser.java +++ b/src/main/java/org/springframework/data/gemfire/config/AsyncEventQueueParser.java @@ -54,6 +54,7 @@ class AsyncEventQueueParser extends AbstractSingleBeanDefinitionParser { ParsingUtils.setPropertyValue(element, builder, "batch-time-interval"); ParsingUtils.setPropertyValue(element, builder, "disk-synchronous"); ParsingUtils.setPropertyValue(element, builder, "dispatcher-threads"); + ParsingUtils.setPropertyValue(element, builder, "ignore-eviction-and-expiration"); ParsingUtils.setPropertyValue(element, builder, "maximum-queue-memory"); ParsingUtils.setPropertyValue(element, builder, "order-policy"); ParsingUtils.setPropertyValue(element, builder, "parallel"); diff --git a/src/main/java/org/springframework/data/gemfire/wan/AsyncEventQueueFactoryBean.java b/src/main/java/org/springframework/data/gemfire/wan/AsyncEventQueueFactoryBean.java index 65c6c413..1739dbae 100644 --- a/src/main/java/org/springframework/data/gemfire/wan/AsyncEventQueueFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/wan/AsyncEventQueueFactoryBean.java @@ -39,6 +39,7 @@ public class AsyncEventQueueFactoryBean extends AbstractWANComponentFactoryBean< private Boolean batchConflationEnabled; private Boolean diskSynchronous; + private Boolean ignoreEvictionAndExpiration; private Boolean parallel; private Boolean persistent; @@ -112,6 +113,10 @@ public class AsyncEventQueueFactoryBean extends AbstractWANComponentFactoryBean< asyncEventQueueFactory.setDiskSynchronous(diskSynchronous); } + if (ignoreEvictionAndExpiration != null) { + asyncEventQueueFactory.setIgnoreEvictionAndExpiration(ignoreEvictionAndExpiration); + } + if (maximumQueueMemory != null) { asyncEventQueueFactory.setMaximumQueueMemory(maximumQueueMemory); } @@ -204,6 +209,11 @@ public class AsyncEventQueueFactoryBean extends AbstractWANComponentFactoryBean< this.dispatcherThreads = dispatcherThreads; } + /* (non-Javadoc) */ + public void setIgnoreEvictionAndExpiration(Boolean ignoreEvictionAndExpiration) { + this.ignoreEvictionAndExpiration = ignoreEvictionAndExpiration; + } + public void setMaximumQueueMemory(Integer maximumQueueMemory) { this.maximumQueueMemory = maximumQueueMemory; } @@ -234,5 +244,4 @@ public class AsyncEventQueueFactoryBean extends AbstractWANComponentFactoryBean< public void setPersistent(Boolean persistent) { this.persistent = persistent; } - } diff --git a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.8.xsd b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.8.xsd index b19380b8..823922f2 100644 --- a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.8.xsd +++ b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.8.xsd @@ -2952,6 +2952,7 @@ if an inner bean. ]]> + diff --git a/src/test/java/org/springframework/data/gemfire/config/AsyncEventQueueNamespaceTest.java b/src/test/java/org/springframework/data/gemfire/config/AsyncEventQueueNamespaceTest.java new file mode 100644 index 00000000..2fc8a596 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/config/AsyncEventQueueNamespaceTest.java @@ -0,0 +1,107 @@ +/* + * Copyright 2012 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.config; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; +import static org.junit.Assert.assertThat; + +import java.util.List; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import com.gemstone.gemfire.cache.asyncqueue.AsyncEvent; +import com.gemstone.gemfire.cache.asyncqueue.AsyncEventListener; +import com.gemstone.gemfire.cache.asyncqueue.AsyncEventQueue; +import com.gemstone.gemfire.cache.wan.GatewaySender; + +/** + * The AsyncEventQueueNamespaceTest class is a test suite of test cases testing the contract and functionality + * of configuring a Pivotal GemFire or Apache Geode {@link AsyncEventQueue} using the SDG XML namespace. + * + * @author John Blum + * @see org.junit.Test + * @see org.junit.runner.RunWith + * @see org.springframework.data.gemfire.config.AsyncEventQueueParser + * @see org.springframework.data.gemfire.wan.AsyncEventQueueFactoryBean + * @see org.springframework.test.context.ContextConfiguration + * @see org.springframework.test.context.junit4.SpringJUnit4ClassRunner + * @see com.gemstone.gemfire.cache.asyncqueue.AsyncEventQueue + * @since 1.0.0 + */ +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration +@SuppressWarnings("all") +public class AsyncEventQueueNamespaceTest { + + @Autowired + private AsyncEventQueue asyncEventQueue; + + @Test + public void asyncEventQueueIsConfiguredProperly() { + assertThat(asyncEventQueue, is(notNullValue(AsyncEventQueue.class))); + assertThat(asyncEventQueue.getId(), is(equalTo("TestAsyncEventQueue"))); + assertThat(asyncEventQueue.isBatchConflationEnabled(), is(true)); + assertThat(asyncEventQueue.getBatchSize(), is(equalTo(100))); + assertThat(asyncEventQueue.getBatchTimeInterval(), is(equalTo(30))); + assertThat(asyncEventQueue.getDiskStoreName(), is(equalTo("TestDiskStore"))); + assertThat(asyncEventQueue.isDiskSynchronous(), is(true)); + assertThat(asyncEventQueue.getDispatcherThreads(), is(equalTo(4))); + assertThat(asyncEventQueue.isIgnoreEvictionAndExpiration(), is(false)); + assertThat(asyncEventQueue.getMaximumQueueMemory(), is(equalTo(50))); + assertThat(asyncEventQueue.getOrderPolicy(), is(equalTo(GatewaySender.OrderPolicy.KEY))); + assertThat(asyncEventQueue.isParallel(), is(false)); + assertThat(asyncEventQueue.isPersistent(), is(true)); + } + + @Test + public void asyncEventQueueListenerEqualsExpected() { + AsyncEventListener asyncEventListener = asyncEventQueue.getAsyncEventListener(); + + assertThat(asyncEventListener, is(notNullValue(AsyncEventListener.class))); + assertThat(asyncEventListener.toString(), is(equalTo("TestAeqListener"))); + } + + public static class TestAsyncEventListener implements AsyncEventListener { + + private final String name; + + public TestAsyncEventListener(String name) { + this.name = name; + } + + @Override + public boolean processEvents(List events) { + return false; + } + + @Override + public void close() { + } + + @Override + public String toString() { + return this.name; + } + } +} diff --git a/src/test/java/org/springframework/data/gemfire/test/StubAsyncEventQueueFactory.java b/src/test/java/org/springframework/data/gemfire/test/StubAsyncEventQueueFactory.java index 4c13943e..598a5288 100644 --- a/src/test/java/org/springframework/data/gemfire/test/StubAsyncEventQueueFactory.java +++ b/src/test/java/org/springframework/data/gemfire/test/StubAsyncEventQueueFactory.java @@ -38,6 +38,7 @@ public class StubAsyncEventQueueFactory implements AsyncEventQueueFactory { private boolean batchConflationEnabled; private boolean diskSynchronous; + private boolean ignoreEvictionAndExpiration; private boolean parallel; private boolean persistent; @@ -55,63 +56,50 @@ public class StubAsyncEventQueueFactory implements AsyncEventQueueFactory { private String diskStoreName; @Override - public AsyncEventQueue create(final String name, final AsyncEventListener listener) { + public AsyncEventQueue create(String name, AsyncEventListener listener) { when(asyncEventQueue.getAsyncEventListener()).thenReturn(listener); - when(asyncEventQueue.getBatchSize()).thenReturn(this.batchSize); - when(asyncEventQueue.getDiskStoreName()).thenReturn(this.diskStoreName); - when(asyncEventQueue.isPersistent()).thenReturn(this.persistent); - when(asyncEventQueue.getId()).thenReturn(name); - when(asyncEventQueue.getMaximumQueueMemory()).thenReturn(this.maxQueueMemory); - when(asyncEventQueue.isParallel()).thenReturn(this.parallel); when(asyncEventQueue.isBatchConflationEnabled()).thenReturn(this.batchConflationEnabled); - when(asyncEventQueue.isDiskSynchronous()).thenReturn(this.diskSynchronous); + when(asyncEventQueue.getBatchSize()).thenReturn(this.batchSize); when(asyncEventQueue.getBatchTimeInterval()).thenReturn(this.batchTimeInterval); - when(asyncEventQueue.getOrderPolicy()).thenReturn(this.orderPolicy); + when(asyncEventQueue.getDiskStoreName()).thenReturn(this.diskStoreName); + when(asyncEventQueue.isDiskSynchronous()).thenReturn(this.diskSynchronous); when(asyncEventQueue.getDispatcherThreads()).thenReturn(this.dispatcherThreads); - when(asyncEventQueue.getGatewayEventSubstitutionFilter()).thenReturn(this.gatewayEventSubstitutionFilter); when(asyncEventQueue.getGatewayEventFilters()).thenReturn(Collections.unmodifiableList(gatewayEventFilters)); + when(asyncEventQueue.getGatewayEventSubstitutionFilter()).thenReturn(this.gatewayEventSubstitutionFilter); + when(asyncEventQueue.getId()).thenReturn(name); + when(asyncEventQueue.isIgnoreEvictionAndExpiration()).thenReturn(this.ignoreEvictionAndExpiration); + when(asyncEventQueue.getMaximumQueueMemory()).thenReturn(this.maxQueueMemory); + when(asyncEventQueue.getOrderPolicy()).thenReturn(this.orderPolicy); + when(asyncEventQueue.isParallel()).thenReturn(this.parallel); + when(asyncEventQueue.isPersistent()).thenReturn(this.persistent); return this.asyncEventQueue; } + public AsyncEventQueueFactory setBatchConflationEnabled(boolean batchConflationEnabled) { + this.batchConflationEnabled = batchConflationEnabled; + return this; + } + @Override public AsyncEventQueueFactory setBatchSize(int batchSize) { this.batchSize = batchSize; return this; } + public AsyncEventQueueFactory setBatchTimeInterval(int batchTimeInterval) { + this.batchTimeInterval = batchTimeInterval; + return this; + } + @Override public AsyncEventQueueFactory setDiskStoreName(String diskStoreName) { this.diskStoreName = diskStoreName; return this; } - @Override - public AsyncEventQueueFactory setMaximumQueueMemory(int maxQueueMemory) { - this.maxQueueMemory = maxQueueMemory; - return this; - } - - @Override - public AsyncEventQueueFactory setPersistent(boolean persistent) { - this.persistent = persistent; - return this; - } - - @Override - public AsyncEventQueueFactory setParallel(boolean parallel) { - this.parallel = parallel; - return this; - } - - //The following added in 7.0.1 - public AsyncEventQueueFactory setBatchConflationEnabled(boolean batchConflationEnabled) { - this.batchConflationEnabled = batchConflationEnabled; - return this; - } - - public AsyncEventQueueFactory setBatchTimeInterval(int batchTimeInterval) { - this.batchTimeInterval = batchTimeInterval; + public AsyncEventQueueFactory setDispatcherThreads(int dispatchThreads) { + this.dispatcherThreads = dispatchThreads; return this; } @@ -120,8 +108,13 @@ public class StubAsyncEventQueueFactory implements AsyncEventQueueFactory { return this; } - public AsyncEventQueueFactory setDispatcherThreads(int dispatchThreads) { - this.dispatcherThreads = dispatchThreads; + public AsyncEventQueueFactory setIgnoreEvictionAndExpiration(boolean ignoreEvictionAndExpiration) { + this.ignoreEvictionAndExpiration = ignoreEvictionAndExpiration; + return this; + } + + public AsyncEventQueueFactory setMaximumQueueMemory(int maxQueueMemory) { + this.maxQueueMemory = maxQueueMemory; return this; } @@ -130,22 +123,28 @@ public class StubAsyncEventQueueFactory implements AsyncEventQueueFactory { return this; } - @Override + public AsyncEventQueueFactory setParallel(boolean parallel) { + this.parallel = parallel; + return this; + } + + public AsyncEventQueueFactory setPersistent(boolean persistent) { + this.persistent = persistent; + return this; + } + public AsyncEventQueueFactory addGatewayEventFilter(final GatewayEventFilter gatewayEventFilter) { gatewayEventFilters.add(gatewayEventFilter); return this; } - @Override public AsyncEventQueueFactory removeGatewayEventFilter(final GatewayEventFilter gatewayEventFilter) { gatewayEventFilters.remove(gatewayEventFilter); return this; } - @Override public AsyncEventQueueFactory setGatewayEventSubstitutionListener(final GatewayEventSubstitutionFilter gatewayEventSubstitutionFilter) { this.gatewayEventSubstitutionFilter = gatewayEventSubstitutionFilter; return this; } - } diff --git a/src/test/resources/org/springframework/data/gemfire/config/AsyncEventQueueNamespaceTest-context.xml b/src/test/resources/org/springframework/data/gemfire/config/AsyncEventQueueNamespaceTest-context.xml new file mode 100644 index 00000000..5ff833fa --- /dev/null +++ b/src/test/resources/org/springframework/data/gemfire/config/AsyncEventQueueNamespaceTest-context.xml @@ -0,0 +1,45 @@ + + + + + + + AsyncEventQueueNamespaceTest + 0 + warning + + + + + + + + + + + + + + +