SpringCloud/spring-functions-catalog
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use Spring Test Data Geode instead of containerized geode server

Browse Source 
Use spring test data geode in the geode integration tests
test to fork a separate geode process, instead of running
a geode server in a docker container.

STDG is faster than launching Geode through gfsh inside of a container.
- It doesn't run in docker
- It doesn't start management components necessary for gfsh
- It doesn't start extra gfsh shell processes

Removing the GeodeContainer test utility
This commit is contained in:
Dan Smith
2021-01-27 14:13:49 -08:00
committed by David Turanski
parent a08cc17642
commit 943a1c9faa
10 changed files with 127 additions and 373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
common/function-test-support/pom.xml
View File

@@ -16,7 +16,6 @@
<properties>
<sshd-core.version>1.6.0</sshd-core.version>
<apache-ftpserver.version>1.1.1</apache-ftpserver.version>
<geode-starter.version>1.2.7.RELEASE</geode-starter.version>
<awaitility.version>4.0.3</awaitility.version>
</properties>
@@ -28,12 +27,6 @@
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-geode</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.integration</groupId>
<artifactId>spring-integration-ftp</artifactId>

197
common/function-test-support/src/main/java/org/springframework/cloud/fn/test/support/geode/GeodeContainer.java
View File

@@ -1,197 +0,0 @@
/*
* Copyright 2020-2020 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
*
* https://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.cloud.fn.test.support.geode;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Future;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testcontainers.containers.GenericContainer;
import org.springframework.lang.NonNull;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* A Test Container that starts a Geode Locator and Server on configured ports. This also
* provides methods for executing one or more Gfsh commands.
*/
public class GeodeContainer extends GenericContainer {
private static Logger logger = LoggerFactory.getLogger(GeodeContainer.class);
private final int locatorPort;
private final int cacheServerPort;
private final boolean useLocator;
/**
* Create a Geode container from a Docker image.
* @param dockerImageName the name of the image.
* @param locatorPort the locator port.
* @param cacheServerPort the cache server port.
* @param useLocator set to use a locator.
*/
public GeodeContainer(@NonNull String dockerImageName, int locatorPort, int cacheServerPort, boolean useLocator) {
super(dockerImageName);
this.locatorPort = locatorPort;
this.cacheServerPort = cacheServerPort;
this.useLocator = useLocator;
}
public GeodeContainer(@NonNull String dockerImageName, int locatorPort, int cacheServerPort) {
this(dockerImageName, locatorPort, cacheServerPort, false);
}
/**
* Create a Geode Container from a {@code Future<String>}. Test containers provides some
* implementations as image builders, such as
* {@link org.testcontainers.images.builder.ImageFromDockerfile}.
* @param image the image builder.
* @param locatorPort the locator port.
* @param cacheServerPort the server port.
* @param useLocator set to use a locator.
*/
public GeodeContainer(@NonNull Future<String> image, int locatorPort, int cacheServerPort, boolean useLocator) {
super(image);
this.locatorPort = locatorPort;
this.cacheServerPort = cacheServerPort;
this.useLocator = useLocator;
}
public GeodeContainer(@NonNull Future<String> image, int locatorPort, int cacheServerPort) {
this(image, locatorPort, cacheServerPort, false);
}
/**
* A convenience method to connect to a locator with Gfsh.
* @return the connect command String.
*/
public String connect() {
return useLocator ? "connect --locator=" + locators() : "connect --jmx-manager=localhost[1099]";
}
/**
* Get the locator port.
* @return the locator port.
*/
public int getLocatorPort() {
return locatorPort;
}
/**
* Get the cache server port.
* @return the cache server port.
*/
public int getCacheServerPort() {
return cacheServerPort;
}
/**
*
* @return Geode locators as host[port],...
*/
public String locators() {
return "localhost[" + locatorPort + "]";
}
/**
* Invoke the `gfsh` shell, Connect to the locator and execute the commands.
* @param command a list of commands to execute in a single `gfsh` invocation.
* @return the {@link org.testcontainers.containers.Container.ExecResult}
*/
public ExecResult connectAndExecGfsh(String... command) {
ArrayList<String> args = new ArrayList<>(Arrays.asList(command));
args.add(0, connect());
return execInContainer(Gfsh.command(args.toArray(new String[args.size()])).commandParts());
}
/**
* Invoke the `gfsh` shell, and execute the commands.
* @param command a list of commands to execute in a single `gfsh` invocation.
* @return the {@link org.testcontainers.containers.Container.ExecResult}
*/
public ExecResult execGfsh(String... command) {
return execInContainer(Gfsh.command(command).commandParts());
}
/**
* Executes a command in the container, logging stdout and stderr and wrapping checked
* exceptions.
* @see GenericContainer#execInContainer(String...)
* @param command the command to execute.
* @return the {@link org.testcontainers.containers.Container.ExecResult}
*/
@Override
public ExecResult execInContainer(String... command) {
try {
ExecResult execResult = super.execInContainer(command);
logger.debug("stdout: {}", execResult.getStdout());
if (execResult.getExitCode() != 0) {
logger.warn("stdout: {}", execResult.getStdout());
logger.warn("stderr: {}", execResult.getStderr());
}
return execResult;
}
catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
catch (InterruptedException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* Builds a Gfsh command.
*/
public final static class Gfsh {
public static Command command(String... gfshCommands) {
return new Command(gfshCommands);
}
public final static class Command {
private final List<String> commandParts = new LinkedList<>();
private Command(String... gfshCommands) {
Assert.notEmpty(gfshCommands, "at least one command is required");
for (String gfshCommand : gfshCommands) {
Assert.hasText(gfshCommand, "command must contain text");
if (commandParts.size() == 0) {
commandParts.add("gfsh");
}
commandParts.add("-e");
commandParts.add(gfshCommand);
}
}
public String[] commandParts() {
return commandParts.toArray(new String[commandParts.size()]);
}
public String toString() {
return StringUtils.collectionToDelimitedString(commandParts, ",");
}
}
}
}

114
common/function-test-support/src/main/java/org/springframework/cloud/fn/test/support/geode/GeodeContainerIntializer.java
View File

@@ -1,114 +0,0 @@
/*
* Copyright 2020-2020 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
*
* https://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.cloud.fn.test.support.geode;
import java.util.Optional;
import java.util.function.Consumer;
import com.github.dockerjava.api.command.CreateContainerCmd;
import com.github.dockerjava.api.model.ExposedPort;
import com.github.dockerjava.api.model.HostConfig;
import com.github.dockerjava.api.model.PortBinding;
import com.github.dockerjava.api.model.Ports;
import org.testcontainers.images.builder.ImageFromDockerfile;
import org.springframework.util.SocketUtils;
/**
* Creates and starts a {@link GeodeContainer} using available random ports for locator
* and server. Runs a {@code Consumer<GeodeContainer>} post processor if provided.
* @author David Turanski
*/
public class GeodeContainerIntializer {
private int locatorPort;
private int cacheServerPort;
private GeodeContainer geode;
private Optional<Consumer<GeodeContainer>> postProcessor;
private final boolean useLocator;
/**
* Create, start, and perform post processing on a {@link GeodeContainer}.
* @param postProcessor a {@code Consumer<GeodeContainer>} to run after the container is
* started.
*/
public GeodeContainerIntializer(Consumer<GeodeContainer> postProcessor) {
this(postProcessor, false);
}
public GeodeContainerIntializer(Consumer<GeodeContainer> postProcessor, boolean useLocator) {
this.useLocator = useLocator;
cacheServerPort = SocketUtils.findAvailableTcpPort();
locatorPort = SocketUtils.findAvailableTcpPort();
this.postProcessor = Optional.ofNullable(postProcessor);
geode = new GeodeContainer(new ImageFromDockerfile()
.withFileFromClasspath("Dockerfile", "geode/Dockerfile")
.withBuildArg("CACHE_SERVER_PORT", String.valueOf(cacheServerPort))
.withBuildArg("LOCATOR_PORT", String.valueOf(locatorPort)),
locatorPort, cacheServerPort, useLocator);
startContainer();
}
/**
* Create and start a {@link GeodeContainer}.
*/
public GeodeContainerIntializer() {
this(null, false);
}
private void startContainer() {
// There is apparently no way to initialize Geode with random port mapping. Ports
// must be the same on client and server.
Consumer<CreateContainerCmd> cmd = e -> {
e.withHostConfig(new HostConfig().withPortBindings(
new PortBinding(Ports.Binding.bindPort(cacheServerPort), new ExposedPort(cacheServerPort)),
new PortBinding(Ports.Binding.bindPort(locatorPort), new ExposedPort(locatorPort))));
};
// Wait forever
geode.withCommand("tail", "-f", "/dev/null").withCreateContainerCmdModifier(cmd).start();
if (useLocator) {
geode.execGfsh("start locator --name=Locator1 --hostname-for-clients=localhost --port=" + locatorPort);
geode.execGfsh(geode.connect(),
"start server --name=Server1 --hostname-for-clients=localhost --server-port=" + cacheServerPort);
}
else {
geode.execGfsh(
"start server --name=Server1 --hostname-for-clients=localhost --server-port=" + cacheServerPort +
" --J=-Dgemfire.jmx-manager=true --J=-Dgemfire.jmx-manager-start=true");
}
postProcessor.ifPresent(geodeContainerConsumer -> geodeContainerConsumer.accept(geode));
}
/**
* @return the {@link GeodeContainer} instance.
*/
public GeodeContainer geodeContainer() {
return geode;
}
}

22
common/function-test-support/src/main/resources/geode/Dockerfile
View File

@@ -1,22 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
FROM apachegeode/geode:1.12.0
ARG CACHE_SERVER_PORT=40404
ARG LOCATOR_PORT=10334
EXPOSE ${LOCATOR_PORT} ${CACHE_SERVER_PORT}

7
consumer/geode-consumer/pom.xml
View File

@@ -31,11 +31,10 @@
<artifactId>config-common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud.fn</groupId>
<artifactId>function-test-support</artifactId>
<version>${revision}</version>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-geode-test</artifactId>
<version>${spring-data-geode-test.version}</version>
<scope>test</scope>
</dependency>
<dependency>

27
consumer/geode-consumer/src/test/java/org/springframework/cloud/fn/consumer/geode/GeodeConsumerApplicationTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.cloud.fn.consumer.geode;
import java.io.IOException;
import java.util.function.Consumer;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -24,14 +25,15 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.geode.cache.Region;
import org.apache.geode.pdx.PdxInstance;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.cloud.fn.test.support.geode.GeodeContainer;
import org.springframework.cloud.fn.test.support.geode.GeodeContainerIntializer;
import org.springframework.cloud.fn.consumer.geodeserver.GeodeServerTestConfiguration;
import org.springframework.data.gemfire.tests.integration.ForkingClientServerIntegrationTestsSupport;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.GenericMessage;
@@ -39,24 +41,23 @@ import static org.assertj.core.api.Assertions.assertThat;
@Tag("integration")
public class GeodeConsumerApplicationTests {
private static ApplicationContextRunner applicationContextRunner;
private static GeodeContainer geode;
private ObjectMapper objectMapper = new ObjectMapper();
@BeforeAll
static void setup() {
GeodeContainerIntializer initializer = new GeodeContainerIntializer(
geodeContainer -> {
geodeContainer.connectAndExecGfsh("create region --name=Stocks --type=REPLICATE");
});
static void setup() throws IOException {
ForkingClientServerIntegrationTestsSupport.startGemFireServer(
GeodeServerTestConfiguration.class);
applicationContextRunner = new ApplicationContextRunner()
.withUserConfiguration(GeodeConsumerTestApplication.class);
}
geode = initializer.geodeContainer();
@AfterAll
static void stopServer() {
ForkingClientServerIntegrationTestsSupport.stopGemFireServer();
ForkingClientServerIntegrationTestsSupport.clearCacheServerPortAndPoolPortProperties();
}
@Test
@@ -67,7 +68,7 @@ public class GeodeConsumerApplicationTests {
"geode.consumer.json=true",
"geode.consumer.key-expression=payload.getField('symbol')",
"geode.pool.connectType=server",
"geode.pool.hostAddresses=" + "localhost:" + geode.getCacheServerPort())
"geode.pool.hostAddresses=" + "localhost:" + System.getProperty("spring.data.gemfire.cache.server.port"))
.run(context -> {
Consumer<Message<?>> geodeConsumer = context.getBean("geodeConsumer", Consumer.class);
@@ -88,7 +89,7 @@ public class GeodeConsumerApplicationTests {
"geode.region.regionName=Stocks",
"geode.consumer.key-expression='key'",
"geode.pool.connectType=server",
"geode.pool.hostAddresses=" + "localhost:" + geode.getCacheServerPort())
"geode.pool.hostAddresses=" + "localhost:" + System.getProperty("spring.data.gemfire.cache.server.port"))
.run(context -> {
Consumer<Message<?>> geodeConsumer = context.getBean("geodeConsumer", Consumer.class);

45
consumer/geode-consumer/src/test/java/org/springframework/cloud/fn/consumer/geodeserver/GeodeServerTestConfiguration.java Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2020-2020 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
*
* https://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.cloud.fn.consumer.geodeserver;
import org.apache.geode.cache.GemFireCache;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.data.gemfire.ReplicatedRegionFactoryBean;
import org.springframework.data.gemfire.config.annotation.CacheServerApplication;
@CacheServerApplication
public class GeodeServerTestConfiguration {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(GeodeServerTestConfiguration.class);
applicationContext.registerShutdownHook();
}
@Bean("Stocks")
public ReplicatedRegionFactoryBean<Object, Object> stocksRegion(GemFireCache gemfireCache) {
ReplicatedRegionFactoryBean<Object, Object> regionFactoryBean = new ReplicatedRegionFactoryBean<>();
regionFactoryBean.setCache(gemfireCache);
return regionFactoryBean;
}
}

6
supplier/geode-supplier/pom.xml
View File

@@ -55,9 +55,9 @@
</dependency>
<dependency>
<groupId>org.springframework.cloud.fn</groupId>
<artifactId>function-test-support</artifactId>
<version>${project.version}</version>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-geode-test</artifactId>
<version>${spring-data-geode-test.version}</version>
<scope>test</scope>
</dependency>

28
supplier/geode-supplier/src/test/java/org/springframework/cloud/fn/supplier/geode/GeodeSupplierApplicationTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.cloud.fn.supplier.geode;
import java.io.IOException;
import java.time.Duration;
import java.util.function.Supplier;
@@ -27,6 +28,7 @@ import lombok.NoArgsConstructor;
import org.apache.geode.cache.EntryEvent;
import org.apache.geode.cache.Region;
import org.apache.geode.pdx.PdxInstance;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
@@ -36,8 +38,8 @@ import reactor.test.StepVerifier;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.cloud.fn.common.geode.JsonPdxFunctions;
import org.springframework.cloud.fn.test.support.geode.GeodeContainer;
import org.springframework.cloud.fn.test.support.geode.GeodeContainerIntializer;
import org.springframework.cloud.fn.supplier.geodeserver.GeodeServerTestConfiguration;
import org.springframework.data.gemfire.tests.integration.ForkingClientServerIntegrationTestsSupport;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
@@ -47,21 +49,21 @@ public class GeodeSupplierApplicationTests {
private static ApplicationContextRunner applicationContextRunner;
private static GeodeContainer geode;
private final ObjectMapper objectMapper = new ObjectMapper();
@BeforeAll
static void setup() {
GeodeContainerIntializer initializer = new GeodeContainerIntializer(
geodeContainer -> {
geodeContainer.connectAndExecGfsh("create region --name=myRegion --type=REPLICATE");
});
static void setup() throws IOException {
ForkingClientServerIntegrationTestsSupport.startGemFireServer(
GeodeServerTestConfiguration.class);
applicationContextRunner = new ApplicationContextRunner()
.withUserConfiguration(GeodeSupplierTestApplication.class);
}
geode = initializer.geodeContainer();
@AfterAll
static void stopServer() {
ForkingClientServerIntegrationTestsSupport.stopGemFireServer();
ForkingClientServerIntegrationTestsSupport.clearCacheServerPortAndPoolPortProperties();
}
@Test
@@ -70,7 +72,7 @@ public class GeodeSupplierApplicationTests {
.withPropertyValues("geode.region.regionName=myRegion",
"geode.supplier.event-expression=#root",
"geode.pool.connectType=server",
"geode.pool.hostAddresses=" + "localhost:" + geode.getCacheServerPort())
"geode.pool.hostAddresses=" + "localhost:" + System.getProperty("spring.data.gemfire.cache.server.port"))
.run(context -> {
Region region = context.getBean(Region.class);
region.put("hello", "world");
@@ -103,7 +105,7 @@ public class GeodeSupplierApplicationTests {
"geode.region.regionName=myRegion",
"geode.client.pdx-read-serialized=true",
"geode.pool.connectType=server",
"geode.pool.hostAddresses=" + "localhost:" + geode.getCacheServerPort())
"geode.pool.hostAddresses=" + "localhost:" + System.getProperty("spring.data.gemfire.cache.server.port"))
.run(context -> {
Supplier<Flux<String>> geodeSupplier = context.getBean("geodeSupplier", Supplier.class);
// Using local region here
@@ -132,7 +134,7 @@ public class GeodeSupplierApplicationTests {
"geode.client.pdx-read-serialized=true",
"geode.supplier.query=Select * from /myRegion where symbol='XXX' and price > 140",
"geode.pool.connectType=server",
"geode.pool.hostAddresses=" + "localhost:" + geode.getCacheServerPort())
"geode.pool.hostAddresses=" + "localhost:" + System.getProperty("spring.data.gemfire.cache.server.port"))
.run(context -> {
Supplier<Flux<String>> geodeCqSupplier = context.getBean("geodeSupplier", Supplier.class);
// Using local region here

47
supplier/geode-supplier/src/test/java/org/springframework/cloud/fn/supplier/geodeserver/GeodeServerTestConfiguration.java Normal file
View File

@@ -0,0 +1,47 @@
/*
* Copyright 2020-2020 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
*
* https://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.cloud.fn.supplier.geodeserver;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Scope;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.data.gemfire.ReplicatedRegionFactoryBean;
import org.springframework.data.gemfire.config.annotation.CacheServerApplication;
@CacheServerApplication
public class GeodeServerTestConfiguration {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(GeodeServerTestConfiguration.class);
applicationContext.registerShutdownHook();
}
@Bean("myRegion")
public ReplicatedRegionFactoryBean<Object, Object> myRegion(GemFireCache gemfireCache) {
ReplicatedRegionFactoryBean<Object, Object> regionFactoryBean = new ReplicatedRegionFactoryBean<>();
regionFactoryBean.setScope(Scope.DISTRIBUTED_ACK);
regionFactoryBean.setCache(gemfireCache);
return regionFactoryBean;
}
}