diff --git a/src/main/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessor.java b/src/main/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessor.java index 2bf207ec..b3164740 100644 --- a/src/main/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessor.java +++ b/src/main/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessor.java @@ -32,12 +32,16 @@ import org.springframework.data.gemfire.ScopeConverter; import org.springframework.data.gemfire.client.InterestResultPolicyConverter; import org.springframework.data.gemfire.server.SubscriptionEvictionPolicy; import org.springframework.data.gemfire.server.SubscriptionEvictionPolicyConverter; +import org.springframework.data.gemfire.wan.OrderPolicyConverter; +import org.springframework.data.gemfire.wan.StartupPolicyConverter; +import org.springframework.data.gemfire.wan.StartupPolicyType; import com.gemstone.gemfire.cache.EvictionAction; import com.gemstone.gemfire.cache.ExpirationAction; import com.gemstone.gemfire.cache.InterestPolicy; import com.gemstone.gemfire.cache.InterestResultPolicy; import com.gemstone.gemfire.cache.Scope; +import com.gemstone.gemfire.cache.util.Gateway; /** * The CustomEditorRegistrationBeanFactoryPostProcessor class is a Spring BeanFactoryPostProcessor used to register @@ -48,7 +52,7 @@ import com.gemstone.gemfire.cache.Scope; * @see org.springframework.beans.factory.config.BeanFactoryPostProcessor * @since 1.6.0 */ -@SuppressWarnings("unused") +@SuppressWarnings({ "deprecation", "unused" }) public class CustomEditorRegistrationBeanFactoryPostProcessor implements BeanFactoryPostProcessor { @Override @@ -60,7 +64,9 @@ public class CustomEditorRegistrationBeanFactoryPostProcessor implements BeanFac beanFactory.registerCustomEditor(IndexType.class, IndexTypeConverter.class); beanFactory.registerCustomEditor(InterestPolicy.class, InterestPolicyConverter.class); beanFactory.registerCustomEditor(InterestResultPolicy.class, InterestResultPolicyConverter.class); + beanFactory.registerCustomEditor(Gateway.OrderPolicy.class, OrderPolicyConverter.class); beanFactory.registerCustomEditor(Scope.class, ScopeConverter.class); + beanFactory.registerCustomEditor(StartupPolicyType.class, StartupPolicyConverter.class); beanFactory.registerCustomEditor(SubscriptionEvictionPolicy.class, SubscriptionEvictionPolicyConverter.class); } diff --git a/src/main/java/org/springframework/data/gemfire/config/GatewayHubParser.java b/src/main/java/org/springframework/data/gemfire/config/GatewayHubParser.java index 99e3dc60..7d361fc6 100644 --- a/src/main/java/org/springframework/data/gemfire/config/GatewayHubParser.java +++ b/src/main/java/org/springframework/data/gemfire/config/GatewayHubParser.java @@ -17,6 +17,7 @@ package org.springframework.data.gemfire.config; import java.util.List; +import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.ManagedList; import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser; @@ -24,89 +25,143 @@ import org.springframework.beans.factory.xml.ParserContext; import org.springframework.data.gemfire.wan.GatewayHubFactoryBean; import org.springframework.data.gemfire.wan.GatewayProxy; import org.springframework.util.CollectionUtils; -import org.springframework.util.StringUtils; import org.springframework.util.xml.DomUtils; import org.w3c.dom.Element; /** + * Parser for the <gateway-hub> SDG XML namespace element used to create GemFire GatewayHubs. + * * @author David Turanski - * + * @author John Blum + * @see org.springframework.beans.factory.config.BeanDefinition + * @see org.springframework.beans.factory.support.BeanDefinitionBuilder + * @see org.springframework.beans.factory.support.ManagedList + * @see org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser + * @see org.springframework.beans.factory.xml.ParserContext + * @see org.springframework.data.gemfire.wan.GatewayHubFactoryBean + * @see org.springframework.data.gemfire.wan.GatewayProxy */ class GatewayHubParser extends AbstractSimpleBeanDefinitionParser { + @Override protected Class getBeanClass(Element element) { return GatewayHubFactoryBean.class; } - @SuppressWarnings({ "rawtypes", "unchecked" }) + /* + + + + + + + + + + + */ @Override + @SuppressWarnings({ "rawtypes", "unchecked" }) protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { + builder.addConstructorArgReference(ParsingUtils.resolveCacheReference(element.getAttribute("cache-ref"))); builder.setLazyInit(false); - String cacheRef = element.getAttribute("cache-ref"); - // add cache reference (fallback to default if nothing is specified) - builder.addConstructorArgReference((StringUtils.hasText(cacheRef) ? cacheRef : "gemfireCache")); + ParsingUtils.setPropertyValue(element, builder, "bind-address"); ParsingUtils.setPropertyValue(element, builder, "manual-start"); + //ParsingUtils.setPropertyValue(element, builder, "max-connections"); + //ParsingUtils.setPropertyValue(element, builder, "max-time-between-pings", "maximumTimeBetweenPings"); + ParsingUtils.setPropertyValue(element, builder, "port"); ParsingUtils.setPropertyValue(element, builder, "socket-buffer-size"); ParsingUtils.setPropertyValue(element, builder, "startup-policy"); - ParsingUtils.setPropertyValue(element, builder, "port"); - + + parseGateways(element, parserContext, builder); + } + + private void parseGateways(Element element, ParserContext parserContext, BeanDefinitionBuilder gatewayHubBuilder) { List gatewayElements = DomUtils.getChildElementsByTagName(element, "gateway"); + if (!CollectionUtils.isEmpty(gatewayElements)) { - ManagedList gateways = new ManagedList(); + ManagedList gateways = new ManagedList(); + for (Element gatewayElement : gatewayElements) { BeanDefinitionBuilder gatewayBuilder = BeanDefinitionBuilder.genericBeanDefinition(GatewayProxy.class); + ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "gateway-id", "id"); ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "concurrency-level"); - ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "socket-read-timeout"); - ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "socket-buffer-size"); ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "order-policy"); - List endpointElements = DomUtils.getChildElementsByTagName(gatewayElement, "gateway-endpoint"); - if (!CollectionUtils.isEmpty(endpointElements)) { - ManagedList endpoints = new ManagedList(); - for (Element endpointElement : endpointElements) { - BeanDefinitionBuilder endpointBuilder = BeanDefinitionBuilder - .genericBeanDefinition(GatewayProxy.GatewayEndpoint.class); - ParsingUtils.setPropertyValue(endpointElement, endpointBuilder, "host"); - ParsingUtils.setPropertyValue(endpointElement, endpointBuilder, "port"); - ParsingUtils.setPropertyValue(endpointElement, endpointBuilder, "endpoint-id", "id"); - endpoints.add(endpointBuilder.getBeanDefinition()); - } - gatewayBuilder.addPropertyValue("endpoints", endpoints); - } + ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "socket-buffer-size"); + ParsingUtils.setPropertyValue(gatewayElement, gatewayBuilder, "socket-read-timeout"); - Element gatewayListenerElement = DomUtils.getChildElementByTagName(gatewayElement, "gateway-listener"); - if (gatewayListenerElement != null) { - Object obj = ParsingUtils.parseRefOrNestedBeanDeclaration(parserContext, gatewayListenerElement, - gatewayBuilder); - gatewayBuilder.addPropertyValue("listeners", obj); - } + parseGatewayEndpoints(gatewayElement, gatewayBuilder); + parseGatewayListeners(gatewayElement, parserContext, gatewayBuilder); + parseGatewayQueue(gatewayElement, gatewayBuilder); - Element gatewayQueueElement = DomUtils.getChildElementByTagName(gatewayElement, "gateway-queue"); - if (gatewayQueueElement != null) { - BeanDefinitionBuilder queueBuilder = BeanDefinitionBuilder - .genericBeanDefinition(GatewayProxy.GatewayQueue.class); - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "alert-threshold"); - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "batch-size"); - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "batch-time-interval"); - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "maximum-queue-memory"); - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "persistent"); - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "disk-store-ref"); - /* - * Make sure any disk store is created first - */ - if (gatewayQueueElement.hasAttribute("disk-store-ref")) { - gatewayBuilder.getBeanDefinition().setDependsOn( - new String[] {gatewayQueueElement.getAttribute("disk-store-ref")}); - } - ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "enable-batch-conflation"); - gatewayBuilder.addPropertyValue("queue", queueBuilder.getBeanDefinition()); - - - } gateways.add(gatewayBuilder.getBeanDefinition()); } - builder.addPropertyValue("gateways", gateways); + + gatewayHubBuilder.addPropertyValue("gateways", gateways); } } + + private void parseGatewayEndpoints(Element gatewayElement, BeanDefinitionBuilder gatewayBuilder) { + List endpointElements = DomUtils.getChildElementsByTagName(gatewayElement, "gateway-endpoint"); + + if (!CollectionUtils.isEmpty(endpointElements)) { + ManagedList endpoints = new ManagedList(); + + for (Element endpointElement : endpointElements) { + BeanDefinitionBuilder endpointBuilder = BeanDefinitionBuilder.genericBeanDefinition( + GatewayProxy.GatewayEndpoint.class); + + ParsingUtils.setPropertyValue(endpointElement, endpointBuilder, "endpoint-id", "id"); + ParsingUtils.setPropertyValue(endpointElement, endpointBuilder, "host"); + ParsingUtils.setPropertyValue(endpointElement, endpointBuilder, "port"); + + endpoints.add(endpointBuilder.getBeanDefinition()); + } + + gatewayBuilder.addPropertyValue("endpoints", endpoints); + } + } + + private void parseGatewayListeners(Element gatewayElement, ParserContext parserContext, + BeanDefinitionBuilder gatewayBuilder) { + + Element gatewayListenerElement = DomUtils.getChildElementByTagName(gatewayElement, "gateway-listener"); + + if (gatewayListenerElement != null) { + gatewayBuilder.addPropertyValue("listeners", ParsingUtils.parseRefOrNestedBeanDeclaration( + parserContext, gatewayListenerElement, gatewayBuilder)); + } + } + + private void parseGatewayQueue(Element gatewayElement, BeanDefinitionBuilder gatewayBuilder) { + Element gatewayQueueElement = DomUtils.getChildElementByTagName(gatewayElement, "gateway-queue"); + + if (gatewayQueueElement != null) { + BeanDefinitionBuilder queueBuilder = BeanDefinitionBuilder.genericBeanDefinition( + GatewayProxy.GatewayQueue.class); + + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "alert-threshold"); + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "batch-size"); + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "batch-time-interval"); + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "disk-store-ref"); + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "enable-batch-conflation"); + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "maximum-queue-memory"); + ParsingUtils.setPropertyValue(gatewayQueueElement, queueBuilder, "persistent"); + + /* Make sure any disk store is created first */ + if (gatewayQueueElement.hasAttribute("disk-store-ref")) { + gatewayBuilder.getBeanDefinition().setDependsOn(new String[] { + gatewayQueueElement.getAttribute("disk-store-ref") }); + } + + gatewayBuilder.addPropertyValue("queue", queueBuilder.getBeanDefinition()); + } + } + } diff --git a/src/main/java/org/springframework/data/gemfire/wan/AbstractWANComponentFactoryBean.java b/src/main/java/org/springframework/data/gemfire/wan/AbstractWANComponentFactoryBean.java index b701aebb..bb1d3b16 100644 --- a/src/main/java/org/springframework/data/gemfire/wan/AbstractWANComponentFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/wan/AbstractWANComponentFactoryBean.java @@ -34,9 +34,13 @@ import com.gemstone.gemfire.management.internal.cli.util.spring.StringUtils; * * @author David Turanski * @author John Blum + * @see org.springframework.beans.factory.BeanNameAware + * @see org.springframework.beans.factory.DisposableBean + * @see org.springframework.beans.factory.FactoryBean + * @see org.springframework.beans.factory.InitializingBean */ -public abstract class AbstractWANComponentFactoryBean implements BeanNameAware, FactoryBean, InitializingBean, - DisposableBean { +public abstract class AbstractWANComponentFactoryBean implements BeanNameAware, FactoryBean, + InitializingBean, DisposableBean { protected static final List VALID_ORDER_POLICIES = Arrays.asList("KEY", "PARTITION", "THREAD"); @@ -67,7 +71,7 @@ public abstract class AbstractWANComponentFactoryBean implements BeanNameAwar } public String getName() { - return (StringUtils.hasText(name) ? name: beanName); + return (StringUtils.hasText(name) ? name : beanName); } @Override @@ -83,8 +87,8 @@ public abstract class AbstractWANComponentFactoryBean implements BeanNameAwar @Override public final void afterPropertiesSet() throws Exception { - Assert.notNull(getName(), "Name must not be null."); Assert.notNull(cache, "Cache must not be null."); + Assert.notNull(getName(), "Name must not be null."); doInit(); } diff --git a/src/main/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBean.java b/src/main/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBean.java index 1ab35dd8..7a604e36 100644 --- a/src/main/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBean.java @@ -16,51 +16,57 @@ package org.springframework.data.gemfire.wan; import java.io.IOException; -import java.util.Arrays; +import java.util.Collections; import java.util.List; import org.springframework.data.gemfire.wan.GatewayProxy.GatewayQueue; import org.springframework.util.Assert; -import org.springframework.util.CollectionUtils; import com.gemstone.gemfire.cache.Cache; import com.gemstone.gemfire.cache.util.Gateway; -import com.gemstone.gemfire.cache.util.Gateway.OrderPolicy; import com.gemstone.gemfire.cache.util.GatewayEventListener; import com.gemstone.gemfire.cache.util.GatewayHub; import com.gemstone.gemfire.cache.util.GatewayQueueAttributes; +import com.gemstone.gemfire.management.internal.cli.util.spring.StringUtils; /** - * FactoryBean for creating a GemFire {@link GatewayHub} (deprecated in Gemfire - * 7) + * FactoryBean for creating a GemFire {@link GatewayHub} (deprecated in Gemfire 7). + * * @author David Turanski - * + * @author John Blum + * @see org.springframework.data.gemfire.wan.AbstractWANComponentFactoryBean + * @see com.gemstone.gemfire.cache.Cache + * @see com.gemstone.gemfire.cache.util.Gateway + * @see com.gemstone.gemfire.cache.util.GatewayHub + * @see com.gemstone.gemfire.cache.util.GatewayEventListener + * @see com.gemstone.gemfire.cache.util.GatewayQueueAttributes */ +@SuppressWarnings({"deprecation", "unused" }) public class GatewayHubFactoryBean extends AbstractWANComponentFactoryBean { - private static List validStartupPolicyValues = Arrays.asList("none", "primary", "secondary"); - - private static List validOrderPolicyValues = Arrays.asList("KEY,PARTITION,THREAD"); - - private GatewayHub gatewayHub; - - private Integer port; - - private String bindAddress; - - private Integer maximumTimeBetweenPings; - - private Integer socketBufferSize; - - private String startupPolicy; private Boolean manualStart; + private GatewayHub gatewayHub; + + private Integer maxConnections; + private Integer maximumTimeBetweenPings; + private Integer port; + private Integer socketBufferSize; + private List gateways; + private StartupPolicyType startupPolicy; + + private String bindAddress; + /** - * @param cache the Gemfire cache + * Constructs an instance of the GatewayHubFactoryBean class used to create GemFire WAN GatewayHubs initialized + * with the specified GemFire Cache. + * + * @param cache a reference to the Gemfire Cache. + * @see com.gemstone.gemfire.cache.Cache */ - public GatewayHubFactoryBean(Cache cache) { + public GatewayHubFactoryBean(final Cache cache) { super(cache); } @@ -71,134 +77,151 @@ public class GatewayHubFactoryBean extends AbstractWANComponentFactoryBean getObjectType() { - return GatewayHub.class; + return (gatewayHub != null ? gatewayHub.getClass() : GatewayHub.class); } @Override protected void doInit() { - String name = getName(); - gatewayHub = cache.addGatewayHub(name, port == null ? GatewayHub.DEFAULT_PORT : port); + gatewayHub = cache.addGatewayHub(getName(), getPort()); if (log.isDebugEnabled()) { - log.debug("added gateway hub " + name); + log.debug(String.format("Adding GemFire GatewayHub (%1$s)", getName())); } - Assert.notNull(cache.getGatewayHub(name)); + Assert.notNull(cache.getGatewayHub(getName())); - if (bindAddress != null) { - gatewayHub.setBindAddress(bindAddress); - } - if (manualStart != null) { - gatewayHub.setManualStart(manualStart); - } - if (socketBufferSize != null) { - gatewayHub.setSocketBufferSize(socketBufferSize); - } - if (startupPolicy != null) { - Assert.isTrue(validStartupPolicyValues.contains(startupPolicy), "The value of startup policy:'" - + startupPolicy + "' is invalid"); - gatewayHub.setStartupPolicy(startupPolicy); - } - if (maximumTimeBetweenPings != null) { - gatewayHub.setMaximumTimeBetweenPings(maximumTimeBetweenPings); - } - - if (!CollectionUtils.isEmpty(gateways)) { - configureGateways(); - } - - if (gatewayHub.getManualStart() == false) { - try { - gatewayHub.start(); - } catch (IOException e) { - throw new RuntimeException(e); + gatewayHub.setBindAddress(getBindAddress()); + gatewayHub.setManualStart(isManualStart(GatewayHub.DEFAULT_MANUAL_START)); + //gatewayHub.setMaxConnections(getMaxConnections()); + gatewayHub.setMaximumTimeBetweenPings(getMaximumTimeBetweenPings()); + gatewayHub.setSocketBufferSize(getSocketBufferSize()); + gatewayHub.setStartupPolicy(getStartupPolicy().getName()); + + configureGateways(); + autoStart(); + } + + private void configureGateways() { + for (GatewayProxy gatewayProxy : getGateways()) { + Gateway gateway = gatewayHub.addGateway(gatewayProxy.getId(), gatewayProxy.getConcurrencyLevel()); + + for (GatewayProxy.GatewayEndpoint endpoint : gatewayProxy.getEndpoints()) { + gateway.addEndpoint(endpoint.getId(), endpoint.getHost(), endpoint.getPort()); + } + + for (GatewayEventListener listener : gatewayProxy.getListeners()) { + gateway.addListener(listener); + } + + gateway.setOrderPolicy(gatewayProxy.getOrderPolicy()); + gateway.setSocketBufferSize(gatewayProxy.getSocketBufferSize()); + //gateway.setSocketReadTimeout(gatewayProxy.getSocketReadTimeout()); + + if (gatewayProxy.getQueue() != null) { + GatewayQueue queue = gatewayProxy.getQueue(); + GatewayQueueAttributes queueAttributes = gateway.getQueueAttributes(); + + queueAttributes.setAlertThreshold(queue.getAlertThreshold()); + queueAttributes.setBatchConflation(queue.getEnableBatchConflation()); + queueAttributes.setBatchSize(queue.getBatchSize()); + queueAttributes.setBatchTimeInterval(queue.getBatchTimeInterval()); + queueAttributes.setMaximumQueueMemory(queue.getMaximumQueueMemory()); + queueAttributes.setEnablePersistence(queue.getPersistent()); + + if (queue.getDiskStoreRef() != null) { + // TODO what about "overflow"? + boolean persistent = (queue.getPersistent() == null || queue.getPersistent()); + Assert.isTrue(persistent, "specifying a disk store requires persistent property to be true"); + queueAttributes.setDiskStoreName(queue.getDiskStoreRef()); + } } } } - public void setPort(Integer port) { - this.port = port; + private void autoStart() { + if (!gatewayHub.getManualStart()) { + try { + gatewayHub.start(); + } + catch (IOException e) { + throw new RuntimeException(e); + } + } } public void setBindAddress(String bindAddress) { this.bindAddress = bindAddress; } - public void setMaximumTimeBetweenPings(Integer maximumTimeBetweenPings) { - this.maximumTimeBetweenPings = maximumTimeBetweenPings; + /* (non-Javadoc) */ + String getBindAddress() { + return (StringUtils.hasText(bindAddress) ? bindAddress : GatewayHub.DEFAULT_BIND_ADDRESS); } - public void setSocketBufferSize(Integer socketBufferSize) { - this.socketBufferSize = socketBufferSize; + public void setGateways(List gateways) { + this.gateways = gateways; } - public void setStartupPolicy(String startupPolicy) { - this.startupPolicy = startupPolicy; + /* (non-Javadoc) */ + List getGateways() { + return (gateways != null ? gateways : Collections.emptyList()); } public void setManualStart(Boolean manualStart) { this.manualStart = manualStart; } - public void setGateways(List gateways) { - this.gateways = gateways; + /* (non-Javadoc) */ + boolean isManualStart(final boolean defaultManualStart) { + return (manualStart != null ? manualStart : defaultManualStart); } - - private void configureGateways() { - for (GatewayProxy gateway : gateways) { - Gateway gw = gatewayHub.addGateway( - gateway.getId(), - gateway.getConcurrencyLevel() == null ? Gateway.DEFAULT_CONCURRENCY_LEVEL : gateway - .getConcurrencyLevel()); - if (!CollectionUtils.isEmpty(gateway.getEndpoints())) { - for (GatewayProxy.GatewayEndpoint endpoint : gateway.getEndpoints()) { - gw.addEndpoint(endpoint.getId(), endpoint.getHost(), endpoint.getPort()); - } - } - if (!CollectionUtils.isEmpty(gateway.getListeners())) { - for (GatewayEventListener listener : gateway.getListeners()) { - gw.addListener(listener); - } - } - if (gateway.getOrderPolicy() != null) { - Assert.isTrue(validOrderPolicyValues.contains(gateway.getOrderPolicy()), - "The value of order policy:'" + gateway.getOrderPolicy() + "' is invalid"); - gw.setOrderPolicy(OrderPolicy.valueOf(gateway.getOrderPolicy())); - } - if (gateway.getSocketBufferSize() != null) { - gw.setSocketBufferSize(gateway.getSocketBufferSize()); - } - if (gateway.getQueue() != null) { - GatewayQueue queue = gateway.getQueue(); - GatewayQueueAttributes queueAttributes = gw.getQueueAttributes(); - if (queue.getAlertThreshold() != null) { - queueAttributes.setAlertThreshold(queue.getAlertThreshold()); - } - if (queue.getEnableBatchConflation() != null) { - queueAttributes.setBatchConflation(queue.getEnableBatchConflation()); - } - if (queue.getBatchSize() != null) { - queueAttributes.setBatchSize(queue.getBatchSize()); - } - if (queue.getBatchTimeInterval() != null) { - queueAttributes.setBatchTimeInterval(queue.getBatchTimeInterval()); - } - - if (queue.getDiskStoreRef() != null) { - boolean persistent = (queue.getPersistent() == null) ? Boolean.TRUE : queue.getPersistent(); - Assert.isTrue(persistent, "specifying a disk store requires persistent property to be true"); - queueAttributes.setDiskStoreName(queue.getDiskStoreRef()); - } - - if (queue.getPersistent() != null) { - queueAttributes.setEnablePersistence(queue.getPersistent()); - } - - if (queue.getMaximumQueueMemory() != null) { - queueAttributes.setMaximumQueueMemory(queue.getMaximumQueueMemory()); - } - } - } + /* + public void setMaxConnections(Integer maxConnections) { + this.maxConnections = maxConnections; } + + // (non-Javadoc) + Integer getMaxConnections() { + return (maxConnections != null ? maxConnections : GatewayHub.DEFAULT_MAX_CONNECTIONS); + } + */ + + public void setMaximumTimeBetweenPings(Integer maximumTimeBetweenPings) { + this.maximumTimeBetweenPings = maximumTimeBetweenPings; + } + + // (non-Javadoc) + Integer getMaximumTimeBetweenPings() { + return (maximumTimeBetweenPings != null ? maximumTimeBetweenPings + : GatewayHub.DEFAULT_MAXIMUM_TIME_BETWEEN_PINGS); + } + + public void setPort(Integer port) { + this.port = port; + } + + /* (non-Javadoc) */ + Integer getPort() { + return (port != null ? port : GatewayHub.DEFAULT_PORT); + } + + public void setSocketBufferSize(Integer socketBufferSize) { + this.socketBufferSize = socketBufferSize; + } + + /* (non-Javadoc) */ + Integer getSocketBufferSize() { + return (socketBufferSize != null ? socketBufferSize : GatewayHub.DEFAULT_SOCKET_BUFFER_SIZE); + } + + public void setStartupPolicy(StartupPolicyType startupPolicy) { + this.startupPolicy = startupPolicy; + } + + /* (non-Javadoc) */ + StartupPolicyType getStartupPolicy() { + return (startupPolicy != null ? startupPolicy : StartupPolicyType.DEFAULT); + } + } diff --git a/src/main/java/org/springframework/data/gemfire/wan/GatewayProxy.java b/src/main/java/org/springframework/data/gemfire/wan/GatewayProxy.java index 62e81af2..dd948db0 100644 --- a/src/main/java/org/springframework/data/gemfire/wan/GatewayProxy.java +++ b/src/main/java/org/springframework/data/gemfire/wan/GatewayProxy.java @@ -15,42 +15,76 @@ */ package org.springframework.data.gemfire.wan; +import java.util.Collections; import java.util.List; import com.gemstone.gemfire.cache.util.Gateway; import com.gemstone.gemfire.cache.util.GatewayEventListener; +import com.gemstone.gemfire.cache.util.GatewayQueueAttributes; /** - * This class used to allow decoupling of 'gateway' parsing from 'gateway-hub' - * parsing + * The GatewayProxy class used to allow decoupling of 'gateway' parsing from 'gateway-hub' parsing. * * @author David Turanski - * + * @author John Blum + * @since com.gemstone.gemfire.cache.util.Gateway */ +@SuppressWarnings({ "deprecation", "unused" }) public class GatewayProxy { - private List endpoints; + private Gateway.OrderPolicy orderPolicy; + + private GatewayQueue queue; private Integer concurrencyLevel = Gateway.DEFAULT_CONCURRENCY_LEVEL; + private Integer socketBufferSize = Gateway.DEFAULT_SOCKET_BUFFER_SIZE; + //private Integer socketReadTimeout = Gateway.DEFAULT_SOCKET_READ_TIMEOUT; + + private List endpoints; + private List listeners; private String id; - private List listeners; + public void setConcurrencyLevel(Integer concurrencyLevel) { + this.concurrencyLevel = concurrencyLevel; + } - private String orderPolicy; - - private int socketBufferSize = Gateway.DEFAULT_SOCKET_BUFFER_SIZE; - - private GatewayQueue queue; + public Integer getConcurrencyLevel() { + return (concurrencyLevel != null ? concurrencyLevel : Gateway.DEFAULT_CONCURRENCY_LEVEL); + } public void setEndpoints(List endpoints) { this.endpoints = endpoints; } + public List getEndpoints() { + return (endpoints != null ? endpoints : Collections.emptyList()); + } + + public void setId(String id) { + this.id = id; + } + + public String getId() { + return this.id; + } + public void setListeners(List listeners) { this.listeners = listeners; } + public List getListeners() { + return (listeners != null ? listeners : Collections.emptyList()); + } + + public void setOrderPolicy(Gateway.OrderPolicy orderPolicy) { + this.orderPolicy = orderPolicy; + } + + public Gateway.OrderPolicy getOrderPolicy() { + return this.orderPolicy; + } + public void setQueue(GatewayQueue queue) { this.queue = queue; } @@ -59,50 +93,31 @@ public class GatewayProxy { return this.queue; } - public Integer getConcurrencyLevel() { - return this.concurrencyLevel; - } - - public List getEndpoints() { - return endpoints; - } - - public String getId() { - return this.id; - } - - public List getListeners() { - return this.listeners; - } - - public String getOrderPolicy() { - return this.orderPolicy; + public void setSocketBufferSize(int socketBufferSize) { + this.socketBufferSize = socketBufferSize; } public Integer getSocketBufferSize() { - return this.socketBufferSize; - } - - public void setId(String id) { - this.id = id; + return (socketBufferSize != null ? socketBufferSize : Gateway.DEFAULT_SOCKET_BUFFER_SIZE); } - public void setOrderPolicy(String orderPolicy) { - this.orderPolicy = orderPolicy; + /* + public void setSocketReadTimeout(final Integer socketReadTimeout) { + this.socketReadTimeout = socketReadTimeout; } - public void setSocketBufferSize(int socketBufferSize) { - this.socketBufferSize = socketBufferSize; - + public Integer getSocketReadTimeout() { + return (socketReadTimeout != null ? socketReadTimeout : Gateway.DEFAULT_SOCKET_READ_TIMEOUT); } + */ public static class GatewayEndpoint { - private String host; - - private String id; private int port; + private String host; + private String id; + public String getHost() { return host; } @@ -129,75 +144,74 @@ public class GatewayProxy { } public static class GatewayQueue { - private Integer alertThreshold; private Boolean enableBatchConflation; - - private Integer batchTimeInterval; - - private Integer batchSize; - private Boolean persistent; - private String diskStoreRef; - + private Integer alertThreshold; + private Integer batchSize; + private Integer batchTimeInterval; private Integer maximumQueueMemory; - public Integer getAlertThreshold() { - return alertThreshold; - } + private String diskStoreRef; public void setAlertThreshold(Integer alertThreshold) { this.alertThreshold = alertThreshold; } - public Boolean getEnableBatchConflation() { - return enableBatchConflation; - } - - public void setEnableBatchConflation(Boolean enableBatchConflation) { - this.enableBatchConflation = enableBatchConflation; - } - - public Integer getBatchTimeInterval() { - return batchTimeInterval; - } - - public void setBatchTimeInterval(Integer batchTimeInterval) { - this.batchTimeInterval = batchTimeInterval; - } - - public Integer getBatchSize() { - return batchSize; + public Integer getAlertThreshold() { + return (alertThreshold != null ? alertThreshold : GatewayQueueAttributes.DEFAULT_ALERT_THRESHOLD); } public void setBatchSize(Integer batchSize) { this.batchSize = batchSize; } - public Boolean getPersistent() { - return persistent; + public Integer getBatchSize() { + return (batchSize != null ? batchSize : GatewayQueueAttributes.DEFAULT_BATCH_SIZE); } - public void setPersistent(Boolean persistent) { - this.persistent = persistent; + public void setBatchTimeInterval(Integer batchTimeInterval) { + this.batchTimeInterval = batchTimeInterval; } - public String getDiskStoreRef() { - return diskStoreRef; + public Integer getBatchTimeInterval() { + return (batchTimeInterval != null ? batchTimeInterval : GatewayQueueAttributes.DEFAULT_BATCH_TIME_INTERVAL); } public void setDiskStoreRef(String diskStoreRef) { this.diskStoreRef = diskStoreRef; } - public Integer getMaximumQueueMemory() { - return maximumQueueMemory; + public String getDiskStoreRef() { + return diskStoreRef; + } + + public void setEnableBatchConflation(Boolean enableBatchConflation) { + this.enableBatchConflation = enableBatchConflation; + } + + public Boolean getEnableBatchConflation() { + return (enableBatchConflation != null ? enableBatchConflation + : GatewayQueueAttributes.DEFAULT_BATCH_CONFLATION); } public void setMaximumQueueMemory(Integer maximumQueueMemory) { this.maximumQueueMemory = maximumQueueMemory; } + public Integer getMaximumQueueMemory() { + return (maximumQueueMemory != null ? maximumQueueMemory + : GatewayQueueAttributes.DEFAULT_MAXIMUM_QUEUE_MEMORY); + } + + public void setPersistent(Boolean persistent) { + this.persistent = persistent; + } + + public Boolean getPersistent() { + return (persistent != null ? persistent : GatewayQueueAttributes.DEFAULT_ENABLE_PERSISTENCE); + } } + } diff --git a/src/main/java/org/springframework/data/gemfire/wan/OrderPolicyConverter.java b/src/main/java/org/springframework/data/gemfire/wan/OrderPolicyConverter.java new file mode 100644 index 00000000..f6ae8754 --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/wan/OrderPolicyConverter.java @@ -0,0 +1,52 @@ +/* + * 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.wan; + +import org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport; + +import com.gemstone.gemfire.cache.util.Gateway; + +/** + * The OrderPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor used to convert a String value + * into an appropriate GemFire Gateway.OrderPolicy enum. + * + * @author John Blum + * @see org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport + * @see org.springframework.data.gemfire.wan.OrderPolicyType + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + * @since 1.7.0 + */ +@SuppressWarnings({ "deprecation", "unused" }) +public class OrderPolicyConverter extends AbstractPropertyEditorConverterSupport { + + /** + * Converts the given String into a GemFire Gateway.OrderPolicy enum. + * + * @param source the String to convert. + * @return a GemFire Gateway.OrderPolicy enum for the given String. + * @throws java.lang.IllegalArgumentException if the String is not a valid GemFire Gateway.OrderPolicy. + * @see org.springframework.data.gemfire.wan.OrderPolicyType#getOrderPolicy() + * @see org.springframework.data.gemfire.wan.OrderPolicyType#valueOfIgnoreCase(String) + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + */ + @Override + public Gateway.OrderPolicy convert(final String source) { + return assertConverted(source, OrderPolicyType.getOrderPolicy(OrderPolicyType.valueOfIgnoreCase(source)), + Gateway.OrderPolicy.class); + } + +} diff --git a/src/main/java/org/springframework/data/gemfire/wan/OrderPolicyType.java b/src/main/java/org/springframework/data/gemfire/wan/OrderPolicyType.java new file mode 100644 index 00000000..712d3f34 --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/wan/OrderPolicyType.java @@ -0,0 +1,108 @@ +/* + * 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.wan; + +import com.gemstone.gemfire.cache.util.Gateway; + +/** + * The OrderPolicyType class is an enumeration of GemFire Gateway Order Policies. + * + * @author John Blum + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + * @since 1.7.0 + */ +@SuppressWarnings({ "deprecation", "unused" }) +public enum OrderPolicyType { + KEY(Gateway.OrderPolicy.KEY), + PARTITION(Gateway.OrderPolicy.PARTITION), + THREAD(Gateway.OrderPolicy.THREAD); + + private final Gateway.OrderPolicy orderPolicy; + + /** + * Constructs an instance of the OrderPolicyType enum initialized with the matching GemFire Gateway.OrderPolicy + * enumerated value. + * + * @param orderPolicy the matching GemFire Gateway.OrderPolicy enumerated value. + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + */ + OrderPolicyType(final Gateway.OrderPolicy orderPolicy) { + this.orderPolicy = orderPolicy; + } + + /** + * Null-safe operation to extract the matching GemFire Gateway.OrderPolicy enumerated value from + * the specified OrderPolicyType. + * + * @param orderPolicyType the OrderPolicyType enum from which to extract the GemFire-based + * Gateway.OrderPolicy enumerated value. + * @return the GemFire Gateway.OrderPolicy enumerated value for the given OrderPolicyType. + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + * @see #getOrderPolicy() + */ + public static Gateway.OrderPolicy getOrderPolicy(final OrderPolicyType orderPolicyType) { + return (orderPolicyType != null ? orderPolicyType.getOrderPolicy() : null); + } + + /** + * Returns the matching OrderPolicyType given a GemFire Gateway.OrderPolicy enumerated value. + * + * @param orderPolicy the GemFire Gateway.OrderPolicy enumerated value used to match + * the desired OrderPolicyType. + * @return a OrderPolicyType matching the given GemFire Gateway.OrderPolicy enumerated value. + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + * @see #getOrderPolicy() + */ + public static OrderPolicyType valueOf(final Gateway.OrderPolicy orderPolicy) { + for (OrderPolicyType orderPolicyType : values()) { + if (orderPolicyType.getOrderPolicy().equals(orderPolicy)) { + return orderPolicyType; + } + } + + return null; + } + + /** + * Returns a matching OrderPolicyType given the case-insensitive, name of the GemFire Gateway OrderPolicy. + * + * @param name a String name used to match the desired OrderPolicyType. + * @return a OrderPolicyType enumerated value for the given name. + * @see java.lang.String#equalsIgnoreCase(String) + * @see #name() + */ + public static OrderPolicyType valueOfIgnoreCase(final String name) { + for (OrderPolicyType orderPolicy : values()) { + if (orderPolicy.name().equalsIgnoreCase(name)) { + return orderPolicy; + } + } + + return null; + } + + /** + * Gets the GemFire Gateway.OrderPolicy corresponding to this OrderPolicyType enum. + * + * @return a GemFire Gateway.OrderPolicy for this enum. + * @see com.gemstone.gemfire.cache.util.Gateway.OrderPolicy + */ + public Gateway.OrderPolicy getOrderPolicy() { + return orderPolicy; + } + +} diff --git a/src/main/java/org/springframework/data/gemfire/wan/StartupPolicyConverter.java b/src/main/java/org/springframework/data/gemfire/wan/StartupPolicyConverter.java new file mode 100644 index 00000000..566160e2 --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/wan/StartupPolicyConverter.java @@ -0,0 +1,48 @@ +/* + * 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.wan; + +import org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport; + +/** + * The StartupPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor responsible for + * converting String values into appropriate StartupPolicyType enumerated values. + * + * @author John Blum + * @see org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport + * @see org.springframework.data.gemfire.wan.StartupPolicyType + * @since 1.7.0 + */ +@SuppressWarnings("unused") +public class StartupPolicyConverter extends AbstractPropertyEditorConverterSupport { + + /** + * Converts the given String value into an appropriate StartupPolicyType enumerated value. + * + * @param source the String to convert. + * @return a StartupPolicyType enumerated value for the given String. + * @throws java.lang.IllegalArgumentException if the String is not a valid GatewayHub Startup Policy. + * @see StartupPolicyType#valueOfIgnoreCase(String) + * @see #assertConverted(String, Object, Class) + */ + @Override + public StartupPolicyType convert(final String source) { + return assertConverted(source, StartupPolicyType.valueOfIgnoreCase(source), + StartupPolicyType.class); + } + +} diff --git a/src/main/java/org/springframework/data/gemfire/wan/StartupPolicyType.java b/src/main/java/org/springframework/data/gemfire/wan/StartupPolicyType.java new file mode 100644 index 00000000..62ffee22 --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/wan/StartupPolicyType.java @@ -0,0 +1,78 @@ +/* + * 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.wan; + +import com.gemstone.gemfire.cache.util.GatewayHub; + +/** + * The StartupPolicyType class is an enumeration of GemFire GatewayHub Startup Policies. + * + * @author John Blum + * @see com.gemstone.gemfire.cache.util.GatewayHub + * @since 1.7.0 + */ +@SuppressWarnings({"deprecation", "unused" }) +public enum StartupPolicyType { + NONE(GatewayHub.STARTUP_POLICY_NONE), + PRIMARY(GatewayHub.STARTUP_POLICY_PRIMARY), + SECONDARY(GatewayHub.STARTUP_POLICY_SECONDARY); + + public static final StartupPolicyType DEFAULT = StartupPolicyType.valueOfIgnoreCase( + GatewayHub.DEFAULT_STARTUP_POLICY); + + private final String name; + + /** + * Constructs an instance of the StartupPolicyType enum initialized with the given GemFire "named", + * GatewayHub Startup Policy. + * + * @param name a String specifying the name used by GemFire for the GatewayHub Startup Policy. + */ + StartupPolicyType(final String name) { + this.name = name; + } + + /** + * Returns a StartupPolicyType enumerated value matching the given official, case-insensitve "name" + * for the GatewayHub Startup Policy used by GemFire. + * + * @param name a String specifying the name used by GemFire for the GatewayHub Startup Policy. + * @return a StartupPolicyType enumerated value matching the given name used by GemFire to specify + * the GatewayHub Startup Policy. + * @see java.lang.String#equalsIgnoreCase(String) + * @see #getName() + */ + public static StartupPolicyType valueOfIgnoreCase(final String name) { + for (StartupPolicyType startupPolicyType : values()) { + if (startupPolicyType.getName().equalsIgnoreCase(name)) { + return startupPolicyType; + } + } + + return null; + } + + /** + * Gets the official name used by GemFire to specify the GatewayHub Startup Policy. + * + * @return the official GatewayHub Startup Policy name used by GemFire. + */ + public String getName() { + return name; + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessorTest.java b/src/test/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessorTest.java index e6c90ed0..a6d6bc7d 100644 --- a/src/test/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessorTest.java +++ b/src/test/java/org/springframework/data/gemfire/config/CustomEditorRegistrationBeanFactoryPostProcessorTest.java @@ -36,12 +36,16 @@ import org.springframework.data.gemfire.ScopeConverter; import org.springframework.data.gemfire.client.InterestResultPolicyConverter; import org.springframework.data.gemfire.server.SubscriptionEvictionPolicy; import org.springframework.data.gemfire.server.SubscriptionEvictionPolicyConverter; +import org.springframework.data.gemfire.wan.OrderPolicyConverter; +import org.springframework.data.gemfire.wan.StartupPolicyConverter; +import org.springframework.data.gemfire.wan.StartupPolicyType; import com.gemstone.gemfire.cache.EvictionAction; import com.gemstone.gemfire.cache.ExpirationAction; import com.gemstone.gemfire.cache.InterestPolicy; import com.gemstone.gemfire.cache.InterestResultPolicy; import com.gemstone.gemfire.cache.Scope; +import com.gemstone.gemfire.cache.util.Gateway; /** * The CustomEditorRegistrationBeanFactoryPostProcessorTest class... @@ -51,6 +55,7 @@ import com.gemstone.gemfire.cache.Scope; * @see org.springframework.data.gemfire.config.CustomEditorRegistrationBeanFactoryPostProcessor * @since 1.6.0 */ +@SuppressWarnings("deprecation") public class CustomEditorRegistrationBeanFactoryPostProcessorTest { @Test @@ -74,6 +79,10 @@ public class CustomEditorRegistrationBeanFactoryPostProcessorTest { verify(mockBeanFactory, times(1)).registerCustomEditor(eq(InterestResultPolicy.class), eq(InterestResultPolicyConverter.class)); verify(mockBeanFactory, times(1)).registerCustomEditor(eq(Scope.class), eq(ScopeConverter.class)); + verify(mockBeanFactory, times(1)).registerCustomEditor(eq(Gateway.OrderPolicy.class), + eq(OrderPolicyConverter.class)); + verify(mockBeanFactory, times(1)).registerCustomEditor(eq(StartupPolicyType.class), + eq(StartupPolicyConverter.class)); verify(mockBeanFactory, times(1)).registerCustomEditor(eq(SubscriptionEvictionPolicy.class), eq(SubscriptionEvictionPolicyConverter.class)); } diff --git a/src/test/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBeanTest.java b/src/test/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBeanTest.java new file mode 100644 index 00000000..f5404c3f --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/wan/GatewayHubFactoryBeanTest.java @@ -0,0 +1,327 @@ +/* + * 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.wan; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.eq; +import static org.mockito.Matchers.same; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; + +import com.gemstone.gemfire.cache.Cache; +import com.gemstone.gemfire.cache.util.Gateway; +import com.gemstone.gemfire.cache.util.GatewayEventListener; +import com.gemstone.gemfire.cache.util.GatewayHub; +import com.gemstone.gemfire.cache.util.GatewayQueueAttributes; + +/** + * The GatewayHubFactoryBeanTest class is a test suite of test cases testing the contract and functionality + * of the GatewayHubFactoryBean. + * + * @author John Blum + * @see org.junit.Test + * @see org.mockito.Mockito + * @see org.springframework.data.gemfire.wan.GatewayHubFactoryBean + * @since 1.7.0 + */ +@SuppressWarnings("deprecation") +public class GatewayHubFactoryBeanTest { + + private Cache mockCache; + + private GatewayHubFactoryBean factoryBean; + + @Before + public void setup() { + mockCache = mock(Cache.class, "GemFire Cache"); + factoryBean = new GatewayHubFactoryBean(mockCache); + } + + @Test + public void testGetObjectAndObjectType() throws Exception { + assertNull(factoryBean.getObject()); + assertEquals(GatewayHub.class, factoryBean.getObjectType()); + } + + @Test + public void testSetAndGetBindAddress() { + assertEquals(GatewayHub.DEFAULT_BIND_ADDRESS, factoryBean.getBindAddress()); + factoryBean.setBindAddress("10.127.255.1"); + assertEquals("10.127.255.1", factoryBean.getBindAddress()); + factoryBean.setBindAddress(null); + assertEquals(GatewayHub.DEFAULT_BIND_ADDRESS, factoryBean.getBindAddress()); + } + + @Test + public void testGetGateways() { + List gateways = factoryBean.getGateways(); + + assertNotNull(gateways); + assertTrue(gateways.isEmpty()); + } + + @Test + public void testSetAndIsManualStart() { + assertEquals(GatewayHub.DEFAULT_MANUAL_START, factoryBean.isManualStart(GatewayHub.DEFAULT_MANUAL_START)); + factoryBean.setManualStart(true); + assertTrue(factoryBean.isManualStart(GatewayHub.DEFAULT_MANUAL_START)); + factoryBean.setManualStart(false); + assertFalse(factoryBean.isManualStart(true)); + factoryBean.setManualStart(null); + assertEquals(GatewayHub.DEFAULT_MANUAL_START, factoryBean.isManualStart(GatewayHub.DEFAULT_MANUAL_START)); + } + + /* + @Test + public void testSetAndGetMaxConnections() { + assertEquals(GatewayHub.DEFAULT_MAX_CONNECTIONS, factoryBean.getMaxConnections().intValue()); + factoryBean.setMaxConnections(8192); + assertEquals(8192, factoryBean.getMaxConnections().intValue()); + factoryBean.setMaxConnections(null); + assertEquals(GatewayHub.DEFAULT_MAX_CONNECTIONS, factoryBean.getMaxConnections().intValue()); + } + */ + + @Test + public void testSetAndGetMaximumTimeBetweenPings() { + assertEquals(GatewayHub.DEFAULT_MAXIMUM_TIME_BETWEEN_PINGS, factoryBean.getMaximumTimeBetweenPings().intValue()); + factoryBean.setMaximumTimeBetweenPings(15000); + assertEquals(15000, factoryBean.getMaximumTimeBetweenPings().intValue()); + factoryBean.setMaximumTimeBetweenPings(null); + assertEquals(GatewayHub.DEFAULT_MAXIMUM_TIME_BETWEEN_PINGS, factoryBean.getMaximumTimeBetweenPings().intValue()); + } + + @Test + public void testSetAndGetPort() { + assertEquals(GatewayHub.DEFAULT_PORT, factoryBean.getPort().intValue()); + factoryBean.setPort(15221); + assertEquals(15221, factoryBean.getPort().intValue()); + factoryBean.setPort(null); + assertEquals(GatewayHub.DEFAULT_PORT, factoryBean.getPort().intValue()); + } + + @Test + public void testSetAndGetSocketBufferSize() { + assertEquals(GatewayHub.DEFAULT_SOCKET_BUFFER_SIZE, factoryBean.getSocketBufferSize().intValue()); + factoryBean.setSocketBufferSize(16384); + assertEquals(16384, factoryBean.getSocketBufferSize().intValue()); + factoryBean.setSocketBufferSize(null); + assertEquals(GatewayHub.DEFAULT_SOCKET_BUFFER_SIZE, factoryBean.getSocketBufferSize().intValue()); + } + + @Test + public void testSetAndGetStartUpPolicy() { + assertEquals(StartupPolicyType.DEFAULT, factoryBean.getStartupPolicy()); + factoryBean.setStartupPolicy(StartupPolicyType.PRIMARY); + assertEquals(StartupPolicyType.PRIMARY, factoryBean.getStartupPolicy()); + factoryBean.setStartupPolicy(null); + assertEquals(StartupPolicyType.DEFAULT, factoryBean.getStartupPolicy()); + factoryBean.setStartupPolicy(StartupPolicyType.SECONDARY); + assertEquals(StartupPolicyType.SECONDARY, factoryBean.getStartupPolicy()); + } + + @Test(expected = IllegalArgumentException.class) + public void testAfterPropertiesSetWitNullCache() throws Exception { + try { + new GatewayHubFactoryBean(null).afterPropertiesSet(); + } + catch (IllegalArgumentException expected) { + assertEquals("Cache must not be null.", expected.getMessage()); + throw expected; + } + } + + @Test(expected = IllegalArgumentException.class) + public void testAfterPropertiesSetWithNullName() throws Exception { + try { + factoryBean.afterPropertiesSet(); + } + catch (IllegalArgumentException expected) { + assertEquals("Name must not be null.", expected.getMessage()); + throw expected; + } + } + + @Test + public void testDoInit() throws Exception { + String gatewayHubName = "testDoInit"; + + GatewayProxy.GatewayEndpoint gatewayEndpointOne = new GatewayProxy.GatewayEndpoint(); + + gatewayEndpointOne.setHost("localhost"); + gatewayEndpointOne.setId("123"); + gatewayEndpointOne.setPort(2121); + + GatewayProxy.GatewayEndpoint gatewayEndpointTwo = new GatewayProxy.GatewayEndpoint(); + + gatewayEndpointOne.setHost("localhost"); + gatewayEndpointOne.setId("456"); + gatewayEndpointOne.setPort(4242); + + GatewayEventListener mockGatewayListener = mock(GatewayEventListener.class, + "testDoInit.MockGatewayEventListener"); + + GatewayProxy.GatewayQueue gatewayQueue = new GatewayProxy.GatewayQueue(); + + gatewayQueue.setAlertThreshold(20); + gatewayQueue.setBatchSize(100); + gatewayQueue.setBatchTimeInterval(60000); + gatewayQueue.setDiskStoreRef("diskX"); + gatewayQueue.setEnableBatchConflation(true); + gatewayQueue.setMaximumQueueMemory(1024); + gatewayQueue.setPersistent(true); + + GatewayProxy gatewayProxy = new GatewayProxy(); + + gatewayProxy.setId("gatewayProxyId"); + gatewayProxy.setConcurrencyLevel(4); + gatewayProxy.setEndpoints(Arrays.asList(gatewayEndpointOne, gatewayEndpointTwo)); + gatewayProxy.setListeners(Arrays.asList(mockGatewayListener)); + gatewayProxy.setOrderPolicy(Gateway.OrderPolicy.THREAD); + gatewayProxy.setQueue(gatewayQueue); + gatewayProxy.setSocketBufferSize(16384); + //gatewayProxy.setSocketReadTimeout(300); + + GatewayHub mockGatewayHub = mock(GatewayHub.class, "testDoInit.MockGatewayHub"); + + Gateway mockGateway = mock(Gateway.class, "testDoInit.MockGateway"); + + GatewayQueueAttributes mockGatewayQueueAttributes = mock(GatewayQueueAttributes.class, + "testDoInit.MockGatewayQueueAttributes"); + + when(mockCache.addGatewayHub(eq(gatewayHubName), eq(8484))).thenReturn(mockGatewayHub); + when(mockCache.getGatewayHub(eq(gatewayHubName))).thenReturn(mockGatewayHub); + when(mockGatewayHub.addGateway(eq(gatewayProxy.getId()), eq(gatewayProxy.getConcurrencyLevel().intValue()))) + .thenReturn(mockGateway); + when(mockGatewayHub.getManualStart()).thenReturn(false); + when(mockGateway.getQueueAttributes()).thenReturn(mockGatewayQueueAttributes); + + factoryBean.setBindAddress("10.124.210.42"); + factoryBean.setGateways(Arrays.asList(gatewayProxy)); + factoryBean.setManualStart(false); + //factoryBean.setMaxConnections(50); + factoryBean.setMaximumTimeBetweenPings(20480); + factoryBean.setName(gatewayHubName); + factoryBean.setPort(8484); + factoryBean.setSocketBufferSize(4096); + factoryBean.setStartupPolicy(StartupPolicyType.PRIMARY); + factoryBean.afterPropertiesSet(); + + verify(mockGatewayHub, times(1)).setBindAddress(eq("10.124.210.42")); + verify(mockGatewayHub, times(1)).setManualStart(eq(false)); + //verify(mockGatewayHub, times(1)).setMaxConnections(eq(50)); + verify(mockGatewayHub, times(1)).setMaximumTimeBetweenPings(eq(20480)); + verify(mockGatewayHub, times(1)).setSocketBufferSize(eq(4096)); + verify(mockGatewayHub, times(1)).setStartupPolicy(eq(StartupPolicyType.PRIMARY.getName())); + verify(mockGatewayHub, times(1)).addGateway(eq(gatewayProxy.getId()), eq(gatewayProxy.getConcurrencyLevel())); + verify(mockGatewayHub, times(1)).start(); + verify(mockGateway, times(1)).addEndpoint(eq(gatewayEndpointOne.getId()), eq(gatewayEndpointOne.getHost()), + eq(gatewayEndpointOne.getPort())); + verify(mockGateway, times(1)).addEndpoint(eq(gatewayEndpointTwo.getId()), eq(gatewayEndpointTwo.getHost()), + eq(gatewayEndpointTwo.getPort())); + verify(mockGateway, times(1)).addListener(same(mockGatewayListener)); + verify(mockGateway, times(1)).setOrderPolicy(eq(gatewayProxy.getOrderPolicy())); + verify(mockGateway, times(1)).setSocketBufferSize(eq(gatewayProxy.getSocketBufferSize())); + //verify(mockGateway, times(1)).setSocketReadTimeout(eq(gatewayProxy.getSocketReadTimeout())); + verify(mockGateway, times(1)).getQueueAttributes(); + verify(mockGatewayQueueAttributes, times(1)).setAlertThreshold(eq(gatewayQueue.getAlertThreshold())); + verify(mockGatewayQueueAttributes, times(1)).setBatchConflation(eq(gatewayQueue.getEnableBatchConflation())); + verify(mockGatewayQueueAttributes, times(1)).setBatchSize(eq(gatewayQueue.getBatchSize())); + verify(mockGatewayQueueAttributes, times(1)).setBatchTimeInterval(eq(gatewayQueue.getBatchTimeInterval())); + verify(mockGatewayQueueAttributes, times(1)).setDiskStoreName(eq(gatewayQueue.getDiskStoreRef())); + verify(mockGatewayQueueAttributes, times(1)).setMaximumQueueMemory(eq(gatewayQueue.getMaximumQueueMemory())); + verify(mockGatewayQueueAttributes, times(1)).setEnablePersistence(eq(gatewayQueue.getPersistent())); + } + + @Test + @Ignore + public void testGatewayQueueWithOverflowNoPersistence() throws Exception { + String gatewayHubName = "testGatewayQueueWithOverflowNoPersistence"; + + GatewayProxy.GatewayQueue gatewayQueue = new GatewayProxy.GatewayQueue(); + + gatewayQueue.setAlertThreshold(100); + gatewayQueue.setBatchSize(250); + gatewayQueue.setBatchTimeInterval(120000); + gatewayQueue.setDiskStoreRef("diskZ"); + gatewayQueue.setEnableBatchConflation(true); + gatewayQueue.setMaximumQueueMemory(2048); + gatewayQueue.setPersistent(false); + + GatewayProxy gatewayProxy = new GatewayProxy(); + + gatewayProxy.setId("gatewayProxyId"); + gatewayProxy.setConcurrencyLevel(2); + gatewayProxy.setEndpoints(null); + gatewayProxy.setListeners(null); + gatewayProxy.setOrderPolicy(Gateway.OrderPolicy.THREAD); + gatewayProxy.setQueue(gatewayQueue); + gatewayProxy.setSocketBufferSize(4096); + //gatewayProxy.setSocketReadTimeout(60); + + GatewayHub mockGatewayHub = mock(GatewayHub.class, "testGatewayQueueWithOverflowNoPersistence.MockGatewayHub"); + + Gateway mockGateway = mock(Gateway.class, "testGatewayQueueWithOverflowNoPersistence.MockGateway"); + + GatewayQueueAttributes mockGatewayQueueAttributes = mock(GatewayQueueAttributes.class, + "testGatewayQueueWithOverflowNoPersistence.MockGatewayQueueAttributes"); + + when(mockCache.addGatewayHub(eq(gatewayHubName), eq(10224))).thenReturn(mockGatewayHub); + when(mockCache.getGatewayHub(eq(gatewayHubName))).thenReturn(mockGatewayHub); + when(mockGatewayHub.addGateway(eq(gatewayProxy.getId()), eq(gatewayProxy.getConcurrencyLevel()))) + .thenReturn(mockGateway); + when(mockGatewayHub.getManualStart()).thenReturn(GatewayHub.DEFAULT_MANUAL_START); + when(mockGateway.getQueueAttributes()).thenReturn(mockGatewayQueueAttributes); + + factoryBean.setGateways(Arrays.asList(gatewayProxy)); + factoryBean.setName(gatewayHubName); + factoryBean.setPort(10224); + factoryBean.afterPropertiesSet(); + + verify(mockGatewayHub, times(1)).setBindAddress(eq(GatewayHub.DEFAULT_BIND_ADDRESS)); + verify(mockGatewayHub, times(1)).setManualStart(eq(GatewayHub.DEFAULT_MANUAL_START)); + verify(mockGatewayHub, times(1)).setMaximumTimeBetweenPings(eq(GatewayHub.DEFAULT_MAXIMUM_TIME_BETWEEN_PINGS)); + verify(mockGatewayHub, times(1)).setSocketBufferSize(eq(GatewayHub.DEFAULT_SOCKET_BUFFER_SIZE)); + verify(mockGatewayHub, times(1)).setStartupPolicy(eq(GatewayHub.DEFAULT_STARTUP_POLICY)); + verify(mockGatewayHub, times(1)).start(); + verify(mockGatewayHub, times(1)).addGateway(eq(gatewayProxy.getId()), eq(gatewayProxy.getConcurrencyLevel())); + verify(mockGateway, times(1)).setOrderPolicy(eq(gatewayProxy.getOrderPolicy())); + verify(mockGateway, times(1)).setSocketBufferSize(eq(gatewayProxy.getSocketBufferSize())); + //verify(mockGateway, times(1)).setSocketReadTimeout(eq(gatewayProxy.getSocketReadTimeout())); + verify(mockGatewayQueueAttributes, times(1)).setAlertThreshold(gatewayQueue.getAlertThreshold()); + verify(mockGatewayQueueAttributes, times(1)).setBatchConflation(gatewayQueue.getEnableBatchConflation()); + verify(mockGatewayQueueAttributes, times(1)).setBatchSize(gatewayQueue.getBatchSize()); + verify(mockGatewayQueueAttributes, times(1)).setBatchTimeInterval(gatewayQueue.getBatchTimeInterval()); + verify(mockGatewayQueueAttributes, times(1)).setDiskStoreName(gatewayQueue.getDiskStoreRef()); + verify(mockGatewayQueueAttributes, times(1)).setMaximumQueueMemory(gatewayQueue.getMaximumQueueMemory()); + verify(mockGatewayQueueAttributes, times(1)).setEnablePersistence(gatewayQueue.getPersistent()); + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyConverterTest.java b/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyConverterTest.java new file mode 100644 index 00000000..f211113d --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyConverterTest.java @@ -0,0 +1,87 @@ +/* + * 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.wan; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.After; +import org.junit.Test; + +import com.gemstone.gemfire.cache.util.Gateway; + +/** + * The OrderPolicyConverterTest class is a test suite of test cases testing the contract and functionality + * of the OrderPolicyConverter. + * + * @author John Blum + * @see org.junit.Test + * @see org.springframework.data.gemfire.wan.OrderPolicyConverter + * @since 1.7.0 + */ +@SuppressWarnings("deprecation") +public class OrderPolicyConverterTest { + + private final OrderPolicyConverter converter = new OrderPolicyConverter(); + + @After + public void tearDown() { + converter.setValue(null); + } + + @Test + public void testConvert() { + assertEquals(Gateway.OrderPolicy.KEY, converter.convert("key")); + assertEquals(Gateway.OrderPolicy.PARTITION, converter.convert("Partition")); + assertEquals(Gateway.OrderPolicy.THREAD, converter.convert("THREAD")); + } + + @Test(expected = IllegalArgumentException.class) + public void testConvertIllegalValue() { + try { + converter.convert("process"); + } + catch (IllegalArgumentException expected) { + assertEquals("(process) is not a valid OrderPolicy!", expected.getMessage()); + throw expected; + } + } + + @Test + public void testSetAsText() { + converter.setAsText("PartItIOn"); + assertEquals(Gateway.OrderPolicy.PARTITION, converter.getValue()); + converter.setAsText("thREAD"); + assertEquals(Gateway.OrderPolicy.THREAD, converter.getValue()); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetAsTextWithIllegalValue() { + try { + assertNull(converter.getValue()); + converter.setAsText("value"); + } + catch (IllegalArgumentException expected) { + assertEquals("(value) is not a valid OrderPolicy!", expected.getMessage()); + throw expected; + } + finally { + assertNull(converter.getValue()); + } + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyTypeTest.java b/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyTypeTest.java new file mode 100644 index 00000000..af3da155 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/wan/OrderPolicyTypeTest.java @@ -0,0 +1,82 @@ +/* + * 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.wan; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import org.junit.Test; + +import com.gemstone.gemfire.cache.util.Gateway; + +/** + * The OrderPolicyTypeTest class is a test suite of test cases testing the contract and functionality + * of the OrderPolicyType enum. + * + * @author John Blum + * @see org.junit.Test + * @see org.springframework.data.gemfire.wan.OrderPolicyType + * @see com.gemstone.gemfire.cache.util.Gateway + * @since 1.7.0 + */ +@SuppressWarnings("deprecation") +public class OrderPolicyTypeTest { + + @Test + public void testStaticGetOrderPolicy() { + assertEquals(Gateway.OrderPolicy.KEY, OrderPolicyType.getOrderPolicy(OrderPolicyType.KEY)); + assertEquals(Gateway.OrderPolicy.PARTITION, OrderPolicyType.getOrderPolicy(OrderPolicyType.PARTITION)); + } + + @Test + public void testStaticGetOrderPolicyWithNull() { + assertNull(OrderPolicyType.getOrderPolicy(null)); + } + + @Test + public void testValueOfGemFireOrderPolicies() { + for (Gateway.OrderPolicy orderPolicy : Gateway.OrderPolicy.values()) { + OrderPolicyType orderPolicyType = OrderPolicyType.valueOf(orderPolicy); + + assertNotNull(orderPolicyType); + assertEquals(orderPolicy, orderPolicyType.getOrderPolicy()); + } + } + + @Test + public void testValueOfNullGemFireOrderPolicy() { + assertNull(OrderPolicyType.valueOf((Gateway.OrderPolicy) null)); + } + + @Test + public void testValueOfIgnoreCase() { + assertEquals(OrderPolicyType.KEY, OrderPolicyType.valueOfIgnoreCase("KEY")); + assertEquals(OrderPolicyType.PARTITION, OrderPolicyType.valueOfIgnoreCase("Partition")); + assertEquals(OrderPolicyType.PARTITION, OrderPolicyType.valueOfIgnoreCase("PARTition")); + assertEquals(OrderPolicyType.PARTITION, OrderPolicyType.valueOfIgnoreCase("PartItIon")); + assertEquals(OrderPolicyType.THREAD, OrderPolicyType.valueOfIgnoreCase("thread")); + } + + @Test + public void testValueOfIgnoreCaseWithInvalidValues() { + assertNull(OrderPolicyType.valueOfIgnoreCase("KEYZ")); + assertNull(OrderPolicyType.valueOfIgnoreCase("Values")); + assertNull(OrderPolicyType.valueOfIgnoreCase("invalid")); + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/wan/StartupPolicyConverterTest.java b/src/test/java/org/springframework/data/gemfire/wan/StartupPolicyConverterTest.java new file mode 100644 index 00000000..93f5a25c --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/wan/StartupPolicyConverterTest.java @@ -0,0 +1,85 @@ +/* + * 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.wan; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.After; +import org.junit.Test; + +/** + * The StartupPolicyConverterTest class is a test suite of test cases testing the contract and functionality + * of the StartupPolicyConverter class. + * + * @author John Blum + * @see org.junit.Test + * @see StartupPolicyType + * @see StartupPolicyConverter + * @since 1.6.0 + */ +public class StartupPolicyConverterTest { + + private StartupPolicyConverter converter = new StartupPolicyConverter(); + + @After + public void tearDown() { + converter.setValue(null); + } + + @Test + public void testConvert() { + assertEquals(StartupPolicyType.NONE, converter.convert("none")); + assertEquals(StartupPolicyType.PRIMARY, converter.convert("Primary")); + assertEquals(StartupPolicyType.SECONDARY, converter.convert("SecONdARY")); + } + + @Test(expected = IllegalArgumentException.class) + public void testConvertIllegalValue() { + try { + converter.convert("tertiary"); + } + catch (IllegalArgumentException expected) { + assertEquals("(tertiary) is not a valid StartupPolicyType!", expected.getMessage()); + throw expected; + } + } + + @Test + public void testSetAsText() { + converter.setAsText("priMARY"); + assertEquals(StartupPolicyType.PRIMARY, converter.getValue()); + converter.setAsText("SecondAry"); + assertEquals(StartupPolicyType.SECONDARY, converter.getValue()); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetAsTextWithIllegalValue() { + try { + assertNull(converter.getValue()); + converter.setAsText("invalid"); + } + catch (IllegalArgumentException expected) { + assertEquals("(invalid) is not a valid StartupPolicyType!", expected.getMessage()); + throw expected; + } + finally { + assertNull(converter.getValue()); + } + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/wan/StartupPolicyTypeTest.java b/src/test/java/org/springframework/data/gemfire/wan/StartupPolicyTypeTest.java new file mode 100644 index 00000000..44564bfc --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/wan/StartupPolicyTypeTest.java @@ -0,0 +1,63 @@ +/* + * 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.wan; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; + +import org.junit.Test; + +import com.gemstone.gemfire.cache.util.GatewayHub; + +/** + * The StartupPolicyTypeTest class is a test suite of test cases testing the contract and functionality + * of the StartupPolicyType enum. + * + * @author John Blum + * @see org.junit.Test + * @see StartupPolicyType + * @since 1.6.0 + */ +@SuppressWarnings("deprecation") +public class StartupPolicyTypeTest { + + @Test + public void testDefault() { + assertEquals(GatewayHub.DEFAULT_STARTUP_POLICY, StartupPolicyType.DEFAULT.getName()); + assertSame(StartupPolicyType.NONE, StartupPolicyType.DEFAULT); + } + + @Test + public void testValueOfIgnoreCase() { + assertEquals(StartupPolicyType.NONE, StartupPolicyType.valueOfIgnoreCase("NONE")); + assertEquals(StartupPolicyType.PRIMARY, StartupPolicyType.valueOfIgnoreCase("Primary")); + assertEquals(StartupPolicyType.SECONDARY, StartupPolicyType.valueOfIgnoreCase("secondary")); + assertEquals(StartupPolicyType.SECONDARY, StartupPolicyType.valueOfIgnoreCase("SECONDary")); + assertEquals(StartupPolicyType.PRIMARY, StartupPolicyType.valueOfIgnoreCase("PriMarY")); + } + + @Test + public void testValueOfIgnoreCaseWithInvalidValues() { + assertNull(StartupPolicyType.valueOfIgnoreCase("NO")); + assertNull(StartupPolicyType.valueOfIgnoreCase("Prime")); + assertNull(StartupPolicyType.valueOfIgnoreCase("second")); + assertNull(StartupPolicyType.valueOfIgnoreCase("all")); + assertNull(StartupPolicyType.valueOfIgnoreCase("N0N3")); + } + +}