Implement geode-supplier and geode-source along with common config and test support

Implement geodeCqSupplier

Implement Geode CQ Source

Implement Geode Sink

Removed @TestInstance

Combine CQ Source and Source

Clean up per review

Update README

Fix Javadoc

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

@@ -0,0 +1,183 @@
+/*
+ * 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;
+
+	/**
+	 * 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.
+	 */
+	public GeodeContainer(@NonNull String dockerImageName, int locatorPort, int cacheServerPort) {
+		super(dockerImageName);
+		this.locatorPort = locatorPort;
+		this.cacheServerPort = cacheServerPort;
+	}
+
+	/**
+	 * 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.
+	 */
+	public GeodeContainer(@NonNull Future<String> image, int locatorPort, int cacheServerPort) {
+		super(image);
+		this.locatorPort = locatorPort;
+		this.cacheServerPort = cacheServerPort;
+	}
+
+	/**
+	 * A convenience method to connect to a locator with Gfsh.
+	 * @return the connect command String.
+	 */
+	public String connect() {
+		return "connect --locator=" + locators();
+	}
+
+	/**
+	 * 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, ",");
+			}
+		}
+	}
+
+}

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

@@ -0,0 +1,94 @@
+/*
+ * 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.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;
+
+	/**
+	 * 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) {
+		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);
+		startContainer();
+	}
+
+	/**
+	 * Create and start a {@link GeodeContainer}.
+	 */
+	public GeodeContainerIntializer() {
+		this(null);
+	}
+
+	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.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();
+
+		geode.execGfsh("start locator --name=Locator1 --hostname-for-clients=localhost --port=" + locatorPort);
+		geode.execGfsh("connect --locator=" + geode.locators(),
+				"start server --name=Server1 --hostname-for-clients=localhost --server-port=" + cacheServerPort);
+		postProcessor.ifPresent(geodeContainerConsumer -> geodeContainerConsumer.accept(geode));
+	}
+
+	/**
+	 * @return the {@link GeodeContainer} instance.
+	 */
+	public GeodeContainer geodeContainer() {
+		return geode;
+	}
+
+}

common/function-test-support/src/main/resources/geode/Dockerfile

@@ -0,0 +1,93 @@
+# 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 openjdk:8-jre-alpine
+
+# runtime dependencies
+RUN apk add --no-cache \
+		bash \
+		ncurses
+
+# pub   4096R/ABF4396F 2018-04-12 [expires: 2022-04-12]
+#       8763 31B4 5A97 E382 D1BD  FB44 4482 0F9C ABF4 396F
+# uid       [  undef ] Mike Stolz <mikestolz@apache.org>
+# sub   4096R/3871E6AD 2018-04-12 [expires: 2022-04-12]
+ENV GEODE_GPG D2AE0CA42736AA78E473774DEBC77DA34AADD408
+# TODO does this change per-release like other Apache projects? (and thus needs to be a list of full fingerprints from a KEYS file instead?)
+
+ENV GEODE_HOME /geode
+ENV PATH $PATH:$GEODE_HOME/bin
+
+# https://geode.apache.org/releases/
+ENV GEODE_VERSION 1.12.0
+# Binaries TGZ SHA-256
+# https://dist.apache.org/repos/dist/release/geode/VERSION/apache-geode-VERSION.tgz.sha256
+ENV GEODE_SHA256 063b473dac914aca53c09326487cc96c63ef84eecc8b053c8cc3d5110e82f179
+
+# http://apache.org/dyn/closer.cgi/geode/1.3.0/apache-geode-1.3.0.tgz
+
+RUN set -eux; \
+	apk add --no-cache --virtual .fetch-deps \
+		libressl \
+		gnupg \
+	; \
+	for file in \
+		"geode/$GEODE_VERSION/apache-geode-$GEODE_VERSION.tgz" \
+		"geode/$GEODE_VERSION/apache-geode-$GEODE_VERSION.tgz.asc" \
+	; do \
+		target="$(basename "$file")"; \
+		for url in \
+# https://issues.apache.org/jira/browse/INFRA-8753?focusedCommentId=14735394#comment-14735394
+			"https://www.apache.org/dyn/closer.cgi?action=download&filename=$file" \
+			"https://www-us.apache.org/dist/$file" \
+			"https://www.apache.org/dist/$file" \
+			"https://archive.apache.org/dist/$file" \
+		; do \
+			if wget -O "$target" "$url"; then \
+				break; \
+			fi; \
+		done; \
+	done; \
+	[ -s "apache-geode-$GEODE_VERSION.tgz" ]; \
+	[ -s "apache-geode-$GEODE_VERSION.tgz.asc" ]; \
+	echo "$GEODE_SHA256 *apache-geode-$GEODE_VERSION.tgz" | sha256sum -c -; \
+	export GNUPGHOME="$(mktemp -d)"; \
+	gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$GEODE_GPG"; \
+	gpg --batch --verify "apache-geode-$GEODE_VERSION.tgz.asc" "apache-geode-$GEODE_VERSION.tgz"; \
+	rm -rf "$GNUPGHOME"; \
+	mkdir /geode; \
+	tar --extract \
+		--file "apache-geode-$GEODE_VERSION.tgz" \
+		--directory /geode \
+		--strip-components 1 \
+	; \
+	rm -rf /geode/javadoc "apache-geode-$GEODE_VERSION.tgz" "apache-geode-$GEODE_VERSION.tgz.asc"; \
+	apk del .fetch-deps; \
+# smoke test to ensure the shell can still run properly after removing temporary deps
+	gfsh version
+
+# Default ports:
+# RMI/JMX 1099
+# REST 8080
+# PULSE 7070
+# LOCATOR 10334
+# CACHESERVER 40404
+ARG CACHE_SERVER_PORT=40404
+ARG LOCATOR_PORT=10334
+
+EXPOSE  8080 ${LOCATOR_PORT} ${CACHE_SERVER_PORT} 1099 7070
+VOLUME ["/data"]
+#CMD ["gfsh"]