refactor code to accommodate edge port config for all services (localstack#20)

Author: whummer

README.md

@@ -26,7 +26,7 @@ import cloud.localstack.TestUtils;
 import cloud.localstack.docker.annotation.LocalstackDockerProperties;
 
 @RunWith(LocalstackTestRunner.class)
-@LocalstackDockerProperties(services = { "s3", "sqs", "kinesis:77077" })
+@LocalstackDockerProperties(services = { "s3", "sqs", "kinesis" })
 public class MyCloudAppTest {
 
   @Test
@@ -39,7 +39,7 @@ public class MyCloudAppTest {
 }
 ```
 
-Or with JUnit 5 :
+Or with JUnit 5:
 
 ```
 @ExtendWith(LocalstackDockerExtension.class)
@@ -58,7 +58,7 @@ Simply add the following dependency to your `pom.xml` file:
 <dependency>
     <groupId>cloud.localstack</groupId>
     <artifactId>localstack-utils</artifactId>
-    <version>0.2.1</version>
+    <version>0.2.2</version>
 </dependency>
 ```
 
@@ -69,17 +69,24 @@ You can configure the Docker behaviour using the `@LocalstackDockerProperties` a
 | property                    | usage                                                                                                                        | type                         | default value |
 |-----------------------------|------------------------------------------------------------------------------------------------------------------------------|------------------------------|---------------|
 | `pullNewImage`              | Determines if a new image is pulled from the docker repo before the tests are run.                                           | boolean                      | `false`         |
-| `randomizePorts`            | Determines if the container should expose the default local stack ports (4567-4583) or if it should expose randomized ports. | boolean                      | `false`         |
 | `services`                  | Determines which services should be run when the localstack starts.                                                          | String[]                     | All           |
 | `imageTag`                  | Use a specific image tag for docker container                                                                                | String                       | `latest`        |
 | `hostNameResolver`          | Used for determining the host name of the machine running the docker containers so that the containers can be addressed.     | IHostNameResolver            | `localhost`     |
 | `environmentVariableProvider` | Used for injecting environment variables into the container.                                                                 | IEnvironmentVariableProvider | Empty Map     |
 | `useSingleDockerContainer`  | Whether a singleton container should be used by all test classes.                     | boolean | `false`     |
 
-_Note: When specifying the port in the `services` property, you cannot use `randomizePorts = true`_
-
 For more details, please refer to the README of the main LocalStack repo: https://github.com/localstack/localstack
 
+### Deprecated Configurations
+
+Due to recent changes in LocalStack (e.g., exposing all services via a single edge port, `4566`), the following configuration parameters are now deprecated in the latest version:
+
+| property                    | usage                                                                                                                        | type                         | default value |
+|-----------------------------|------------------------------------------------------------------------------------------------------------------------------|------------------------------|---------------|
+| `randomizePorts`            | Determines if the container should expose the default local stack ports (4567-4583) or if it should expose randomized ports. | boolean                      | `false`         |
+
+_Note: When specifying the port in the `services` property, you cannot use `randomizePorts = true`_
+
 ## Building
 
 To build the latest version of the code via Maven:
@@ -89,11 +96,12 @@ make build
 
 ## Change Log
 
-* v0.2.2: Addition of CloudWatch Logs endpoint configuration
+* v0.2.2: Addition of CloudWatch Logs endpoint configuration; adjust tests to use central edge service endpoint
 * v0.2.1: Move Java sources into separate project; mark non-Docker Java `LocalstackExtension` as deprecated; update paths for Python code lookup in Docker container
+* v0.2.0: Last version still maintained in LocalStack main repo
 
 ## License
 
-Copyright (c) 2017-2020 LocalStack maintainers and contributors.
+Copyright (c) LocalStack maintainers and contributors.
 
 This version of LocalStack is released under the Apache License, Version 2.0 (see LICENSE.txt).

src/main/java/cloud/localstack/Constants.java

@@ -8,6 +8,8 @@ public class Constants {
 
     public static final String LOCALHOST_DOMAIN_NAME = "localhost.localstack.cloud";
 
+    public static final String DEFAULT_AWS_ACCOUNT_ID = "000000000000";
+
     public static final String DEFAULT_REGION = "us-east-1";
     public static final String TEST_ACCESS_KEY = "test";
     public static final String TEST_SECRET_KEY = "test";

src/main/java/cloud/localstack/Localstack.java

@@ -23,22 +23,21 @@
  */
 public class Localstack {
 
+    public static final String ENV_CONFIG_USE_SSL = "USE_SSL";
+    public static final String ENV_CONFIG_EDGE_PORT = "EDGE_PORT";
+
     private static final Logger LOG = Logger.getLogger(Localstack.class.getName());
 
+    private static final Pattern READY_TOKEN = Pattern.compile("Ready\\.");
+
+    private static final int DEFAULT_EDGE_PORT = 4566;
+
     private static final String PORT_CONFIG_FILENAME = "/opt/code/localstack/" +
             ".venv/lib/python3.8/site-packages/localstack_client/config.py";
 
-    private static final Pattern READY_TOKEN = Pattern.compile("Ready\\.");
-
     //Regular expression used to parse localstack config to determine default ports for services
     private static final Pattern DEFAULT_PORT_PATTERN = Pattern.compile("'(\\w+)'\\Q: '{proto}://{host}:\\E(\\d+)'");
 
-    private static final int SERVICE_NAME_GROUP = 1;
-
-    private static final int PORT_GROUP = 2;
-
-    public static final String ENV_CONFIG_USE_SSL = "USE_SSL";
-
     private Container localStackContainer;
 
     /**
@@ -99,12 +98,16 @@ public void stop() {
         locked = false;
     }
 
+    public boolean isRunning() {
+        return localStackContainer == null ? false : localStackContainer.isRunning();
+    }
+
     private void loadServiceToPortMap() {
         String localStackPortConfig = localStackContainer.executeCommand(Arrays.asList("cat", PORT_CONFIG_FILENAME));
 
+        int edgePort = getEdgePort();
         Map<String, Integer> ports = new RegexStream(DEFAULT_PORT_PATTERN.matcher(localStackPortConfig)).stream()
-                .collect(Collectors.toMap(match -> match.group(SERVICE_NAME_GROUP),
-                        match -> Integer.parseInt(match.group(PORT_GROUP))));
+                .collect(Collectors.toMap(match -> match.group(1), match -> edgePort));
 
         serviceToPortMap = Collections.unmodifiableMap(ports);
     }
@@ -121,6 +124,11 @@ public String getEndpointS3() {
         return s3Endpoint;
     }
 
+    public int getEdgePort() {
+        String envEdgePort = System.getenv(ENV_CONFIG_EDGE_PORT);
+        return envEdgePort == null ? DEFAULT_EDGE_PORT : Integer.parseInt(envEdgePort);
+    }
+
     public String getEndpointKinesis() {
         return endpointForService(ServiceName.KINESIS);
     }
@@ -172,7 +180,7 @@ public String getEndpointCloudWatch() {
     public String getEndpointCloudWatchLogs() {
         return endpointForService(ServiceName.CLOUDWATCH_LOGS);
     }
-    
+
     public String getEndpointSES() {
         return endpointForService(ServiceName.SES);
     }
@@ -206,6 +214,10 @@ public String getEndpointIAM() {
     }
 
     public String endpointForService(String serviceName) {
+        return endpointForPort(getServicePort(serviceName));
+    }
+
+    public int getServicePort(String serviceName) {
         if (serviceToPortMap == null) {
             throw new IllegalStateException("Service to port mapping has not been determined yet.");
         }
@@ -214,8 +226,7 @@ public String endpointForService(String serviceName) {
             throw new IllegalArgumentException("Unknown port mapping for service: " + serviceName);
         }
 
-        int internalPort = serviceToPortMap.get(serviceName);
-        return endpointForPort(internalPort);
+        return serviceToPortMap.get(serviceName);
     }
 
     public String endpointForPort(int port) {

src/main/java/cloud/localstack/docker/Container.java

@@ -22,10 +22,10 @@ public class Container {
     private static final Logger LOG = Logger.getLogger(Container.class.getName());
 
     private static final String LOCALSTACK_NAME = "localstack/localstack";
-    private static final String LOCALSTACK_PORTS = "4566-4593";
+    private static final String LOCALSTACK_PORT_EDGE = "4566";
+    private static final String LOCALSTACK_PORT_ELASTICSEARCH = "4571";
 
     private static final int MAX_PORT_CONNECTION_ATTEMPTS = 10;
-
     private static final int MAX_LOG_COLLECTION_ATTEMPTS = 120;
     private static final long POLL_INTERVAL = 1000;
     private static final int NUM_LOG_LINES = 10;
@@ -66,7 +66,8 @@ public static Container createLocalstackContainer(
         }
 
         RunCommand runCommand = new RunCommand(LOCALSTACK_NAME, imageTag)
-            .withExposedPorts(LOCALSTACK_PORTS, randomizePorts)
+            .withExposedPorts(LOCALSTACK_PORT_EDGE, randomizePorts)
+            .withExposedPorts(LOCALSTACK_PORT_ELASTICSEARCH, randomizePorts)
             .withEnvironmentVariable(LOCALSTACK_EXTERNAL_HOSTNAME, externalHostName)
             .withEnvironmentVariable(ENV_DEBUG, ENV_DEBUG_DEFAULT)
             .withEnvironmentVariable(ENV_USE_SSL, Localstack.INSTANCE.useSSL() ? "1" : "0")
@@ -82,7 +83,6 @@ public static Container createLocalstackContainer(
         return result;
     }
 
-
     public static Container getRunningLocalstackContainer() {
         return getRunningLocalstackContainer(DEFAULT_CONTAINER_ID);
     }
@@ -134,6 +134,15 @@ private boolean isPortOpen(String ip, PortMapping port) {
         }
     }
 
+    public boolean isRunning() {
+        try {
+            new PortCommand(containerId).execute();
+            return true;
+        } catch(Exception e) {
+            return false;
+        }
+    }
+
     /**
      * Poll the docker logs until a specific token appears, then return. Primarily
      * used to look for the "Ready." token in the LocalStack logs.

src/main/java/cloud/localstack/docker/LocalstackDockerExtension.java

@@ -37,9 +37,10 @@ public void beforeAll(final ExtensionContext context) throws Exception {
         } else {
             store = context.getStore(NAMESPACE);
         }
-        if (store.get("localstack") == null) {
-            final StartedLocalStack startedStack = new LocalstackDockerExtension.StartedLocalStack(context);
-            store.getOrComputeIfAbsent("localstack", key -> startedStack);
+        StartedLocalStack startedStack = (StartedLocalStack)store.get("localstack");
+        if (startedStack == null || !startedStack.isRunning()) {
+            final StartedLocalStack newStartedStack = new LocalstackDockerExtension.StartedLocalStack(context);
+            store.put("localstack", newStartedStack);
         }
     }
 
@@ -56,6 +57,10 @@ static class StartedLocalStack implements ExtensionContext.Store.CloseableResour
             localstackDocker.startup(dockerConfig);
         }
 
+        public boolean isRunning() {
+            return localstackDocker.isRunning();
+        }
+
         @Override
         public void close() throws Throwable {
             localstackDocker.stop();

src/main/java/cloud/localstack/docker/annotation/LocalstackDockerAnnotationProcessor.java

@@ -75,7 +75,7 @@ private String getExternalHostName(final LocalstackDockerProperties properties)
 
             final String externalHostName = StringUtils.defaultIfBlank(resolvedName, "localhost");
 
-            LOG.info("External host name is set to: " + externalHostName);
+            LOG.fine("External host name is set to: " + externalHostName);
             return externalHostName;
         } catch (InstantiationException | IllegalAccessException ex) {
             throw new IllegalStateException("Unable to resolve hostname", ex);

src/main/java/cloud/localstack/docker/annotation/LocalstackDockerProperties.java

@@ -33,8 +33,11 @@
 
     /**
      * Determines if the container should expose the default local stack ports (4567-4583) or if it should expose randomized ports
-     *  in order to prevent conflicts with other localstack containers running on the same machine
+     *  in order to prevent conflicts with other localstack containers running on the same machine.
+     *
+     * Deprecated, since latest LocalStack is using a single entry point (edge service)
      */
+    @Deprecated
     boolean randomizePorts() default false;
 
     /**

src/main/java/cloud/localstack/docker/command/PortCommand.java

@@ -30,6 +30,7 @@ public List<PortMapping> execute() {
                 .collect(Collectors.toList());
     }
 
-    private Function<MatchResult, PortMapping> matchToPortMapping = m -> new PortMapping(m.group(IP_GROUP), m.group(EXTERNAL_PORT_GROUP), m.group(INTERNAL_PORT_GROUP));
+    private Function<MatchResult, PortMapping> matchToPortMapping = m ->
+        new PortMapping(m.group(IP_GROUP), m.group(EXTERNAL_PORT_GROUP), m.group(INTERNAL_PORT_GROUP));
 
 }