Add term and config to cluster state

build.gradle

@@ -173,8 +173,8 @@ task verifyVersions {
  * the enabled state of every bwc task. It should be set back to true
  * after the backport of the backcompat code is complete.
  */
-final boolean bwc_tests_enabled = true
-final String bwc_tests_disabled_issue = "" /* place a PR link here when committing bwc changes */
+final boolean bwc_tests_enabled = false
+final String bwc_tests_disabled_issue = "https://github.com/elastic/elasticsearch/issues/32006" // BWC handled at a later time
 if (bwc_tests_enabled == false) {
   if (bwc_tests_disabled_issue.isEmpty()) {
     throw new GradleException("bwc_tests_disabled_issue must be set when bwc_tests_enabled == false")

server/src/main/java/org/elasticsearch/action/admin/cluster/state/TransportClusterStateAction.java

@@ -76,8 +76,11 @@ protected void masterOperation(final ClusterStateRequest request, final ClusterS
         ClusterState currentState = clusterService.state();
         logger.trace("Serving cluster state request using version {}", currentState.version());
         ClusterState.Builder builder = ClusterState.builder(currentState.getClusterName());
+        builder.term(currentState.term());
         builder.version(currentState.version());
         builder.stateUUID(currentState.stateUUID());
+        builder.lastCommittedConfiguration(currentState.getLastCommittedConfiguration());
+        builder.lastAcceptedConfiguration(currentState.getLastAcceptedConfiguration());
         if (request.nodes()) {
             builder.nodes(currentState.nodes());
         }

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

@@ -70,8 +70,11 @@ public void testToXContent() throws IOException {
                     "  \"acknowledged\" : true,\n" +
                     "  \"state\" : {\n" +
                     "    \"cluster_uuid\" : \"_na_\",\n" +
+                    "    \"term\" : 0,\n" +
                     "    \"version\" : 0,\n" +
                     "    \"state_uuid\" : \"" + clusterState.stateUUID() + "\",\n" +
+                    "    \"last_committed_config\" : [ ],\n" +
+                    "    \"last_accepted_config\" : [ ],\n" +
                     "    \"master_node\" : \"node0\",\n" +
                     "    \"blocks\" : { },\n" +
                     "    \"nodes\" : {\n" +
@@ -138,8 +141,11 @@ public void testToXContent() throws IOException {
                     "  \"acknowledged\" : true,\n" +
                     "  \"state\" : {\n" +
                     "    \"cluster_uuid\" : \"_na_\",\n" +
+                    "    \"term\" : 0,\n" +
                     "    \"version\" : 0,\n" +
                     "    \"state_uuid\" : \"" + clusterState.stateUUID() + "\",\n" +
+                    "    \"last_committed_config\" : [ ],\n" +
+                    "    \"last_accepted_config\" : [ ],\n" +
                     "    \"master_node\" : \"node0\"\n" +
                     "  },\n" +
                     "  \"explanations\" : [\n" +

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

@@ -97,7 +97,7 @@ public void testClusterStateDiffSerialization() throws Exception {
                 if (i > 0) {
                     clusterState = builder.build();
                 }
-                switch (randomInt(4)) {
+                switch (randomInt(5)) {
                     case 0:
                         builder = randomNodes(clusterState);
                         break;
@@ -113,11 +113,14 @@ public void testClusterStateDiffSerialization() throws Exception {
                     case 4:
                         builder = randomMetaDataChanges(clusterState);
                         break;
+                    case 5:
+                        builder = randomVotingConfiguration(clusterState);
+                        break;
                     default:
                         throw new IllegalArgumentException("Shouldn't be here");
                 }
             }
-            clusterState = builder.incrementVersion().build();
+            clusterState = builder.incrementVersion().term(randomLong()).build();
 
             if (randomIntBetween(0, 10) < 1) {
                 // Update cluster state via full serialization from time to time
@@ -141,7 +144,10 @@ public void testClusterStateDiffSerialization() throws Exception {
             try {
                 // Check non-diffable elements
                 assertThat(clusterStateFromDiffs.version(), equalTo(clusterState.version()));
+                assertThat(clusterStateFromDiffs.term(), equalTo(clusterState.term()));
                 assertThat(clusterStateFromDiffs.stateUUID(), equalTo(clusterState.stateUUID()));
+                assertThat(clusterStateFromDiffs.getLastAcceptedConfiguration(), equalTo(clusterState.getLastAcceptedConfiguration()));
+                assertThat(clusterStateFromDiffs.getLastCommittedConfiguration(), equalTo(clusterState.getLastCommittedConfiguration()));
 
                 // Check nodes
                 assertThat(clusterStateFromDiffs.nodes().getNodes(), equalTo(clusterState.nodes().getNodes()));
@@ -190,6 +196,20 @@ public void testClusterStateDiffSerialization() throws Exception {
 
     }
 
+    private ClusterState.Builder randomVotingConfiguration(ClusterState clusterState) {
+        ClusterState.Builder builder = ClusterState.builder(clusterState);
+        if (randomBoolean()) {
+            builder.lastCommittedConfiguration(
+                new ClusterState.VotingConfiguration(Sets.newHashSet(generateRandomStringArray(10, 10, false))));
+        }
+        if (randomBoolean()) {
+            builder.lastAcceptedConfiguration(
+                new ClusterState.VotingConfiguration(Sets.newHashSet(generateRandomStringArray(10, 10, false))));
+        }
+
+        return builder;
+    }
+
     /**
      * Randomly updates nodes in the cluster state
      */

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

@@ -19,10 +19,18 @@
 package org.elasticsearch.cluster;
 
 import org.elasticsearch.Version;
+import org.elasticsearch.cluster.ClusterState.VotingConfiguration;
 import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.cluster.node.DiscoveryNodes;
+import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.util.set.Sets;
 import org.elasticsearch.test.ESTestCase;
+import org.elasticsearch.test.EqualsHashCodeTestUtils;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
@@ -55,6 +63,70 @@ public void testSupersedes() {
 
         // state from the same master compare by version
         assertThat(withMaster1a.supersedes(withMaster1b), equalTo(withMaster1a.version() > withMaster1b.version()));
+    }
+
+    public void testVotingConfiguration() {
+        VotingConfiguration config0 = new VotingConfiguration(Sets.newHashSet());
+        assertThat(config0, equalTo(VotingConfiguration.EMPTY_CONFIG));
+        assertThat(config0.getNodeIds(), equalTo(Sets.newHashSet()));
+        assertThat(config0.isEmpty(), equalTo(true));
+        assertThat(config0.hasQuorum(Sets.newHashSet()), equalTo(false));
+        assertThat(config0.hasQuorum(Sets.newHashSet("id1")), equalTo(false));
+
+        VotingConfiguration config1 = new VotingConfiguration(Sets.newHashSet("id1"));
+        assertThat(config1.getNodeIds(), equalTo(Sets.newHashSet("id1")));
+        assertThat(config1.isEmpty(), equalTo(false));
+        assertThat(config1.hasQuorum(Sets.newHashSet("id1")), equalTo(true));
+        assertThat(config1.hasQuorum(Sets.newHashSet("id1", "id2")), equalTo(true));
+        assertThat(config1.hasQuorum(Sets.newHashSet("id2")), equalTo(false));
+        assertThat(config1.hasQuorum(Sets.newHashSet()), equalTo(false));
+
+        VotingConfiguration config2 = new VotingConfiguration(Sets.newHashSet("id1", "id2"));
+        assertThat(config2.getNodeIds(), equalTo(Sets.newHashSet("id1", "id2")));
+        assertThat(config2.isEmpty(), equalTo(false));
+        assertThat(config2.hasQuorum(Sets.newHashSet("id1", "id2")), equalTo(true));
+        assertThat(config2.hasQuorum(Sets.newHashSet("id1", "id2", "id3")), equalTo(true));
+        assertThat(config2.hasQuorum(Sets.newHashSet("id1")), equalTo(false));
+        assertThat(config2.hasQuorum(Sets.newHashSet("id2")), equalTo(false));
+        assertThat(config2.hasQuorum(Sets.newHashSet("id3")), equalTo(false));
+        assertThat(config2.hasQuorum(Sets.newHashSet("id1", "id3")), equalTo(false));
+        assertThat(config2.hasQuorum(Sets.newHashSet()), equalTo(false));
+
+        VotingConfiguration config3 = new VotingConfiguration(Sets.newHashSet("id1", "id2", "id3"));
+        assertThat(config3.getNodeIds(), equalTo(Sets.newHashSet("id1", "id2", "id3")));
+        assertThat(config3.isEmpty(), equalTo(false));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1", "id2")), equalTo(true));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id2", "id3")), equalTo(true));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1", "id3")), equalTo(true));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1", "id2", "id3")), equalTo(true));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1", "id2", "id4")), equalTo(true));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1")), equalTo(false));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id2")), equalTo(false));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id3")), equalTo(false));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1", "id4")), equalTo(false));
+        assertThat(config3.hasQuorum(Sets.newHashSet("id1", "id4", "id5")), equalTo(false));
+        assertThat(config3.hasQuorum(Sets.newHashSet()), equalTo(false));
+    }
 
