Archive-Index upgrade compatibility

server/src/main/java/org/elasticsearch/cluster/coordination/NodeJoinExecutor.java

@@ -376,14 +376,22 @@ public static void ensureIndexCompatibility(IndexVersion minSupportedVersion, In
                         + maxSupportedVersion.toReleaseVersion()
                 );
             }
-            if (idxMetadata.getCompatibilityVersion().before(minSupportedVersion)) {
+
+            IndexVersion minVersion = minSupportedVersion;
+
+            if (idxMetadata.getCreationVersion().equals(idxMetadata.getCompatibilityVersion()) == false
+                && idxMetadata.getCompatibilityVersion().onOrAfter(IndexVersions.MINIMUM_READONLY_COMPATIBLE)) {
+                minVersion = IndexVersions.MINIMUM_READONLY_COMPATIBLE;
+            }
+
+            if (idxMetadata.getCompatibilityVersion().before(minVersion)) {
                 throw new IllegalStateException(
                     "index "
                         + idxMetadata.getIndex()
                         + " version not supported: "
                         + idxMetadata.getCompatibilityVersion().toReleaseVersion()
                         + " minimum compatible index version is: "
-                        + minSupportedVersion.toReleaseVersion()
+                        + minVersion.toReleaseVersion()
                 );
             }
         }

server/src/main/java/org/elasticsearch/cluster/metadata/IndexMetadataVerifier.java

@@ -22,6 +22,7 @@
 import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
 import org.elasticsearch.index.IndexSettings;
 import org.elasticsearch.index.IndexVersion;
+import org.elasticsearch.index.IndexVersions;
 import org.elasticsearch.index.analysis.AnalyzerScope;
 import org.elasticsearch.index.analysis.NamedAnalyzer;
 import org.elasticsearch.index.mapper.MapperMetrics;
