Reuse Elasticsearch container between test runs for integration tests (#6843)

    Added the new `withReuse(true)` flag from this new testcontainers
    feature: testcontainers/testcontainers-java#1781

    This allows not only reusing a container between different tests in the
    same run, but also keeping the container alive for subsequent runs to
    decrease container startup time.

Author: Luca Di Grazia

dataset/GitHub_Java/Graylog2.graylog2-server/graylog2-server/src/test/java/org/graylog/testing/elasticsearch/ElasticsearchInstance.java

@@ -16,39 +16,68 @@
  */
 package org.graylog.testing.elasticsearch;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.github.joschi.jadconfig.util.Duration;
 import com.github.zafarkhaja.semver.Version;
-import com.google.common.io.Resources;
+import com.google.common.base.Stopwatch;
+import com.google.common.collect.ImmutableList;
+import io.searchbox.client.JestClient;
+import io.searchbox.cluster.State;
+import org.graylog.testing.PropertyLoader;
+import org.graylog2.bindings.providers.JestClientProvider;
+import org.graylog2.indexer.cluster.jest.JestUtils;
+import org.graylog2.shared.bindings.providers.ObjectMapperProvider;
 import org.junit.rules.ExternalResource;
-import org.testcontainers.containers.Network;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.testcontainers.containers.wait.strategy.Wait;
 import org.testcontainers.elasticsearch.ElasticsearchContainer;
-import org.testcontainers.utility.DockerImageName;
 
-import java.net.URL;
-import java.nio.file.Paths;
+import java.net.URI;
 import java.util.HashMap;
-import java.util.Locale;
 import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.TimeUnit;
+
+import static com.google.common.collect.Iterators.toArray;
 
 /**
- * This rule starts an Elasticsearch instance and provides a configured {@link Client}.
+ * This rule starts an Elasticsearch instance and provides a configured {@link JestClient}.
  */
-public abstract class ElasticsearchInstance extends ExternalResource {
+public class ElasticsearchInstance extends ExternalResource {
+
+    private static final Logger LOG = LoggerFactory.getLogger(ElasticsearchInstance.class);
+
     private static final Map<Version, ElasticsearchContainer> containersByVersion = new HashMap<>();
 
+    private static final String PROPERTIES_RESOURCE_NAME = "elasticsearch.properties";
+
     private static final String DEFAULT_IMAGE_OSS = "docker.elastic.co/elasticsearch/elasticsearch-oss";
     private static final String DEFAULT_IMAGE = "elasticsearch";
+    private static final String DEFAULT_VERSION = "6.8.4";
 
-    private static final int ES_PORT = 9200;
-    private static final String NETWORK_ALIAS = "elasticsearch";
-
+    private final ElasticsearchContainer container;
+    private JestClient jestClient;
+    private Client client;
+    private FixtureImporter fixtureImporter = new FixtureImporter();
     private final Version version;
-    protected final ElasticsearchContainer container;
 
-    protected abstract Client client();
-    protected abstract FixtureImporter fixtureImporter();
+    public static ElasticsearchInstance create() {
+        final Properties properties = PropertyLoader.loadProperties(PROPERTIES_RESOURCE_NAME);
+
+        return create(properties.getProperty("version", DEFAULT_VERSION));
+    }
+
+    public static ElasticsearchInstance create(String versionString) {
+        final Version version = Version.valueOf(versionString);
+        final String image = imageNameFrom(version);
+
+        LOG.debug("Creating instance {}", image);
+
+        return new ElasticsearchInstance(image, version);
+    }
 
-    protected static String imageNameFrom(Version version) {
+    private static String imageNameFrom(Version version) {
         final String defaultImage = version.satisfies("^6.0.0")
                 // The OSS image only exists for 6.0.0 and later
                 ? DEFAULT_IMAGE_OSS
@@ -57,60 +86,82 @@ protected static String imageNameFrom(Version version) {
         return defaultImage + ":" + version.toString();
     }
 
-    protected ElasticsearchInstance(String image, Version version, Network network) {
+    private ElasticsearchInstance(String image, Version version) {
         this.version = version;
-
-        this.container = createContainer(image, version, network);
+        this.container = createContainer(image, version);
     }
 
-    private ElasticsearchContainer createContainer(String image, Version version, Network network) {
+    private static ElasticsearchContainer createContainer(String image, Version version) {
         if (!containersByVersion.containsKey(version)) {
-            ElasticsearchContainer container = buildContainer(image, network);
-            container.start();
-            containersByVersion.put(version, container);
+            containersByVersion.put(version, startNewContainerInstance(image));
         }
         return containersByVersion.get(version);
     }
 
-    private ElasticsearchContainer buildContainer(String image, Network network) {
-        return new ElasticsearchContainer(DockerImageName.parse(image).asCompatibleSubstituteFor("docker.elastic.co/elasticsearch/elasticsearch"))
+    private static ElasticsearchContainer startNewContainerInstance(String image) {
+        final Stopwatch sw = Stopwatch.createStarted();
+
+        final ElasticsearchContainer container = new ElasticsearchContainer(image)
                 .withReuse(true)
-                .withEnv("ES_JAVA_OPTS", "-Xms2g -Xmx2g")
+                .withEnv("ES_JAVA_OPTS", "-Xms512m -Xmx512m")
                 .withEnv("discovery.type", "single-node")
-                .withEnv("action.auto_create_index", ".watches,.triggered_watches,.watcher-history-*")
-                .withEnv("cluster.info.update.interval", "10s")
-                .withNetwork(network)
-                .withNetworkAliases(NETWORK_ALIAS)
-                .waitingFor(Wait.forHttp("/").forPort(ES_PORT));
+                .withEnv("action.auto_create_index", "false")
+                .waitingFor(Wait.forHttp("/").forPort(9200));
+        container.start();
+        LOG.debug("Started container {} in {}ms", container.getContainerInfo().getName(), sw.elapsed(TimeUnit.MILLISECONDS));
+        return container;
+    }
+
+    @Override
+    protected void before() {
+        jestClient = new JestClientProvider(
+                ImmutableList.of(URI.create("http://" + container.getHttpHostAddress())),
+                Duration.seconds(60),
+                Duration.seconds(60),
+                Duration.seconds(60),
+                1,
+                1,
+                1,
+                false,
+                null,
+                Duration.seconds(60),
+                false,
+                new ObjectMapperProvider().get()
+        ).get();
+
+        client = new Client(jestClient);
     }
 
     @Override
     protected void after() {
         cleanUp();
     }
 
-    public void cleanUp() {
-        client().cleanUp();
+    private void cleanUp() {
+        final State request = new State.Builder().withMetadata().build();
+        final JsonNode result = JestUtils.execute(jestClient, request, () -> "failed to read state").getJsonObject();
+
+        client.deleteTemplates(metadataFieldNamesFor(result, "templates"));
+        client.deleteIndices(metadataFieldNamesFor(result, "indices"));
     }
 
-    public static String internalUri() {
-        return String.format(Locale.US, "http://%s:%d", NETWORK_ALIAS, ES_PORT);
+    private String[] metadataFieldNamesFor(JsonNode result, String templates) {
+        return toArray(result.get("metadata").get(templates).fieldNames(), String.class);
     }
 
     public Version version() {
         return version;
     }
 
-    public void importFixtureResource(String resourcePath, Class<?> testClass) {
-        boolean isFullResourcePath = Paths.get(resourcePath).getNameCount() > 1;
-
-        @SuppressWarnings("UnstableApiUsage") final URL fixtureResource = isFullResourcePath
-                ? Resources.getResource(resourcePath)
-                : Resources.getResource(testClass, resourcePath);
+    public JestClient jestClient() {
+        return jestClient;
+    }
 
-        fixtureImporter().importResource(fixtureResource);
+    public Client client() {
+        return client;
+    }
 
-        // Make sure the data we just imported is visible
-        client().refreshNode();
+    FixtureImporter fixtureImporter() {
+        return fixtureImporter;
     }
 }