Create fewer objects when an ILM policy is not used (elastic#140705)

This PR is trying to reduce the object creation by the [`GET
_ilm/policy`](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-get-lifecycle)
when the policy is not used.

To achieve that we perform the following 2 changes:

- We introduce a constant empty instance which is returned when the policy is not used
- We use null instead of empty lists to reduce so the response will not have unnecessary fields. These fields are not documented yet, and from the code it looks like they are optional, another PR will come to document them.

Instead of:

```
"in_use_by": {
  "data_streams": [],
  "indices": [],
  "composable_templates": []
}
```

It will only return the fields in use:

```
"in_use_by": {}

# or

"in_use_by": {
  "composable_templates": ["some_template"]
}
```

Author: gmarouli

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

@@ -10,7 +10,6 @@
 package org.elasticsearch.cluster.metadata;
 
 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.core.Nullable;
@@ -28,6 +27,8 @@
  */
 public class ItemUsage implements Writeable, ToXContentObject {
 
+    public static final ItemUsage EMPTY = new ItemUsage(null, null, null);
+
     private final Set<String> indices;
     private final Set<String> dataStreams;
     private final Set<String> composableTemplates;
@@ -46,24 +47,6 @@ public ItemUsage(
         this.composableTemplates = composableTemplates == null ? null : new HashSet<>(composableTemplates);
     }
 
-    public ItemUsage(StreamInput in) throws IOException {
-        if (in.readBoolean()) {
-            this.indices = in.readCollectionAsSet(StreamInput::readString);
-        } else {
-            this.indices = null;
-        }
-        if (in.readBoolean()) {
-            this.dataStreams = in.readCollectionAsSet(StreamInput::readString);
-        } else {
-            this.dataStreams = null;
-        }
-        if (in.readBoolean()) {
-            this.composableTemplates = in.readCollectionAsSet(StreamInput::readString);
-        } else {
-            this.composableTemplates = null;
-        }
-    }
-
     public Set<String> getIndices() {
         return indices;
     }
@@ -79,15 +62,9 @@ public Set<String> getComposableTemplates() {
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject();
-        if (this.indices != null) {
-            builder.stringListField("indices", this.indices);
-        }
-        if (this.dataStreams != null) {
-            builder.stringListField("data_streams", this.dataStreams);
-        }
-        if (this.composableTemplates != null) {
-            builder.stringListField("composable_templates", this.composableTemplates);
-        }
+        builder.stringListField("indices", this.indices != null ? this.indices : Set.of());
+        builder.stringListField("data_streams", this.dataStreams != null ? this.dataStreams : Set.of());
+        builder.stringListField("composable_templates", this.composableTemplates != null ? this.composableTemplates : Set.of());
         builder.endObject();
         return builder;
     }

server/src/test/java/org/elasticsearch/cluster/metadata/ItemUsageTests.java

@@ -10,12 +10,18 @@
 package org.elasticsearch.cluster.metadata;
 
 import org.elasticsearch.TransportVersion;
+import org.elasticsearch.common.Strings;
 import org.elasticsearch.core.Nullable;
 import org.elasticsearch.test.AbstractWireTestCase;
+import org.elasticsearch.xcontent.ToXContent;
+import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentType;
 
 import java.io.IOException;
 import java.util.List;
 
+import static org.hamcrest.Matchers.containsString;
+
 public class ItemUsageTests extends AbstractWireTestCase<ItemUsage> {
 
     public static ItemUsage randomUsage() {
@@ -45,4 +51,16 @@ protected ItemUsage copyInstance(ItemUsage instance, TransportVersion version) t
     protected ItemUsage mutateInstance(ItemUsage instance) {
         return null;// TODO implement https://github.com/elastic/elasticsearch/issues/25929
     }
+
+    // We test this in a unit test and not a yml test because it is not required by API,
+    // but it has been existing behavior that we chose to preserve.
+    public void testEmptyInstanceXContent() throws IOException {
+        try (XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent())) {
+            builder.humanReadable(true);
+            String json = Strings.toString(ItemUsage.EMPTY.toXContent(builder, ToXContent.EMPTY_PARAMS));
+            assertThat(json, containsString("\"indices\":[]"));
+            assertThat(json, containsString("\"data_streams\":[]"));
+            assertThat(json, containsString("\"composable_templates\":[]"));
+        }
+    }
 }

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ilm/LifecyclePolicyUsageCalculator.java

@@ -107,11 +107,13 @@ public LifecyclePolicyUsageCalculator(
      * Retrieves the pre-calculated indices, data streams, and composable templates that use the given policy.
      */
     public ItemUsage retrieveCalculatedUsage(String policyName) {
-        return new ItemUsage(
-            policyToIndices.getOrDefault(policyName, List.of()),
-            policyToDataStreams.getOrDefault(policyName, List.of()),
-            policyToTemplates.getOrDefault(policyName, List.of())
-        );
+        List<String> indices = policyToIndices.get(policyName);
+        List<String> dataStreams = policyToDataStreams.get(policyName);
+        List<String> composableTemplates = policyToTemplates.get(policyName);
+        if (indices == null && dataStreams == null && composableTemplates == null) {
+            return ItemUsage.EMPTY;
+        }
+        return new ItemUsage(indices, dataStreams, composableTemplates);
     }
 
     private boolean doesPolicyMatchAnyName(String policyName, List<String> names) {

x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/ilm/LifecyclePolicyUsageCalculatorTests.java

@@ -27,6 +27,7 @@
 import java.util.Map;
 
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.sameInstance;
 
 public class LifecyclePolicyUsageCalculatorTests extends ESTestCase {
 
@@ -46,7 +47,7 @@ public void testGetUsageNonExistentPolicy() {
         final var project = ProjectMetadata.builder(randomProjectIdOrDefault()).build();
         assertThat(
             new LifecyclePolicyUsageCalculator(iner, project, List.of("mypolicy")).retrieveCalculatedUsage("mypolicy"),
-            equalTo(new ItemUsage(List.of(), List.of(), List.of()))
+            sameInstance(ItemUsage.EMPTY)
         );
     }
 
@@ -64,7 +65,7 @@ public void testGetUsageUnusedPolicy() {
 
         assertThat(
             new LifecyclePolicyUsageCalculator(iner, project, List.of("mypolicy")).retrieveCalculatedUsage("mypolicy"),
-            equalTo(new ItemUsage(List.of(), List.of(), List.of()))
+            sameInstance(ItemUsage.EMPTY)
         );
     }
 
@@ -86,7 +87,7 @@ public void testGetUsagePolicyUsedByIndex() {
 
         assertThat(
             new LifecyclePolicyUsageCalculator(iner, project, List.of("mypolicy")).retrieveCalculatedUsage("mypolicy"),
-            equalTo(new ItemUsage(List.of("myindex"), List.of(), List.of()))
+            equalTo(new ItemUsage(List.of("myindex"), null, null))
         );
     }
 
@@ -123,7 +124,7 @@ public void testGetUsagePolicyUsedByIndexAndTemplate() {
 
         assertThat(
             new LifecyclePolicyUsageCalculator(iner, project, List.of("mypolicy")).retrieveCalculatedUsage("mypolicy"),
-            equalTo(new ItemUsage(List.of("myindex"), List.of(), List.of("mytemplate")))
+            equalTo(new ItemUsage(List.of("myindex"), null, List.of("mytemplate")))
         );
     }
 
@@ -215,7 +216,7 @@ public void testGetUsagePolicyNotUsedByDataStreamDueToOverride() {
         // Test where policy exists and is used by an index, datastream, and template
         assertThat(
             new LifecyclePolicyUsageCalculator(iner, project, List.of("mypolicy")).retrieveCalculatedUsage("mypolicy"),
-            equalTo(new ItemUsage(List.of("myindex"), List.of(), List.of("mytemplate")))
+            equalTo(new ItemUsage(List.of("myindex"), null, List.of("mytemplate")))
         );
     }
 }