Add min. read-only index version compatible to DiscoveryNode

docs/reference/indices/shard-stores.asciidoc

@@ -172,8 +172,9 @@ The API returns the following response:
                             "attributes": {},
                             "roles": [...],
                             "version": "8.10.0",
-                            "min_index_version": 7000099,
-                            "max_index_version": 8100099
+                            "min_index_version": 8000099,
+                            "min_read_only_index_version": 7000099,
+                            "max_index_version": 9004000
                         },
                         "allocation_id": "2iNySv_OQVePRX-yaRH_lQ", <4>
                         "allocation" : "primary|replica|unused" <5>
@@ -193,6 +194,7 @@ The API returns the following response:
 // TESTRESPONSE[s/"roles": \[[^]]*\]/"roles": $body.$_path/]
 // TESTRESPONSE[s/"8.10.0"/\$node_version/]
 // TESTRESPONSE[s/"min_index_version": 7000099/"min_index_version": $body.$_path/]
+// TESTRESPONSE[s/"min_index_version": 7000099/"min_index_version": $body.$_path/]
 // TESTRESPONSE[s/"max_index_version": 8100099/"max_index_version": $body.$_path/]
 
 

server/src/main/java/org/elasticsearch/TransportVersions.java

@@ -139,6 +139,7 @@ static TransportVersion def(int id) {
     public static final TransportVersion SEMANTIC_QUERY_LENIENT = def(8_807_00_0);
     public static final TransportVersion ESQL_QUERY_BUILDER_IN_SEARCH_FUNCTIONS = def(8_808_00_0);
     public static final TransportVersion EQL_ALLOW_PARTIAL_SEARCH_RESULTS = def(8_809_00_0);
+    public static final TransportVersion NODE_VERSION_INFORMATION_WITH_MIN_READ_ONLY_INDEX_VERSION = def(8_810_00_0);
 
     /*
      * STOP! READ THIS FIRST! No, really,

server/src/main/java/org/elasticsearch/cluster/node/DiscoveryNode.java

@@ -37,6 +37,7 @@
 import java.util.SortedSet;
 import java.util.TreeSet;
 
+import static org.elasticsearch.TransportVersions.NODE_VERSION_INFORMATION_WITH_MIN_READ_ONLY_INDEX_VERSION;
 import static org.elasticsearch.node.NodeRoleSettings.NODE_ROLES_SETTING;
 
 /**
@@ -325,7 +326,17 @@ public DiscoveryNode(StreamInput in) throws IOException {
             }
         }
         this.roles = Collections.unmodifiableSortedSet(roles);
-        versionInfo = new VersionInformation(Version.readVersion(in), IndexVersion.readVersion(in), IndexVersion.readVersion(in));
+        Version version = Version.readVersion(in);
+        IndexVersion minIndexVersion = IndexVersion.readVersion(in);
+        IndexVersion minReadOnlyIndexVersion;
+        if (in.getTransportVersion().onOrAfter(NODE_VERSION_INFORMATION_WITH_MIN_READ_ONLY_INDEX_VERSION)) {
+            minReadOnlyIndexVersion = IndexVersion.readVersion(in);
+        } else {
+            minReadOnlyIndexVersion = minIndexVersion;
+
+        }
+        IndexVersion maxIndexVersion = IndexVersion.readVersion(in);
+        versionInfo = new VersionInformation(version, minIndexVersion, minReadOnlyIndexVersion, maxIndexVersion);
         if (in.getTransportVersion().onOrAfter(EXTERNAL_ID_VERSION)) {
             this.externalId = readStringLiteral.read(in);
         } else {
@@ -360,6 +371,9 @@ public void writeTo(StreamOutput out) throws IOException {
         });
         Version.writeVersion(versionInfo.nodeVersion(), out);
         IndexVersion.writeVersion(versionInfo.minIndexVersion(), out);
+        if (out.getTransportVersion().onOrAfter(NODE_VERSION_INFORMATION_WITH_MIN_READ_ONLY_INDEX_VERSION)) {
+            IndexVersion.writeVersion(versionInfo.minReadOnlyIndexVersion(), out);
+        }
         IndexVersion.writeVersion(versionInfo.maxIndexVersion(), out);
         if (out.getTransportVersion().onOrAfter(EXTERNAL_ID_VERSION)) {
             out.writeString(externalId);
@@ -478,6 +492,10 @@ public IndexVersion getMinIndexVersion() {
         return versionInfo.minIndexVersion();
     }
 
+    public IndexVersion getMinReadOnlyIndexVersion() {
+        return versionInfo.minReadOnlyIndexVersion();
+    }
+
     public IndexVersion getMaxIndexVersion() {
         return versionInfo.maxIndexVersion();
     }
@@ -577,6 +595,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.endArray();
         builder.field("version", versionInfo.buildVersion().toString());
         builder.field("min_index_version", versionInfo.minIndexVersion());
+        builder.field("min_read_only_index_version", versionInfo.minReadOnlyIndexVersion());
         builder.field("max_index_version", versionInfo.maxIndexVersion());
         builder.endObject();
         return builder;

server/src/main/java/org/elasticsearch/cluster/node/DiscoveryNodes.java

@@ -69,6 +69,7 @@ public class DiscoveryNodes implements Iterable<DiscoveryNode>, SimpleDiffable<D
     private final Version minNodeVersion;
     private final IndexVersion maxDataNodeCompatibleIndexVersion;
     private final IndexVersion minSupportedIndexVersion;
+    private final IndexVersion minReadOnlySupportedIndexVersion;
 
     private final Map<String, Set<String>> tiersToNodeIds;
 
@@ -84,6 +85,7 @@ private DiscoveryNodes(
         Version minNodeVersion,
         IndexVersion maxDataNodeCompatibleIndexVersion,
         IndexVersion minSupportedIndexVersion,
+        IndexVersion minReadOnlySupportedIndexVersion,
         Map<String, Set<String>> tiersToNodeIds
     ) {
         this.nodeLeftGeneration = nodeLeftGeneration;
@@ -100,6 +102,8 @@ private DiscoveryNodes(
         this.maxNodeVersion = maxNodeVersion;
         this.maxDataNodeCompatibleIndexVersion = maxDataNodeCompatibleIndexVersion;
         this.minSupportedIndexVersion = minSupportedIndexVersion;
+        this.minReadOnlySupportedIndexVersion = minReadOnlySupportedIndexVersion;
+        assert minReadOnlySupportedIndexVersion.onOrBefore(minSupportedIndexVersion);
         assert (localNodeId == null) == (localNode == null);
         this.tiersToNodeIds = tiersToNodeIds;
     }
@@ -118,6 +122,7 @@ public DiscoveryNodes withMasterNodeId(@Nullable String masterNodeId) {
             minNodeVersion,
             maxDataNodeCompatibleIndexVersion,
             minSupportedIndexVersion,
+            minReadOnlySupportedIndexVersion,
             tiersToNodeIds
         );
     }
@@ -374,6 +379,13 @@ public IndexVersion getMinSupportedIndexVersion() {
         return minSupportedIndexVersion;
     }
 
+    /**
+     * Returns the minimum index version for read-only indices supported by all nodes in the cluster
+     */
+    public IndexVersion getMinReadOnlySupportedIndexVersion() {
+        return minReadOnlySupportedIndexVersion;
+    }
+
     /**
      * Return the node-left generation, which is the number of times the cluster membership has been updated by removing one or more nodes.
      * <p>
@@ -840,6 +852,7 @@ public DiscoveryNodes build() {
             Version maxNodeVersion = null;
             IndexVersion maxDataNodeCompatibleIndexVersion = null;
             IndexVersion minSupportedIndexVersion = null;
+            IndexVersion minReadOnlySupportedIndexVersion = null;
             for (Map.Entry<String, DiscoveryNode> nodeEntry : nodes.entrySet()) {
                 DiscoveryNode discoNode = nodeEntry.getValue();
                 Version version = discoNode.getVersion();
@@ -849,6 +862,7 @@ public DiscoveryNodes build() {
                 minNodeVersion = min(minNodeVersion, version);
                 maxNodeVersion = max(maxNodeVersion, version);
                 minSupportedIndexVersion = max(minSupportedIndexVersion, discoNode.getMinIndexVersion());
+                minReadOnlySupportedIndexVersion = max(minReadOnlySupportedIndexVersion, discoNode.getMinReadOnlyIndexVersion());
             }
 
             final long newNodeLeftGeneration;
@@ -881,6 +895,7 @@ public DiscoveryNodes build() {
                 Objects.requireNonNullElse(minNodeVersion, Version.CURRENT.minimumCompatibilityVersion()),
                 Objects.requireNonNullElse(maxDataNodeCompatibleIndexVersion, IndexVersion.current()),
                 Objects.requireNonNullElse(minSupportedIndexVersion, IndexVersions.MINIMUM_COMPATIBLE),
+                Objects.requireNonNullElse(minReadOnlySupportedIndexVersion, IndexVersions.MINIMUM_READONLY_COMPATIBLE),
                 computeTiersToNodesMap(dataNodes)
             );
         }

server/src/main/java/org/elasticsearch/cluster/node/VersionInformation.java

@@ -18,32 +18,42 @@
 
 /**
  * Represents the versions of various aspects of an Elasticsearch node.
- * @param buildVersion      The node {@link BuildVersion}
- * @param minIndexVersion   The minimum {@link IndexVersion} supported by this node
- * @param maxIndexVersion   The maximum {@link IndexVersion} supported by this node
+ * @param buildVersion              The node {@link BuildVersion}
+ * @param minIndexVersion           The minimum {@link IndexVersion} supported by this node
+ * @param minReadOnlyIndexVersion   The minimum {@link IndexVersion} for read-only indices supported by this node
+ * @param maxIndexVersion           The maximum {@link IndexVersion} supported by this node
  */
 public record VersionInformation(
     BuildVersion buildVersion,
     Version nodeVersion,
     IndexVersion minIndexVersion,
+    IndexVersion minReadOnlyIndexVersion,
     IndexVersion maxIndexVersion
 ) {
 
     public static final VersionInformation CURRENT = new VersionInformation(
         BuildVersion.current(),
         IndexVersions.MINIMUM_COMPATIBLE,
+        IndexVersions.MINIMUM_READONLY_COMPATIBLE,
         IndexVersion.current()
     );
 
     public VersionInformation {
         Objects.requireNonNull(buildVersion);
         Objects.requireNonNull(nodeVersion);
         Objects.requireNonNull(minIndexVersion);
+        Objects.requireNonNull(minReadOnlyIndexVersion);
         Objects.requireNonNull(maxIndexVersion);
+        assert minReadOnlyIndexVersion.onOrBefore(minIndexVersion) : minReadOnlyIndexVersion + " > " + minIndexVersion;
     }
 
-    public VersionInformation(BuildVersion version, IndexVersion minIndexVersion, IndexVersion maxIndexVersion) {
-        this(version, Version.CURRENT, minIndexVersion, maxIndexVersion);
+    public VersionInformation(
+        BuildVersion version,
+        IndexVersion minIndexVersion,
+        IndexVersion minReadOnlyIndexVersion,
+        IndexVersion maxIndexVersion
+    ) {
+        this(version, Version.CURRENT, minIndexVersion, minReadOnlyIndexVersion, maxIndexVersion);
         /*
          * Whilst DiscoveryNode.getVersion exists, we need to be able to get a Version from VersionInfo
          * This needs to be consistent - on serverless, BuildVersion has an id of -1, which translates
@@ -57,7 +67,17 @@ public VersionInformation(BuildVersion version, IndexVersion minIndexVersion, In
 
     @Deprecated
     public VersionInformation(Version version, IndexVersion minIndexVersion, IndexVersion maxIndexVersion) {
-        this(BuildVersion.fromVersionId(version.id()), version, minIndexVersion, maxIndexVersion);
+        this(version, minIndexVersion, minIndexVersion, maxIndexVersion);
+    }
+
+    @Deprecated
+    public VersionInformation(
+        Version version,
+        IndexVersion minIndexVersion,
+        IndexVersion minReadOnlyIndexVersion,
+        IndexVersion maxIndexVersion
+    ) {
+        this(BuildVersion.fromVersionId(version.id()), version, minIndexVersion, minReadOnlyIndexVersion, maxIndexVersion);
     }
 
     @Deprecated

server/src/main/java/org/elasticsearch/discovery/HandshakingTransportAddressConnector.java

@@ -110,6 +110,7 @@ private void openProbeConnection(ActionListener<Transport.Connection> listener)
                     new VersionInformation(
                         Version.CURRENT.minimumCompatibilityVersion(),
                         IndexVersions.MINIMUM_COMPATIBLE,
+                        IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                         IndexVersion.current()
                     )
                 ),

server/src/main/java/org/elasticsearch/transport/ProxyConnectionStrategy.java

@@ -303,6 +303,7 @@ public void onFailure(Exception e) {
                     new VersionInformation(
                         Version.CURRENT.minimumCompatibilityVersion(),
                         IndexVersions.MINIMUM_COMPATIBLE,
+                        IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                         IndexVersion.current()
                     )
                 );

server/src/main/java/org/elasticsearch/transport/SniffConnectionStrategy.java

@@ -505,6 +505,7 @@ private static DiscoveryNode resolveSeedNode(String clusterAlias, String address
         var seedVersion = new VersionInformation(
             Version.CURRENT.minimumCompatibilityVersion(),
             IndexVersions.MINIMUM_COMPATIBLE,
+            IndexVersions.MINIMUM_READONLY_COMPATIBLE,
             IndexVersion.current()
         );
         if (proxyAddress == null || proxyAddress.isEmpty()) {

server/src/test/java/org/elasticsearch/action/admin/cluster/reroute/ClusterRerouteResponseTests.java

@@ -127,6 +127,7 @@ public void testToXContentWithDeprecatedClusterState() {
                             ],
                             "version": "%s",
                             "min_index_version": %s,
+                            "min_read_only_index_version": %s,
                             "max_index_version": %s
                           }
                         },
@@ -218,6 +219,7 @@ public void testToXContentWithDeprecatedClusterState() {
                 clusterState.getNodes().get("node0").getEphemeralId(),
                 Version.CURRENT,
                 IndexVersions.MINIMUM_COMPATIBLE,
+                IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                 IndexVersion.current(),
                 IndexVersion.current(),
                 IndexVersion.current()

server/src/test/java/org/elasticsearch/cluster/ClusterStateTests.java

@@ -213,6 +213,7 @@ public void testToXContent() throws IOException {
                               ],
                               "version": "%s",
                               "min_index_version":%s,
+                              "min_read_only_index_version":%s,
                               "max_index_version":%s
                             }
                           },
@@ -389,6 +390,7 @@ public void testToXContent() throws IOException {
                     ephemeralId,
                     Version.CURRENT,
                     IndexVersions.MINIMUM_COMPATIBLE,
+                    IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                     IndexVersion.current(),
                     TransportVersion.current(),
                     IndexVersion.current(),
@@ -488,6 +490,7 @@ public void testToXContent_FlatSettingTrue_ReduceMappingFalse() throws IOExcepti
                           ],
                           "version" : "%s",
                           "min_index_version" : %s,
+                          "min_read_only_index_version" : %s,
                           "max_index_version" : %s
                         }
                       },
@@ -663,6 +666,7 @@ public void testToXContent_FlatSettingTrue_ReduceMappingFalse() throws IOExcepti
                 ephemeralId,
                 Version.CURRENT,
                 IndexVersions.MINIMUM_COMPATIBLE,
+                IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                 IndexVersion.current(),
                 TransportVersion.current(),
                 IndexVersion.current(),
@@ -762,6 +766,7 @@ public void testToXContent_FlatSettingFalse_ReduceMappingTrue() throws IOExcepti
                           ],
                           "version" : "%s",
                           "min_index_version" : %s,
+                          "min_read_only_index_version" : %s,
                           "max_index_version" : %s
                         }
                       },
@@ -943,6 +948,7 @@ public void testToXContent_FlatSettingFalse_ReduceMappingTrue() throws IOExcepti
                 ephemeralId,
                 Version.CURRENT,
                 IndexVersions.MINIMUM_COMPATIBLE,
+                IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                 IndexVersion.current(),
                 TransportVersion.current(),
                 IndexVersion.current(),

server/src/test/java/org/elasticsearch/cluster/node/DiscoveryNodeTests.java

@@ -31,6 +31,8 @@
 import static java.util.Collections.emptySet;
 import static org.elasticsearch.test.NodeRoles.nonRemoteClusterClientNode;
 import static org.elasticsearch.test.NodeRoles.remoteClusterClientNode;
+import static org.elasticsearch.test.TransportVersionUtils.getPreviousVersion;
+import static org.elasticsearch.test.TransportVersionUtils.randomVersionBetween;
 import static org.hamcrest.Matchers.allOf;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
@@ -221,13 +223,15 @@ public void testDiscoveryNodeToXContent() {
                             ],
                             "version" : "%s",
                             "min_index_version" : %s,
+                            "min_read_only_index_version" : %s,
                             "max_index_version" : %s
                           }
                         }""",
                     transportAddress,
                     withExternalId ? "test-external-id" : "test-name",
                     Version.CURRENT,
                     IndexVersions.MINIMUM_COMPATIBLE,
+                    IndexVersions.MINIMUM_READONLY_COMPATIBLE,
                     IndexVersion.current()
                 )
             )
@@ -250,4 +254,61 @@ public void testDiscoveryNodeToString() {
         assertThat(toString, containsString("{" + node.getBuildVersion() + "}"));
         assertThat(toString, containsString("{test-attr=val}"));// attributes
     }
+
+    public void testDiscoveryNodeMinReadOnlyVersionSerialization() throws Exception {
+        var node = DiscoveryNodeUtils.create("_id", buildNewFakeTransportAddress(), VersionInformation.CURRENT);
+
+        {
+            try (var out = new BytesStreamOutput()) {
+                out.setTransportVersion(TransportVersion.current());
+                node.writeTo(out);
+
+                try (var in = StreamInput.wrap(out.bytes().array())) {
+                    in.setTransportVersion(TransportVersion.current());
+
+                    var deserialized = new DiscoveryNode(in);
+                    assertThat(deserialized.getId(), equalTo(node.getId()));
+                    assertThat(deserialized.getAddress(), equalTo(node.getAddress()));
+                    assertThat(deserialized.getMinIndexVersion(), equalTo(node.getMinIndexVersion()));
+                    assertThat(deserialized.getMaxIndexVersion(), equalTo(node.getMaxIndexVersion()));
+                    assertThat(deserialized.getMinReadOnlyIndexVersion(), equalTo(node.getMinReadOnlyIndexVersion()));
+                    assertThat(deserialized.getVersionInformation(), equalTo(node.getVersionInformation()));
+                }
+            }
+        }
+
+        {
+            var oldVersion = randomVersionBetween(
+                random(),
+                TransportVersions.MINIMUM_COMPATIBLE,
+                getPreviousVersion(TransportVersions.NODE_VERSION_INFORMATION_WITH_MIN_READ_ONLY_INDEX_VERSION)
+            );
+            try (var out = new BytesStreamOutput()) {
+                out.setTransportVersion(oldVersion);
+                node.writeTo(out);
+
+                try (var in = StreamInput.wrap(out.bytes().array())) {
+                    in.setTransportVersion(oldVersion);
+
+                    var deserialized = new DiscoveryNode(in);
+                    assertThat(deserialized.getId(), equalTo(node.getId()));
+                    assertThat(deserialized.getAddress(), equalTo(node.getAddress()));
+                    assertThat(deserialized.getMinIndexVersion(), equalTo(node.getMinIndexVersion()));
+                    assertThat(deserialized.getMaxIndexVersion(), equalTo(node.getMaxIndexVersion()));
+                    assertThat(deserialized.getMinReadOnlyIndexVersion(), equalTo(node.getMinIndexVersion()));
+                    assertThat(
+                        deserialized.getVersionInformation(),
+                        equalTo(
+                            new VersionInformation(
+                                node.getBuildVersion(),
+                                node.getMinIndexVersion(),
+                                node.getMinIndexVersion(),
+                                node.getMaxIndexVersion()
+                            )
+                        )
+                    );
+                }
+            }
+        }
+    }
 }