Modify state of VerifyRepositoryResponse for bwc

server/src/main/java/org/elasticsearch/action/admin/cluster/repositories/verify/VerifyRepositoryResponse.java

@@ -19,23 +19,111 @@
 
 package org.elasticsearch.action.admin.cluster.repositories.verify;
 
+import org.elasticsearch.Version;
 import org.elasticsearch.action.ActionResponse;
 import org.elasticsearch.cluster.ClusterName;
 import org.elasticsearch.cluster.node.DiscoveryNode;
+import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.io.stream.Writeable;
+import org.elasticsearch.common.transport.TransportAddress;
+import org.elasticsearch.common.xcontent.ObjectParser;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.node.Node;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 /**
- * Unregister repository response
+ * verify repository response
  */
 public class VerifyRepositoryResponse extends ActionResponse implements ToXContentObject {
 
-    private DiscoveryNode[] nodes;
+    public static class NodeView implements Writeable, ToXContentObject {
+        private static final ObjectParser.NamedObjectParser<NodeView, Void> PARSER;
+        static {
+            ObjectParser<NodeView, Void> parser = new ObjectParser<>("nodes");
+            parser.declareString(NodeView::setName, new ParseField(Fields.NAME));
+            PARSER = (p, v, name) -> parser.parse(p, new NodeView(name), null);
+        }
+
+        final String nodeId;
+        String name;
+
+        public NodeView(String nodeId) { this.nodeId = nodeId; }
+
+        public NodeView(String nodeId, String name) {
+            this(nodeId);
+            this.name = name;
+        }
+
+        public NodeView(StreamInput in) throws IOException {
+            this(in.readString());
+            this.name = in.readString();
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeString(nodeId);
+            out.writeString(name);
+        }
+
+        void setName(String name) { this.name = name; }
+
+        public String getName() { return name; }
+
+        public String getNodeId() { return nodeId; }
+
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject(nodeId);
+            builder.field(Fields.NAME, name);
+            builder.endObject();
+            return builder;
+        }
+
+        /**
+         * Temporary method that allows turning a {@link NodeView} into a {@link DiscoveryNode}. This representation will never be used in
+         * practice, because in >= 6.4 a consumer of the response will only be able to retrieve a representation of {@link NodeView}
+         * objects.
+         *
+         * Effectively this will be used to hold the state of the object in 6.x so there is no need to have 2 backing objects that
+         * represent the state of the Response. In practice these will always be read by a consumer as a NodeView, but it eases the
+         * transition to master which will not contain any representation of a {@link DiscoveryNode}.
+         */
+        DiscoveryNode convertToDiscoveryNode() {
+            return new DiscoveryNode(name, nodeId, "", "", "", new TransportAddress(TransportAddress.META_ADDRESS, 0),
+                Collections.emptyMap(), Collections.emptySet(), Version.CURRENT);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (getClass() != obj.getClass()) {
+                return false;
+            }
+            NodeView other = (NodeView) obj;
+            return Objects.equals(nodeId, other.nodeId) &&
+                Objects.equals(name, other.name);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(nodeId, name);
+        }
+    }
+
+    private List<DiscoveryNode> nodes;
 
     private ClusterName clusterName;
 
@@ -45,31 +133,33 @@ public class VerifyRepositoryResponse extends ActionResponse implements ToXConte
 
     public VerifyRepositoryResponse(ClusterName clusterName, DiscoveryNode[] nodes) {
         this.clusterName = clusterName;
-        this.nodes = nodes;
+        this.nodes = Arrays.asList(nodes);
     }
 
     @Override
     public void readFrom(StreamInput in) throws IOException {
         super.readFrom(in);
-        clusterName = new ClusterName(in);
-        nodes = new DiscoveryNode[in.readVInt()];
-        for (int i=0; i<nodes.length; i++){
-            nodes[i] = new DiscoveryNode(in);
+        if (in.getVersion().onOrAfter(Version.V_6_4_0)) {
+            this.nodes = in.readList(NodeView::new).stream().map(n -> n.convertToDiscoveryNode()).collect(Collectors.toList());
+        } else {
+            clusterName = new ClusterName(in);
+            this.nodes = in.readList(DiscoveryNode::new);
         }
     }
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        clusterName.writeTo(out);
-        out.writeVInt(nodes.length);
-        for (DiscoveryNode node : nodes) {
-            node.writeTo(out);
+        if (Version.CURRENT.onOrAfter(Version.V_6_4_0)) {
+            out.writeList(getNodes());
+        } else {
+            clusterName.writeTo(out);
+            out.writeList(nodes);
         }
     }
 
-    public DiscoveryNode[] getNodes() {
-        return nodes;
+    public List<NodeView> getNodes() {
+        return nodes.stream().map(dn -> new NodeView(dn.getId(), dn.getName())).collect(Collectors.toList());
     }
 
     public ClusterName getClusterName() {

server/src/test/java/org/elasticsearch/action/admin/cluster/repositories/RepositoryBlocksIT.java

@@ -67,7 +67,7 @@ public void testVerifyRepositoryWithBlocks() {
         try {
             setClusterReadOnly(true);
             VerifyRepositoryResponse response = client().admin().cluster().prepareVerifyRepository("test-repo-blocks").execute().actionGet();
-            assertThat(response.getNodes().length, equalTo(cluster().numDataAndMasterNodes()));
+            assertThat(response.getNodes().size(), equalTo(cluster().numDataAndMasterNodes()));
         } finally {
             setClusterReadOnly(false);
         }

server/src/test/java/org/elasticsearch/action/admin/cluster/snapshots/SnapshotBlocksIT.java

@@ -73,7 +73,7 @@ protected void setUpRepository() throws Exception {
 
         logger.info("--> verify the repository");
         VerifyRepositoryResponse verifyResponse = client().admin().cluster().prepareVerifyRepository(REPOSITORY_NAME).get();
-        assertThat(verifyResponse.getNodes().length, equalTo(cluster().numDataAndMasterNodes()));
+        assertThat(verifyResponse.getNodes().size(), equalTo(cluster().numDataAndMasterNodes()));
 
         logger.info("--> create a snapshot");
         CreateSnapshotResponse snapshotResponse = client().admin().cluster().prepareCreateSnapshot(REPOSITORY_NAME, SNAPSHOT_NAME)

server/src/test/java/org/elasticsearch/snapshots/RepositoriesIT.java

@@ -61,7 +61,7 @@ public void testRepositoryCreation() throws Exception {
         logger.info("--> verify the repository");
         int numberOfFiles = FileSystemUtils.files(location).length;
         VerifyRepositoryResponse verifyRepositoryResponse = client.admin().cluster().prepareVerifyRepository("test-repo-1").get();
-        assertThat(verifyRepositoryResponse.getNodes().length, equalTo(cluster().numDataAndMasterNodes()));
+        assertThat(verifyRepositoryResponse.getNodes().size(), equalTo(cluster().numDataAndMasterNodes()));
 
         logger.info("--> verify that we didn't leave any files as a result of verification");
         assertThat(FileSystemUtils.files(location).length, equalTo(numberOfFiles));