Changing details section name in response

Christoph Büscher · Christoph Büscher · commit b3f3de140ada · 2019-07-02T10:30:33.000+02:00
diff --git a/docs/reference/indices/apis/reload-analyzers.asciidoc b/docs/reference/indices/apis/reload-analyzers.asciidoc
@@ -82,7 +82,7 @@ analyzers that were reloaded:
         "successful" : 2,
         "failed" : 0
     },
-    "reloaded_nodes" : [
+    "reload_details" : [
         {
             "index" : "my_index",
             "reloaded_analyzers" : [
diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/action/ReloadAnalyzersResponse.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/action/ReloadAnalyzersResponse.java
@@ -30,34 +30,39 @@
  */
 public class ReloadAnalyzersResponse extends BroadcastResponse  {
 
-    private final Map<String, IndexDetails> reloadedIndicesDetails;
+    private final Map<String, ReloadDetails> reloadDetails;
+    private final static ParseField RELOAD_DETAILS_FIELD = new ParseField("reload_details");
+    private final static ParseField INDEX_FIELD = new ParseField("index");
+    private final static ParseField RELOADED_ANALYZERS_FIELD = new ParseField("reloaded_analyzers");
+    private final static ParseField RELOADED_NODE_IDS_FIELD = new ParseField("reloaded_node_ids");
+
 
     public ReloadAnalyzersResponse() {
-        reloadedIndicesDetails = Collections.emptyMap();
+        reloadDetails = Collections.emptyMap();
     }
 
     public ReloadAnalyzersResponse(int totalShards, int successfulShards, int failedShards,
-            List<DefaultShardOperationFailedException> shardFailures, Map<String, IndexDetails> reloadedIndicesNodes) {
+            List<DefaultShardOperationFailedException> shardFailures, Map<String, ReloadDetails> reloadedIndicesNodes) {
         super(totalShards, successfulShards, failedShards, shardFailures);
-        this.reloadedIndicesDetails = reloadedIndicesNodes;
+        this.reloadDetails = reloadedIndicesNodes;
     }
 
-    public final Map<String, IndexDetails> getReloadedIndicesDetails() {
-        return this.reloadedIndicesDetails;
+    public final Map<String, ReloadDetails> getReloadDetails() {
+        return this.reloadDetails;
     }
 
     /**
      * Override in subclass to add custom fields following the common `_shards` field
      */
     @Override
     protected void addCustomXContentFields(XContentBuilder builder, Params params) throws IOException {
-        builder.startArray("reloaded_nodes");
-        for (Entry<String, IndexDetails> indexDetails : reloadedIndicesDetails.entrySet()) {
+        builder.startArray(RELOAD_DETAILS_FIELD.getPreferredName());
+        for (Entry<String, ReloadDetails> indexDetails : reloadDetails.entrySet()) {
             builder.startObject();
-            IndexDetails value = indexDetails.getValue();
-            builder.field("index", value.getIndexName());
-            builder.field("reloaded_analyzers", value.getReloadedAnalyzers());
-            builder.field("reloaded_node_ids", value.getReloadedIndicesNodes());
+            ReloadDetails value = indexDetails.getValue();
+            builder.field(INDEX_FIELD.getPreferredName(), value.getIndexName());
+            builder.field(RELOADED_ANALYZERS_FIELD.getPreferredName(), value.getReloadedAnalyzers());
+            builder.field(RELOADED_NODE_IDS_FIELD.getPreferredName(), value.getReloadedIndicesNodes());
             builder.endObject();
         }
         builder.endArray();
@@ -67,40 +72,40 @@ protected void addCustomXContentFields(XContentBuilder builder, Params params) t
     private static final ConstructingObjectParser<ReloadAnalyzersResponse, Void> PARSER = new ConstructingObjectParser<>("reload_analyzer",
             true, arg -> {
                 BroadcastResponse response = (BroadcastResponse) arg[0];
-                List<IndexDetails> results = (List<IndexDetails>) arg[1];
-                Map<String, IndexDetails> reloadedNodeIds = new HashMap<>();
-                for (IndexDetails result : results) {
+                List<ReloadDetails> results = (List<ReloadDetails>) arg[1];
+                Map<String, ReloadDetails> reloadedNodeIds = new HashMap<>();
+                for (ReloadDetails result : results) {
                     reloadedNodeIds.put(result.getIndexName(), result);
                 }
                 return new ReloadAnalyzersResponse(response.getTotalShards(), response.getSuccessfulShards(), response.getFailedShards(),
                         Arrays.asList(response.getShardFailures()), reloadedNodeIds);
             });
 
     @SuppressWarnings({ "unchecked" })
-    private static final ConstructingObjectParser<IndexDetails, Void> ENTRY_PARSER = new ConstructingObjectParser<>(
+    private static final ConstructingObjectParser<ReloadDetails, Void> ENTRY_PARSER = new ConstructingObjectParser<>(
             "reload_analyzer.entry", true, arg -> {
-                return new IndexDetails((String) arg[0], new HashSet<>((List<String>) arg[1]), new HashSet<>((List<String>) arg[2]));
+                return new ReloadDetails((String) arg[0], new HashSet<>((List<String>) arg[1]), new HashSet<>((List<String>) arg[2]));
             });
 
     static {
         declareBroadcastFields(PARSER);
-        PARSER.declareObjectArray(constructorArg(), ENTRY_PARSER, new ParseField("reloaded_nodes"));
-        ENTRY_PARSER.declareString(constructorArg(), new ParseField("index"));
-        ENTRY_PARSER.declareStringArray(constructorArg(), new ParseField("reloaded_analyzers"));
-        ENTRY_PARSER.declareStringArray(constructorArg(), new ParseField("reloaded_node_ids"));
+        PARSER.declareObjectArray(constructorArg(), ENTRY_PARSER, RELOAD_DETAILS_FIELD);
+        ENTRY_PARSER.declareString(constructorArg(), INDEX_FIELD);
+        ENTRY_PARSER.declareStringArray(constructorArg(), RELOADED_ANALYZERS_FIELD);
+        ENTRY_PARSER.declareStringArray(constructorArg(), RELOADED_NODE_IDS_FIELD);
     }
 
     public static ReloadAnalyzersResponse fromXContent(XContentParser parser) {
         return PARSER.apply(parser, null);
     }
 
-    public static class IndexDetails {
+    public static class ReloadDetails {
 
         private final String indexName;
         private final Set<String> reloadedIndicesNodes;
         private final Set<String> reloadedAnalyzers;
 
-        IndexDetails(String name, Set<String> reloadedIndicesNodes, Set<String> reloadedAnalyzers) {
+        ReloadDetails(String name, Set<String> reloadedIndicesNodes, Set<String> reloadedAnalyzers) {
             this.indexName = name;
             this.reloadedIndicesNodes = reloadedIndicesNodes;
             this.reloadedAnalyzers = reloadedAnalyzers;
diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/action/TransportReloadAnalyzersAction.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/action/TransportReloadAnalyzersAction.java
@@ -29,7 +29,7 @@
 import org.elasticsearch.indices.IndicesService;
 import org.elasticsearch.threadpool.ThreadPool;
 import org.elasticsearch.transport.TransportService;
-import org.elasticsearch.xpack.core.action.ReloadAnalyzersResponse.IndexDetails;
+import org.elasticsearch.xpack.core.action.ReloadAnalyzersResponse.ReloadDetails;
 import org.elasticsearch.xpack.core.action.TransportReloadAnalyzersAction.ReloadResult;
 
 import java.io.IOException;
@@ -68,14 +68,14 @@ protected ReloadResult readShardResult(StreamInput in) throws IOException {
     @Override
     protected ReloadAnalyzersResponse newResponse(ReloadAnalyzersRequest request, int totalShards, int successfulShards, int failedShards,
             List<ReloadResult> responses, List<DefaultShardOperationFailedException> shardFailures, ClusterState clusterState) {
-        Map<String, IndexDetails> reloadedIndicesDetails = new HashMap<String, IndexDetails>();
+        Map<String, ReloadDetails> reloadedIndicesDetails = new HashMap<String, ReloadDetails>();
         for (ReloadResult result : responses) {
             if (reloadedIndicesDetails.containsKey(result.index)) {
                 reloadedIndicesDetails.get(result.index).merge(result);;
             } else {
                 HashSet<String> nodeIds = new HashSet<String>();
                 nodeIds.add(result.nodeId);
-                IndexDetails details = new IndexDetails(result.index, nodeIds, new HashSet<String>(result.reloadedSearchAnalyzers));
+                ReloadDetails details = new ReloadDetails(result.index, nodeIds, new HashSet<String>(result.reloadedSearchAnalyzers));
                 reloadedIndicesDetails.put(result.index, details);
             }
         }
diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/action/ReloadAnalyzersResponseTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/action/ReloadAnalyzersResponseTests.java
@@ -9,7 +9,7 @@
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.test.AbstractBroadcastResponseTestCase;
-import org.elasticsearch.xpack.core.action.ReloadAnalyzersResponse.IndexDetails;
+import org.elasticsearch.xpack.core.action.ReloadAnalyzersResponse.ReloadDetails;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -25,13 +25,13 @@ public class ReloadAnalyzersResponseTests extends AbstractBroadcastResponseTestC
     @Override
     protected ReloadAnalyzersResponse createTestInstance(int totalShards, int successfulShards, int failedShards,
                                                  List<DefaultShardOperationFailedException> failures) {
-        Map<String, IndexDetails> reloadedIndicesDetails = new HashMap<>();
+        Map<String, ReloadDetails> reloadedIndicesDetails = new HashMap<>();
         int randomIndices = randomIntBetween(0, 5);
         for (int i = 0; i < randomIndices; i++) {
             String name = randomAlphaOfLengthBetween(5, 10);
             Set<String> reloadedIndicesNodes = new HashSet<>(Arrays.asList(generateRandomStringArray(5, 5, false, true)));
             Set<String> reloadedAnalyzers = new HashSet<>(Arrays.asList(generateRandomStringArray(5, 5, false, true)));
-            reloadedIndicesDetails.put(name, new IndexDetails(name, reloadedIndicesNodes, reloadedAnalyzers));
+            reloadedIndicesDetails.put(name, new ReloadDetails(name, reloadedIndicesNodes, reloadedAnalyzers));
         }
         return new ReloadAnalyzersResponse(totalShards, successfulShards, failedShards, failures, reloadedIndicesDetails);
     }
@@ -43,13 +43,13 @@ protected ReloadAnalyzersResponse doParseInstance(XContentParser parser) throws
 
     @Override
     public void testToXContent() {
-        Map<String, IndexDetails> reloadedIndicesNodes = Collections.singletonMap("index",
-                new IndexDetails("index", Collections.singleton("nodeId"), Collections.singleton("my_analyzer")));
+        Map<String, ReloadDetails> reloadedIndicesNodes = Collections.singletonMap("index",
+                new ReloadDetails("index", Collections.singleton("nodeId"), Collections.singleton("my_analyzer")));
         ReloadAnalyzersResponse response = new ReloadAnalyzersResponse(10, 5, 5, null, reloadedIndicesNodes);
         String output = Strings.toString(response);
         assertEquals(
                 "{\"_shards\":{\"total\":10,\"successful\":5,\"failed\":5},"
-                + "\"reloaded_nodes\":[{\"index\":\"index\",\"reloaded_analyzers\":[\"my_analyzer\"],\"reloaded_node_ids\":[\"nodeId\"]}]"
+                + "\"reload_details\":[{\"index\":\"index\",\"reloaded_analyzers\":[\"my_analyzer\"],\"reloaded_node_ids\":[\"nodeId\"]}]"
                 + "}",
                 output);
     }
diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/action/ReloadSynonymAnalyzerTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/action/ReloadSynonymAnalyzerTests.java
@@ -87,7 +87,7 @@ public void testSynonymsUpdateable() throws FileNotFoundException, IOException {
         ReloadAnalyzersResponse reloadResponse = client().execute(ReloadAnalyzerAction.INSTANCE, new ReloadAnalyzersRequest(indexName))
                 .actionGet();
         assertNoFailures(reloadResponse);
-        Set<String> reloadedAnalyzers = reloadResponse.getReloadedIndicesDetails().get(indexName).getReloadedAnalyzers();
+        Set<String> reloadedAnalyzers = reloadResponse.getReloadDetails().get(indexName).getReloadedAnalyzers();
         assertEquals(1, reloadedAnalyzers.size());
         assertTrue(reloadedAnalyzers.contains(analyzerName));
 
diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/rest/action/ReloadSynonymAnalyzerIT.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/rest/action/ReloadSynonymAnalyzerIT.java
@@ -103,10 +103,10 @@ public void testSynonymsUpdateable() throws FileNotFoundException, IOException,
                     .actionGet();
             assertNoFailures(reloadResponse);
             assertEquals(cluster().numDataNodes(), reloadResponse.getSuccessfulShards());
-            assertTrue(reloadResponse.getReloadedIndicesDetails().containsKey("test"));
-            assertEquals("test", reloadResponse.getReloadedIndicesDetails().get("test").getIndexName());
+            assertTrue(reloadResponse.getReloadDetails().containsKey("test"));
+            assertEquals("test", reloadResponse.getReloadDetails().get("test").getIndexName());
             assertEquals(Collections.singleton("my_synonym_analyzer"),
-                    reloadResponse.getReloadedIndicesDetails().get("test").getReloadedAnalyzers());
+                    reloadResponse.getReloadDetails().get("test").getReloadedAnalyzers());
 
             analyzeResponse = client().admin().indices().prepareAnalyze("test", "foo").setAnalyzer("my_synonym_analyzer").get();
             assertEquals(3, analyzeResponse.getTokens().size());

Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ analyzers that were reloaded:`
`82`	`82`	`"successful" : 2,`
`83`	`83`	`"failed" : 0`
`84`	`84`	`},`
`85`		`- "reloaded_nodes" : [`
	`85`	`+ "reload_details" : [`
`86`	`86`	`{`
`87`	`87`	`"index" : "my_index",`
`88`	`88`	`"reloaded_analyzers" : [`