@@ -109,6 +110,13 @@ public IndexMetadata verifyIndexMetadata(IndexMetadata indexMetadata, IndexVersi
      * previous major version.
      */
     private static void checkSupportedVersion(IndexMetadata indexMetadata, IndexVersion minimumIndexCompatibilityVersion) {
+        // This is for archive indices support of N-2. This is temporal and eventually should be deleted when
+        // the distrib team concludes their work.
+        if (indexMetadata.getCreationVersion().equals(indexMetadata.getCompatibilityVersion()) == false
+            && indexMetadata.getCompatibilityVersion().onOrAfter(IndexVersions.MINIMUM_READONLY_COMPATIBLE)) {
+            return;
+        }
+
         boolean isSupportedVersion = indexMetadata.getCompatibilityVersion().onOrAfter(minimumIndexCompatibilityVersion);
         if (isSupportedVersion == false) {
             throw new IllegalStateException(

x-pack/qa/repository-old-versions-compatibility/build.gradle

@@ -0,0 +1,25 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+apply plugin: 'elasticsearch.internal-java-rest-test'
+apply plugin: 'elasticsearch.internal-test-artifact'
+apply plugin: 'elasticsearch.bwc-test'
+
+buildParams.bwcVersions.withLatestReadOnlyIndexCompatible { bwcVersion ->
+  tasks.named("javaRestTest").configure {
+    systemProperty("tests.minimum.index.compatible", bwcVersion)
+    usesBwcDistribution(bwcVersion)
+    enabled = true
+  }
+}
+
+tasks.withType(Test).configureEach {
+  // CI doesn't like it when there's multiple clusters running at once
+  maxParallelForks = 1
+}
+

x-pack/qa/repository-old-versions-compatibility/src/javaRestTest/java/org/elasticsearch/lucene/AbstractArchiveIndexCompatibilityTestCase.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.lucene;
+
+import com.carrotsearch.randomizedtesting.TestMethodAndParams;
+import com.carrotsearch.randomizedtesting.annotations.Name;
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+import com.carrotsearch.randomizedtesting.annotations.TestCaseOrdering;
+
+import org.elasticsearch.client.Request;
+import org.elasticsearch.test.cluster.ElasticsearchCluster;
+import org.elasticsearch.test.cluster.local.LocalClusterConfigProvider;
+import org.elasticsearch.test.cluster.local.distribution.DistributionType;
+import org.elasticsearch.test.cluster.util.Version;
+import org.elasticsearch.test.rest.ESRestTestCase;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.rules.RuleChain;
+import org.junit.rules.TemporaryFolder;
+import org.junit.rules.TestRule;
+
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+import static org.elasticsearch.test.cluster.util.Version.CURRENT;
+import static org.elasticsearch.test.cluster.util.Version.fromString;
+import static org.elasticsearch.test.rest.ObjectPath.createFromResponse;
+import static org.hamcrest.Matchers.notNullValue;
+
+@TestCaseOrdering(AbstractArchiveIndexCompatibilityTestCase.TestCaseOrdering.class)
+public abstract class AbstractArchiveIndexCompatibilityTestCase extends ESRestTestCase {
+
+    protected static final Version VERSION_MINUS_1 = fromString(System.getProperty("tests.minimum.wire.compatible"));
+    protected static final Version VERSION_CURRENT = CURRENT;
+
+    protected static TemporaryFolder REPOSITORY_PATH = new TemporaryFolder();
+
+    protected static LocalClusterConfigProvider clusterConfig = c -> {};
+    private static ElasticsearchCluster cluster = ElasticsearchCluster.local()
+        .distribution(DistributionType.DEFAULT)
+        .version(VERSION_MINUS_1)
+        .nodes(2)
+        .setting("xpack.security.enabled", "false")
+        .setting("xpack.ml.enabled", "false")
+        .setting("path.repo", () -> REPOSITORY_PATH.getRoot().getPath())
+        .apply(() -> clusterConfig)
+        .build();
+
+    @ClassRule
+    public static TestRule ruleChain = RuleChain.outerRule(REPOSITORY_PATH).around(cluster);
+
+    private static boolean upgradeFailed = false;
+
+    private final Version clusterVersion;
+
+    public AbstractArchiveIndexCompatibilityTestCase(@Name("cluster") Version clusterVersion) {
+        this.clusterVersion = clusterVersion;
+    }
+
+    @ParametersFactory
+    public static Iterable<Object[]> parameters() {
+        return Stream.of(VERSION_MINUS_1, CURRENT).map(v -> new Object[] { v }).toList();
+    }
+
+    @Override
+    protected String getTestRestCluster() {
+        return cluster.getHttpAddresses();
+    }
+
+    @Override
+    protected boolean preserveClusterUponCompletion() {
+        return true;
+    }
+
+    @Before
+    public void maybeUpgrade() throws Exception {
+        // We want to use this test suite for the V9 upgrade, but we are not fully committed to necessarily having N-2 support
+        // in V10, so we add a check here to ensure we'll revisit this decision once V10 exists.
+        // assertThat("Explicit check that N-2 version is Elasticsearch 7", VERSION_MINUS_2.getMajor(), equalTo(7));
+
+        var currentVersion = clusterVersion();
+        if (currentVersion.before(clusterVersion)) {
+            try {
+                cluster.upgradeToVersion(clusterVersion);
+                closeClients();
+                initClient();
+            } catch (Exception e) {
+                upgradeFailed = true;
+                throw e;
+            }
+        }
+
+        // Skip remaining tests if upgrade failed
+        assumeFalse("Cluster upgrade failed", upgradeFailed);
+    }
+
+    protected static Version clusterVersion() throws Exception {
+        var response = assertOK(client().performRequest(new Request("GET", "/")));
+        var responseBody = createFromResponse(response);
+        var version = Version.fromString(responseBody.evaluate("version.number").toString());
+        assertThat("Failed to retrieve cluster version", version, notNullValue());
+        return version;
+    }
+
+    /**
+     * Execute the test suite with the parameters provided by the {@link #parameters()} in version order.
+     */
+    public static class TestCaseOrdering implements Comparator<TestMethodAndParams> {
+        @Override
+        public int compare(TestMethodAndParams o1, TestMethodAndParams o2) {
+            var version1 = (Version) o1.getInstanceArguments().get(0);
+            var version2 = (Version) o2.getInstanceArguments().get(0);
+            return version1.compareTo(version2);
+        }
+    }
+}

x-pack/qa/repository-old-versions-compatibility/src/javaRestTest/java/org/elasticsearch/lucene/ArchiveIndexCompatibilityIT.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.lucene;
+
+import org.apache.http.util.EntityUtils;
+import org.elasticsearch.client.Request;
+import org.elasticsearch.client.Response;
+import org.elasticsearch.client.RestClient;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.repositories.fs.FsRepository;
+import org.elasticsearch.test.cluster.util.Version;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+import java.util.stream.IntStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import static org.elasticsearch.test.rest.ObjectPath.createFromResponse;
+
+public class ArchiveIndexCompatibilityIT extends AbstractArchiveIndexCompatibilityTestCase {
+
+    static {
+        clusterConfig = config -> config.setting("xpack.license.self_generated.type", "trial");
+    }
+
+    public ArchiveIndexCompatibilityIT(Version version) {
+        super(version);
+    }
+
+    public void testArchiveIndicesV5() throws Exception {
+        verifyArchiveIndexCompatibility("5");
+    }
+
+    public void verifyArchiveIndexCompatibility(String version) throws Exception {
+        final String repository = "repository";
+        final String snapshot = "snapshot";
+        final String index = "index";
+
+        String repositoryPath = REPOSITORY_PATH.getRoot().getPath();
+
+        if (VERSION_MINUS_1.equals(clusterVersion())) {
+            assertTrue(getIndices(client()).isEmpty());
+
+            copySnapshotFromResources(repositoryPath, version);
+
+            registerRepository(client(), repository, FsRepository.TYPE, true, Settings.builder().put("location", repositoryPath).build());
+
+            restoreSnapshot(client(), repository, snapshot, index);
+            assertTrue(getIndices(client()).contains(index));
+
+            return;
+        }
+
+        if (VERSION_CURRENT.equals(clusterVersion())) {
+            assertTrue(getIndices(client()).contains(index));
+        }
+    }
+
+    private void copySnapshotFromResources(String repositoryPath, String version) throws IOException, URISyntaxException {
+        Path zipFilePath = Paths.get(
+            Objects.requireNonNull(getClass().getClassLoader().getResource("snapshot_v" + version + ".zip")).toURI()
+        );
+        unzip(zipFilePath, Paths.get(repositoryPath));
+    }
+
+    public static void unzip(Path zipFilePath, Path outputDir) throws IOException {
+        try (ZipInputStream zipIn = new ZipInputStream(Files.newInputStream(zipFilePath))) {
+            ZipEntry entry;
+            while ((entry = zipIn.getNextEntry()) != null) {
+                Path outputPath = outputDir.resolve(entry.getName());
+                if (entry.isDirectory()) {
+                    Files.createDirectories(outputPath);
+                } else {
+                    Files.createDirectories(outputPath.getParent());
+                    try (OutputStream out = Files.newOutputStream(outputPath)) {
+                        byte[] buffer = new byte[1024];
+                        int len;
+                        while ((len = zipIn.read(buffer)) > 0) {
+                            out.write(buffer, 0, len);
+                        }
+                    }
+                }
+                zipIn.closeEntry();
+            }
+        }
+    }
+
+    private void addDocuments(RestClient client, String index, int numDocs) throws Exception {
+        final var bulks = new StringBuilder();
+        IntStream.range(0, numDocs).forEach(n -> bulks.append(Strings.format("""
+            {"index":{"_id":"%s","_index":"%s"}}
+            {"test":"test"}
+            """, n, index)));
+
+        var bulkRequest = new Request("POST", "/_bulk");
+        bulkRequest.setJsonEntity(bulks.toString());
+        var bulkResponse = client.performRequest(bulkRequest);
+        assertOK(bulkResponse);
+    }
+
+    private void restoreSnapshot(RestClient client, String repository, String snapshot, String index) throws Exception {
+        var request = new Request("POST", "/_snapshot/" + repository + "/" + snapshot + "/_restore");
+        request.addParameter("wait_for_completion", "true");
+        request.setJsonEntity(Strings.format("""
+            {
+              "indices": "%s",
+              "include_global_state": false,
+              "rename_pattern": "(.+)",
+              "include_aliases": false
+            }""", index));
+        createFromResponse(client.performRequest(request));
+    }
+
+    private String getIndices(RestClient client) throws IOException {
+        final Request request = new Request("GET", "_cat/indices");
+        Response response = client.performRequest(request);
+        return EntityUtils.toString(response.getEntity());
+    }
+}