Spring/spring-data-gemfire
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SGF-476 - Polish Spring (Data GemFire) provided, GemFire ServerLauncherCacheProvider implementation and tests.

Browse Source 
Closes #87.

(cherry picked from commit 7ef14587e207ad0d8144333add2656aef3abcfd1)
Signed-off-by: John Blum <jblum@pivotal.io>
This commit is contained in:
John Blum
2016-03-29 18:04:17 -07:00
parent b02abf2c1e
commit 91e9cdc9f8
7 changed files with 243 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/main/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProvider.java
View File

@@ -15,67 +15,66 @@
*/
package org.springframework.data.gemfire.support;
import java.util.Collections;
import java.util.Properties;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.distributed.ServerLauncher;
import com.gemstone.gemfire.distributed.ServerLauncher.Builder;
import com.gemstone.gemfire.distributed.internal.DistributionConfig;
import com.gemstone.gemfire.internal.util.CollectionUtils;
import com.gemstone.gemfire.distributed.ServerLauncherCacheProvider;
import org.apache.geode.cache.Cache;
import org.apache.geode.distributed.ServerLauncher;
import org.apache.geode.distributed.ServerLauncher.Builder;
import org.apache.geode.distributed.ServerLauncherCacheProvider;
import org.springframework.data.gemfire.GemfireUtils;
/**
* The SpringServerLauncherCacheProvider class is overrides the default behavior
* of GemFire's ServerLauncher to bootstrap the cache using a Spring
* ApplicationContext instead of a GemFire cache.xml inside a GemFire Server
* JVM-based process. This enables a GemFire Cache Server resources to be
* configured with Spring Data GemFire's XML namespace.
*
* Unlike {@link SpringContextBootstrappingInitializer}, this allows the configuration
* of the cache to specified in the Spring Context.
*
* To use this cache provider, ensure that the spring data gemfire jars are on
* the classpath of the GemFire server and specify the --spring-xml-location
* option from the command line or call {@link Builder#setSpringXmlLocation(String)}
* when launching the GemFire server.
* The SpringServerLauncherCacheProvider class overrides the default behavior of GemFire's {@link ServerLauncher}
* to bootstrap the GemFire cache using a Spring {@link org.springframework.context.ApplicationContext} instead
* of GemFire cache.xml inside a GemFire Server JVM-based process. This enables a GemFire Cache Server's resources
* to be configured with Spring Data GemFire's XML namespace.
*
* Unlike {@link SpringContextBootstrappingInitializer}, this allows the configuration of the cache to specified
* in the Spring context.
*
* To use this cache provider, ensure that the Spring Data GemFire JAR file is on the classpath of the GemFire server
* and specify the --spring-xml-location option from the Gfsh command line or call
* {@link Builder#setSpringXmlLocation(String)} when launching the GemFire server.
*
* @author Dan Smith
* @see ServerLauncherCacheProvider
* @see SpringContextBootstrappingInitializer
* @author John Blum
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ApplicationListener
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.context.annotation.
* AnnotationConfigApplicationContext
* @see org.springframework.context.event.ApplicationContextEvent
* @see org.springframework.context.event.ApplicationEventMulticaster
* @see org.springframework.context.support.ClassPathXmlApplicationContext
* @see com.gemstone.gemfire.cache.Declarable
* @link http://gemfire.docs.pivotal.io/latest/userguide/index.html#basic_config
* /the_cache/setting_cache_initializer.html
* @see org.springframework.data.gemfire.support.SpringContextBootstrappingInitializer
* @see org.apache.geode.distributed.ServerLauncherCacheProvider
* @since 1.7.0
* @link http://gemfire.docs.pivotal.io/latest/userguide/index.html#basic_config/the_cache/setting_cache_initializer.html
*/
public class SpringServerLauncherCacheProvider implements ServerLauncherCacheProvider {
/* (non-Javadoc) */
@Override
public Cache createCache(Properties gemfireProperties, ServerLauncher serverLauncher) {
if (!serverLauncher.isSpringXmlLocationSpecified()) {
return null;
Cache cache = null;
if (serverLauncher.isSpringXmlLocationSpecified()) {
System.setProperty(gemfireName(), serverLauncher.getMemberName());
newSpringContextBootstrappingInitializer().init(createParameters(serverLauncher));
cache = SpringContextBootstrappingInitializer.getApplicationContext().getBean(Cache.class);
}
System.setProperty(DistributionConfig.GEMFIRE_PREFIX + DistributionConfig.NAME_NAME,
serverLauncher.getMemberName());
createSpringContextBootstrappingInitializer().init(CollectionUtils.createProperties(
Collections.singletonMap(SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER,
serverLauncher.getSpringXmlLocation())));
return SpringContextBootstrappingInitializer.getApplicationContext().getBean(Cache.class);
return cache;
}
/* Used for testing purposes */
protected SpringContextBootstrappingInitializer createSpringContextBootstrappingInitializer() {
/* (non-Javadoc) */
Properties createParameters(ServerLauncher serverLauncher) {
Properties parameters = new Properties();
parameters.setProperty(SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER,
serverLauncher.getSpringXmlLocation());
return parameters;
}
/* (non-Javadoc) */
String gemfireName() {
return (GemfireUtils.GEMFIRE_PREFIX + GemfireUtils.NAME_PROPERTY_NAME);
}
/* (non-Javadoc) */
SpringContextBootstrappingInitializer newSpringContextBootstrappingInitializer() {
return new SpringContextBootstrappingInitializer();
}
}

0
src/main/resources/META-INF/services/com.gemstone.gemfire.distributed.ServerLauncherCacheProvider → src/main/resources/META-INF/services/org.apache.geode.distributed.ServerLauncherCacheProvider
View File

93
src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderIntegrationTest.java
View File

@@ -1,93 +0,0 @@
/*
* Copyright 2016 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.support;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.util.Collections;
import org.junit.After;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.gemfire.support.SpringContextBootstrappingInitializerIntegrationTest.UserDataStoreCacheLoader;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.cache.CacheClosedException;
import com.gemstone.gemfire.cache.CacheFactory;
import com.gemstone.gemfire.distributed.AbstractLauncher.Status;
import com.gemstone.gemfire.distributed.ServerLauncher;
import com.gemstone.gemfire.distributed.ServerLauncher.ServerState;
import com.gemstone.gemfire.distributed.internal.DistributionConfig;
import com.gemstone.gemfire.internal.util.CollectionUtils;
/**
* The SpringServerLauncherCacheProviderTest class is a test suite of test cases testing the contract and functionality
* of the SpringServerLauncherCacheProvider class. This test class focuses on testing isolated units of functionality in
* the ServerLauncherCacheProvider class directly, mocking any dependencies as appropriate, in order for the class to
* uphold it's contract.
*
* @author Dan Smith
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
*/
public class SpringServerLauncherCacheProviderIntegrationTest {
@After
public void tearDown() {
System.clearProperty(DistributionConfig.GEMFIRE_PREFIX + DistributionConfig.NAME_NAME);
SpringContextBootstrappingInitializer.getApplicationContext().close();
tearDownCache();
}
private void tearDownCache() {
try {
Cache cache = CacheFactory.getAnyInstance();
if (cache != null) {
cache.close();
}
}
catch (CacheClosedException ignore) {
// CacheClosedExceptions happen when the Cache reference returned by GemFireCacheImpl.getInstance()
// inside the CacheFactory.getAnyInstance() is null, or the Cache is already closed with calling
// Cache.close();
}
}
@Test
public void createCacheWithSpecifiedConfig() {
String xmlLocation = getClass().getSimpleName() + "-context.xml";
ServerLauncher launcher = mock(ServerLauncher.class);
ServerLauncher.Builder builder = new ServerLauncher.Builder();
builder.setSpringXmlLocation(xmlLocation);
builder.setMemberName("membername");
launcher = builder.build();
ServerState state = launcher.start();
assertEquals(Status.ONLINE, state.getStatus());
ConfigurableApplicationContext ctx = SpringContextBootstrappingInitializer.getApplicationContext();
Cache cache = ctx.getBean(Cache.class);
assertNotNull(cache);
assertEquals(55, cache.getResourceManager().getCriticalHeapPercentage(), 0.1);
assertEquals(Status.STOPPED, launcher.stop().getStatus());
}
}

83
src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderIntegrationTests.java Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2016 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.support;
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 org.apache.geode.cache.Cache;
import org.apache.geode.distributed.AbstractLauncher.Status;
import org.apache.geode.distributed.ServerLauncher;
import org.apache.geode.distributed.ServerLauncher.ServerState;
import org.junit.After;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.gemfire.GemfireUtils;
/**
* Integration tests for {@link SpringServerLauncherCacheProvider}.
*
* @author Dan Smith
* @author John Blum
* @see org.junit.Test
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
* @see org.apache.geode.cache.Cache
* @see org.apache.geode.distributed.ServerLauncher
*/
public class SpringServerLauncherCacheProviderIntegrationTests {
@After
public void tearDown() {
System.clearProperty(gemfireName());
SpringContextBootstrappingInitializer.getApplicationContext().close();
GemfireUtils.closeClientCache();
}
String gemfireName() {
return (GemfireUtils.GEMFIRE_PREFIX + GemfireUtils.NAME_PROPERTY_NAME);
}
@Test
public void createCacheWithSpring() {
String springXmlLocation = getClass().getSimpleName() + "-context.xml";
ServerLauncher.Builder builder = new ServerLauncher.Builder();
builder.setSpringXmlLocation(springXmlLocation);
builder.setMemberName("membername");
ServerLauncher launcher = builder.build();
ServerState state = launcher.start();
assertThat(state.getStatus(), is(equalTo(Status.ONLINE)));
ConfigurableApplicationContext applicationContext =
SpringContextBootstrappingInitializer.getApplicationContext();
Cache cache = applicationContext.getBean(Cache.class);
assertThat(cache, is(notNullValue()));
assertThat(cache.getResourceManager().getCriticalHeapPercentage(), is(equalTo(55.0f)));
state = launcher.stop();
assertThat(state.getStatus(), is(equalTo(Status.STOPPED)));
}
}

92
src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderTest.java
View File

@@ -1,92 +0,0 @@
/*
* Copyright 2016 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.support;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.util.Collections;
import org.junit.After;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.distributed.ServerLauncher;
import com.gemstone.gemfire.distributed.internal.DistributionConfig;
import com.gemstone.gemfire.internal.util.CollectionUtils;
/**
* The SpringServerLauncherCacheProviderTest class is a test suite of test cases testing the contract and functionality
* of the SpringServerLauncherCacheProvider class. This test class focuses on testing isolated units of functionality in
* the ServerLauncherCacheProvider class directly, mocking any dependencies as appropriate, in order for the class to
* uphold it's contract.
*
* @author Dan Smith
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
*/
public class SpringServerLauncherCacheProviderTest {
@After
public void tearDown() {
System.clearProperty(DistributionConfig.GEMFIRE_PREFIX + DistributionConfig.NAME_NAME);
SpringContextBootstrappingInitializer.applicationContext = null;
}
@Test
public void doesNothingWhenSpringXmlLocationNotSpecified() {
SpringServerLauncherCacheProvider provider = new SpringServerLauncherCacheProvider();
ServerLauncher launcher = mock(ServerLauncher.class);
when(launcher.isSpringXmlLocationSpecified()).thenReturn(false);
assertEquals(null, provider.createCache(null, launcher));
verify(launcher).isSpringXmlLocationSpecified();
}
@Test
public void createCacheWithSpecifiedConfig() {
String xmlLocation = "xml/location";
ServerLauncher launcher = mock(ServerLauncher.class);
when(launcher.isSpringXmlLocationSpecified()).thenReturn(true);
when(launcher.getSpringXmlLocation()).thenReturn(xmlLocation);
when(launcher.getMemberName()).thenReturn("membername");
final SpringContextBootstrappingInitializer initializer = mock(SpringContextBootstrappingInitializer.class);
ConfigurableApplicationContext context = mock(ConfigurableApplicationContext.class);
SpringContextBootstrappingInitializer.applicationContext = context;
Cache cache = mock(Cache.class);
when(context.getBean(eq(Cache.class))).thenReturn(cache );
SpringServerLauncherCacheProvider provider = new SpringServerLauncherCacheProvider() {
@Override
public SpringContextBootstrappingInitializer createSpringContextBootstrappingInitializer() {
return initializer;
}
};
assertEquals(cache, provider.createCache(null, launcher));
verify(launcher).isSpringXmlLocationSpecified();
verify(initializer).init(CollectionUtils.createProperties(
Collections.singletonMap(SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER,
xmlLocation)));
}
}

113
src/test/java/org/springframework/data/gemfire/support/SpringServerLauncherCacheProviderUnitTests.java Normal file
View File

@@ -0,0 +1,113 @@
/*
* Copyright 2016 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.support;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.eq;
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.Properties;
import org.apache.geode.cache.Cache;
import org.apache.geode.distributed.ServerLauncher;
import org.junit.After;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.gemfire.GemfireUtils;
/**
* Unit tests for {@link SpringServerLauncherCacheProvider}.
*
* @author Dan Smith
* @author John Blum
* @see org.junit.Test
* @see org.mockito.Mockito
* @see org.apache.geode.cache.Cache
* @see org.apache.geode.distributed.ServerLauncher
* @see org.apache.geode.distributed.ServerLauncherCacheProvider
* @see org.springframework.context.ApplicationContext
* @see org.springframework.context.ConfigurableApplicationContext
* @see org.springframework.data.gemfire.support.SpringServerLauncherCacheProvider
*/
public class SpringServerLauncherCacheProviderUnitTests {
String gemfireName() {
return (GemfireUtils.GEMFIRE_PREFIX + GemfireUtils.NAME_PROPERTY_NAME);
}
Properties singletonProperties(String propertyName, String propertyValue) {
Properties properties = new Properties();
properties.setProperty(propertyName, propertyValue);
return properties;
}
@After
public void tearDown() {
System.clearProperty(gemfireName());
SpringContextBootstrappingInitializer.applicationContext = null;
}
@Test
public void createsCacheWhenSpringXmlLocationIsSpecified() {
Cache mockCache = mock(Cache.class);
ConfigurableApplicationContext mockApplicationContext = mock(ConfigurableApplicationContext.class);
ServerLauncher mockServerLauncher = mock(ServerLauncher.class);
SpringContextBootstrappingInitializer.applicationContext = mockApplicationContext;
when(mockServerLauncher.isSpringXmlLocationSpecified()).thenReturn(true);
when(mockServerLauncher.getSpringXmlLocation()).thenReturn("test-context.xml");
when(mockServerLauncher.getMemberName()).thenReturn("TEST");
when(mockApplicationContext.getBean(eq(Cache.class))).thenReturn(mockCache);
final SpringContextBootstrappingInitializer initializer = mock(SpringContextBootstrappingInitializer.class);
SpringServerLauncherCacheProvider provider = new SpringServerLauncherCacheProvider() {
@Override
public SpringContextBootstrappingInitializer newSpringContextBootstrappingInitializer() {
return initializer;
}
};
Properties expectedParameters = singletonProperties(
SpringContextBootstrappingInitializer.CONTEXT_CONFIG_LOCATIONS_PARAMETER, "test-context.xml");
assertThat(provider.createCache(null, mockServerLauncher), is(equalTo(mockCache)));
verify(mockServerLauncher, times(1)).isSpringXmlLocationSpecified();
verify(mockServerLauncher, times(1)).getSpringXmlLocation();
verify(mockServerLauncher, times(1)).getMemberName();
verify(mockApplicationContext, times(1)).getBean(eq(Cache.class));
verify(initializer).init(eq(expectedParameters));
}
@Test
public void doesNothingWhenSpringXmlLocationNotSpecified() {
ServerLauncher launcher = mock(ServerLauncher.class);
when(launcher.isSpringXmlLocationSpecified()).thenReturn(false);
assertThat(new SpringServerLauncherCacheProvider().createCache(null, launcher), is(nullValue()));
verify(launcher, times(1)).isSpringXmlLocationSpecified();
}
}

11
src/test/resources/SpringServerLauncherCacheProviderIntegrationTest-context.xml → src/test/resources/SpringServerLauncherCacheProviderIntegrationTests-context.xml
View File

@@ -1,5 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- data source Spring XML configuration file and meta-data, using GemFire -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:gfe="http://www.springframework.org/schema/gemfire"
xmlns:util="http://www.springframework.org/schema/util"
@@ -11,15 +10,11 @@
">
<util:properties id="gemfireProperties">
<prop key="name">SpringContextBootstrappingInitializerTest</prop>
<prop key="statistic-sampling-enabled">false</prop>
<prop key="name">SpringServerLauncherCacheProviderIntegrationTest</prop>
<prop key="mcast-port">0</prop>
<prop key="log-level">config</prop>
<prop key="log-level">warn</prop>
</util:properties>
<gfe:cache properties-ref="gemfireProperties" use-bean-factory-locator="false"
critical-heap-percentage="55"/>
<gfe:replicated-region id="TestRegion" persistent="false"/>
<gfe:cache properties-ref="gemfireProperties" critical-heap-percentage="55"/>
</beans>