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

[SB3 Update] Remove Apache Geode (#345)

Browse Source 
- Also update SFTP usage
This commit is contained in:
Corneil du Plessis
2022-10-07 15:22:57 +02:00
committed by GitHub
parent b5ed0bdf1e
commit c64b259d91
52 changed files with 74 additions and 2785 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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, ",");
}
}
}
}

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

@@ -1,112 +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;
/**
* 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;
}
}

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

@@ -1,302 +0,0 @@
/*
* Copyright 2002-2022 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.net.DatagramSocket;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;
import javax.net.ServerSocketFactory;
import org.springframework.util.Assert;
/**
* Simple utility methods for working with network sockets &mdash; for example,
* for finding available ports on {@code localhost}.
*
* <p>Within this class, a TCP port refers to a port for a {@link ServerSocket};
* whereas, a UDP port refers to a port for a {@link DatagramSocket}.
*
* <p>{@code SocketUtils} was introduced in Spring Framework 4.0, primarily to
* assist in writing integration tests which start an external server on an
* available random port. However, these utilities make no guarantee about the
* subsequent availability of a given port and are therefore unreliable. Instead
* of using {@code SocketUtils} to find an available local port for a server, it
* is recommended that you rely on a server's ability to start on a random port
* that it selects or is assigned by the operating system. To interact with that
* server, you should query the server for the port it is currently using.
*
* @author Sam Brannen
* @author Ben Hale
* @author Arjen Poutsma
* @author Gunnar Hillert
* @author Gary Russell
* @since 4.0
* @deprecated as of Spring Framework 5.3.16, to be removed in 6.0; see
* {@link SocketUtils class-level Javadoc} for details.
*/
@Deprecated
public final class SocketUtils {
/**
* The default minimum value for port ranges used when finding an available
* socket port.
*/
public static final int PORT_RANGE_MIN = 1024;
/**
* The default maximum value for port ranges used when finding an available
* socket port.
*/
public static final int PORT_RANGE_MAX = 65535;
private static final Random random = new Random(System.nanoTime());
private SocketUtils() {
}
/**
* Find an available TCP port randomly selected from the range
* [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
* @return an available TCP port number
* @throws IllegalStateException if no available port could be found
*/
public static int findAvailableTcpPort() {
return findAvailableTcpPort(PORT_RANGE_MIN);
}
/**
* Find an available TCP port randomly selected from the range
* [{@code minPort}, {@value #PORT_RANGE_MAX}].
* @param minPort the minimum port number
* @return an available TCP port number
* @throws IllegalStateException if no available port could be found
*/
public static int findAvailableTcpPort(int minPort) {
return findAvailableTcpPort(minPort, PORT_RANGE_MAX);
}
/**
* Find an available TCP port randomly selected from the range
* [{@code minPort}, {@code maxPort}].
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return an available TCP port number
* @throws IllegalStateException if no available port could be found
*/
public static int findAvailableTcpPort(int minPort, int maxPort) {
return SocketType.TCP.findAvailablePort(minPort, maxPort);
}
/**
* Find the requested number of available TCP ports, each randomly selected
* from the range [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
* @param numRequested the number of available ports to find
* @return a sorted set of available TCP port numbers
* @throws IllegalStateException if the requested number of available ports could not be found
*/
public static SortedSet<Integer> findAvailableTcpPorts(int numRequested) {
return findAvailableTcpPorts(numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX);
}
/**
* Find the requested number of available TCP ports, each randomly selected
* from the range [{@code minPort}, {@code maxPort}].
* @param numRequested the number of available ports to find
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return a sorted set of available TCP port numbers
* @throws IllegalStateException if the requested number of available ports could not be found
*/
public static SortedSet<Integer> findAvailableTcpPorts(int numRequested, int minPort, int maxPort) {
return SocketType.TCP.findAvailablePorts(numRequested, minPort, maxPort);
}
/**
* Find an available UDP port randomly selected from the range
* [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
* @return an available UDP port number
* @throws IllegalStateException if no available port could be found
*/
public static int findAvailableUdpPort() {
return findAvailableUdpPort(PORT_RANGE_MIN);
}
/**
* Find an available UDP port randomly selected from the range
* [{@code minPort}, {@value #PORT_RANGE_MAX}].
* @param minPort the minimum port number
* @return an available UDP port number
* @throws IllegalStateException if no available port could be found
*/
public static int findAvailableUdpPort(int minPort) {
return findAvailableUdpPort(minPort, PORT_RANGE_MAX);
}
/**
* Find an available UDP port randomly selected from the range
* [{@code minPort}, {@code maxPort}].
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return an available UDP port number
* @throws IllegalStateException if no available port could be found
*/
public static int findAvailableUdpPort(int minPort, int maxPort) {
return SocketType.UDP.findAvailablePort(minPort, maxPort);
}
/**
* Find the requested number of available UDP ports, each randomly selected
* from the range [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
* @param numRequested the number of available ports to find
* @return a sorted set of available UDP port numbers
* @throws IllegalStateException if the requested number of available ports could not be found
*/
public static SortedSet<Integer> findAvailableUdpPorts(int numRequested) {
return findAvailableUdpPorts(numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX);
}
/**
* Find the requested number of available UDP ports, each randomly selected
* from the range [{@code minPort}, {@code maxPort}].
* @param numRequested the number of available ports to find
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return a sorted set of available UDP port numbers
* @throws IllegalStateException if the requested number of available ports could not be found
*/
public static SortedSet<Integer> findAvailableUdpPorts(int numRequested, int minPort, int maxPort) {
return SocketType.UDP.findAvailablePorts(numRequested, minPort, maxPort);
}
private enum SocketType {
TCP {
@Override
protected boolean isPortAvailable(int port) {
try {
ServerSocket serverSocket = ServerSocketFactory.getDefault().createServerSocket(
port, 1, InetAddress.getByName("localhost"));
serverSocket.close();
return true;
}
catch (Exception ex) {
return false;
}
}
},
UDP {
@Override
protected boolean isPortAvailable(int port) {
try {
DatagramSocket socket = new DatagramSocket(port, InetAddress.getByName("localhost"));
socket.close();
return true;
}
catch (Exception ex) {
return false;
}
}
};
/**
* Determine if the specified port for this {@code SocketType} is
* currently available on {@code localhost}.
*/
protected abstract boolean isPortAvailable(int port);
/**
* Find a pseudo-random port number within the range
* [{@code minPort}, {@code maxPort}].
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return a random port number within the specified range
*/
private int findRandomPort(int minPort, int maxPort) {
int portRange = maxPort - minPort;
return minPort + random.nextInt(portRange + 1);
}
/**
* Find an available port for this {@code SocketType}, randomly selected
* from the range [{@code minPort}, {@code maxPort}].
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return an available port number for this socket type
* @throws IllegalStateException if no available port could be found
*/
int findAvailablePort(int minPort, int maxPort) {
Assert.isTrue(minPort > 0, "'minPort' must be greater than 0");
Assert.isTrue(maxPort >= minPort, "'maxPort' must be greater than or equal to 'minPort'");
Assert.isTrue(maxPort <= PORT_RANGE_MAX, "'maxPort' must be less than or equal to " + PORT_RANGE_MAX);
int portRange = maxPort - minPort;
int candidatePort;
int searchCounter = 0;
do {
if (searchCounter > portRange) {
throw new IllegalStateException(String.format(
"Could not find an available %s port in the range [%d, %d] after %d attempts",
name(), minPort, maxPort, searchCounter));
}
candidatePort = findRandomPort(minPort, maxPort);
searchCounter++;
}
while (!isPortAvailable(candidatePort));
return candidatePort;
}
/**
* Find the requested number of available ports for this {@code SocketType},
* each randomly selected from the range [{@code minPort}, {@code maxPort}].
* @param numRequested the number of available ports to find
* @param minPort the minimum port number
* @param maxPort the maximum port number
* @return a sorted set of available port numbers for this socket type
* @throws IllegalStateException if the requested number of available ports could not be found
*/
SortedSet<Integer> findAvailablePorts(int numRequested, int minPort, int maxPort) {
Assert.isTrue(minPort > 0, "'minPort' must be greater than 0");
Assert.isTrue(maxPort > minPort, "'maxPort' must be greater than 'minPort'");
Assert.isTrue(maxPort <= PORT_RANGE_MAX, "'maxPort' must be less than or equal to " + PORT_RANGE_MAX);
Assert.isTrue(numRequested > 0, "'numRequested' must be greater than 0");
Assert.isTrue((maxPort - minPort) >= numRequested,
"'numRequested' must not be greater than 'maxPort' - 'minPort'");
SortedSet<Integer> availablePorts = new TreeSet<>();
int attemptCount = 0;
while ((++attemptCount <= numRequested + 100) && availablePorts.size() < numRequested) {
availablePorts.add(findAvailablePort(minPort, maxPort));
}
if (availablePorts.size() != numRequested) {
throw new IllegalStateException(String.format(
"Could not find %d available %s ports in the range [%d, %d]",
numRequested, name(), minPort, maxPort));
}
return availablePorts;
}
}
}