+    public void testVotingConfigurationSerializationEqualsHashCode() {
+        VotingConfiguration initialConfig = new VotingConfiguration(
+            Sets.newHashSet(generateRandomStringArray(randomInt(10), 20, false)));
+        EqualsHashCodeTestUtils.checkEqualsAndHashCode(initialConfig,
+            orig -> ESTestCase.copyWriteable(orig, new NamedWriteableRegistry(Collections.emptyList()), VotingConfiguration::new),
+            cfg -> {
+                Set<String> newNodeIds = new HashSet<>(cfg.getNodeIds());
+                if (cfg.isEmpty() == false && randomBoolean()) {
+                    // remove random element
+                    newNodeIds.remove(randomFrom(cfg.getNodeIds()));
+                } else if (cfg.isEmpty() == false && randomBoolean()) {
+                    // change random element
+                    newNodeIds.remove(randomFrom(cfg.getNodeIds()));
+                    newNodeIds.add(randomAlphaOfLength(20));
+                } else {
+                    // add random element
+                    newNodeIds.add(randomAlphaOfLength(20));
+                }
+                return new VotingConfiguration(newNodeIds);
+            });
     }
 }

server/src/test/java/org/elasticsearch/discovery/zen/PublishClusterStateActionTests.java

@@ -487,7 +487,8 @@ public void clusterChanged(ClusterChangedEvent event) {
         clusterState = ClusterState.builder(clusterState).blocks(ClusterBlocks.builder()
             .addGlobalBlock(MetaData.CLUSTER_READ_ONLY_BLOCK)).incrementVersion().build();
 
-        ClusterState unserializableClusterState = new ClusterState(clusterState.version(), clusterState.stateUUID(), clusterState) {
+        ClusterState unserializableClusterState = new ClusterState(clusterState.term(), clusterState.version(), clusterState.stateUUID(),
+                                                                   clusterState) {
             @Override
             public Diff<ClusterState> diff(ClusterState previousState) {
                 return new Diff<ClusterState>() {

x-pack/plugin/monitoring/src/test/java/org/elasticsearch/xpack/monitoring/collector/cluster/ClusterStatsMonitoringDocTests.java

@@ -504,8 +504,11 @@ public void testToXContent() throws IOException {
                     + "\"nodes_hash\":1314980060,"
                     + "\"status\":\"green\","
                     + "\"cluster_uuid\":\"_cluster\","
+                    + "\"term\":0,"
                     + "\"version\":12,"
                     + "\"state_uuid\":\"_state_uuid\","
+                    + "\"last_committed_config\":[],"
+                    + "\"last_accepted_config\":[],"
                     + "\"master_node\":\"_node\","
                     + "\"nodes\":{"
                       + "\"_node_id\":{"