[BACKPORT] Adds Index lifecycle feature

buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy

@@ -242,11 +242,12 @@ class BuildPlugin implements Plugin<Project> {
             compilerJavaHome = findJavaHome(compilerJavaProperty)
         }
         if (compilerJavaHome == null) {
-            if (System.getProperty("idea.active") != null || System.getProperty("eclipse.launcher") != null) {
+            if (System.getProperty("idea.executable") != null || System.getProperty("eclipse.launcher") != null) {
                 // IntelliJ does not set JAVA_HOME, so we use the JDK that Gradle was run with
                 return Jvm.current().javaHome
             } else {
                 throw new GradleException(
+                        " " + System.getProperties().toString() + " " +
                         "JAVA_HOME must be set to build Elasticsearch. " +
                                 "Note that if the variable was just set you might have to run `./gradlew --stop` for " +
                                 "it to be picked up. See https://github.com/elastic/elasticsearch/issues/31399 details."

client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleRequestConverters.java

@@ -0,0 +1,154 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client;
+
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.elasticsearch.client.indexlifecycle.DeleteLifecyclePolicyRequest;
+import org.elasticsearch.client.indexlifecycle.ExplainLifecycleRequest;
+import org.elasticsearch.client.indexlifecycle.GetLifecyclePolicyRequest;
+import org.elasticsearch.client.indexlifecycle.LifecycleManagementStatusRequest;
+import org.elasticsearch.client.indexlifecycle.PutLifecyclePolicyRequest;
+import org.elasticsearch.client.indexlifecycle.RemoveIndexLifecyclePolicyRequest;
+import org.elasticsearch.client.indexlifecycle.RetryLifecyclePolicyRequest;
+import org.elasticsearch.client.indexlifecycle.StartILMRequest;
+import org.elasticsearch.client.indexlifecycle.StopILMRequest;
+import org.elasticsearch.common.Strings;
+
+import java.io.IOException;
+
+final class IndexLifecycleRequestConverters {
+
+    private IndexLifecycleRequestConverters() {}
+
+    static Request getLifecyclePolicy(GetLifecyclePolicyRequest getLifecyclePolicyRequest) {
+        String endpoint = new RequestConverters.EndpointBuilder().addPathPartAsIs("_ilm/policy")
+                .addCommaSeparatedPathParts(getLifecyclePolicyRequest.getPolicyNames()).build();
+        Request request = new Request(HttpGet.METHOD_NAME, endpoint);
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(getLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(getLifecyclePolicyRequest.timeout());
+        return request;
+    }
+
+    static Request putLifecyclePolicy(PutLifecyclePolicyRequest putLifecycleRequest) throws IOException {
+        String endpoint = new RequestConverters.EndpointBuilder()
+            .addPathPartAsIs("_ilm/policy")
+            .addPathPartAsIs(putLifecycleRequest.getName())
+            .build();
+        Request request = new Request(HttpPut.METHOD_NAME, endpoint);
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(putLifecycleRequest.masterNodeTimeout());
+        params.withTimeout(putLifecycleRequest.timeout());
+        request.setEntity(RequestConverters.createEntity(putLifecycleRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE));
+        return request;
+    }
+
+    static Request deleteLifecyclePolicy(DeleteLifecyclePolicyRequest deleteLifecyclePolicyRequest) {
+        Request request = new Request(HttpDelete.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addPathPartAsIs("_ilm/policy")
+                .addPathPartAsIs(deleteLifecyclePolicyRequest.getLifecyclePolicy())
+                .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(deleteLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(deleteLifecyclePolicyRequest.timeout());
+        return request;
+    }
+
+    static Request removeIndexLifecyclePolicy(RemoveIndexLifecyclePolicyRequest removePolicyRequest) {
+        String[] indices = removePolicyRequest.indices() == null ?
+                Strings.EMPTY_ARRAY : removePolicyRequest.indices().toArray(new String[] {});
+        Request request = new Request(HttpDelete.METHOD_NAME,
+                new RequestConverters.EndpointBuilder()
+                        .addCommaSeparatedPathParts(indices)
+                        .addPathPartAsIs("_ilm")
+                        .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withIndicesOptions(removePolicyRequest.indicesOptions());
+        params.withMasterTimeout(removePolicyRequest.masterNodeTimeout());
+        return request;
+    }
+
+    static Request startILM(StartILMRequest startILMRequest) {
+        Request request = new Request(HttpPost.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addPathPartAsIs("_ilm")
+                .addPathPartAsIs("start")
+            .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(startILMRequest.masterNodeTimeout());
+        params.withTimeout(startILMRequest.timeout());
+        return request;
+    }
+
+    static Request stopILM(StopILMRequest stopILMRequest) {
+        Request request = new Request(HttpPost.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addPathPartAsIs("_ilm")
+                .addPathPartAsIs("stop")
+            .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(stopILMRequest.masterNodeTimeout());
+        params.withTimeout(stopILMRequest.timeout());
+        return request;
+    }
+
+    static Request lifecycleManagementStatus(LifecycleManagementStatusRequest lifecycleManagementStatusRequest){
+        Request request = new Request(HttpGet.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addPathPartAsIs("_ilm")
+                .addPathPartAsIs("status")
+            .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(lifecycleManagementStatusRequest.masterNodeTimeout());
+        params.withTimeout(lifecycleManagementStatusRequest.timeout());
+        return request;
+    }
+
+    static Request explainLifecycle(ExplainLifecycleRequest explainLifecycleRequest) {
+        String[] indices = explainLifecycleRequest.indices() == null ? Strings.EMPTY_ARRAY : explainLifecycleRequest.indices();
+        Request request = new Request(HttpGet.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addCommaSeparatedPathParts(indices)
+                .addPathPartAsIs("_ilm")
+                .addPathPartAsIs("explain")
+            .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withIndicesOptions(explainLifecycleRequest.indicesOptions());
+        params.withMasterTimeout(explainLifecycleRequest.masterNodeTimeout());
+        return request;
+    }
+
+    static Request retryLifecycle(RetryLifecyclePolicyRequest retryLifecyclePolicyRequest) {
+        Request request = new Request(HttpPost.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addCommaSeparatedPathParts(retryLifecyclePolicyRequest.getIndices())
+                .addPathPartAsIs("_ilm")
+                .addPathPartAsIs("retry")
+                .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(retryLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(retryLifecyclePolicyRequest.timeout());
+        return request;
+    }
+}

client/rest-high-level/src/main/java/org/elasticsearch/client/RequestConverters.java

@@ -84,6 +84,7 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.charset.Charset;
+import java.util.List;
 import java.util.Locale;
 import java.util.StringJoiner;
 
@@ -1022,7 +1023,12 @@ EndpointBuilder addCommaSeparatedPathParts(String[] parts) {
             return this;
         }
 
-        EndpointBuilder addPathPartAsIs(String... parts) {
+        EndpointBuilder addCommaSeparatedPathParts(List<String> parts) {
+            addPathPart(String.join(",", parts));
+            return this;
+        }
+
+        EndpointBuilder addPathPartAsIs(String ... parts) {
             for (String part : parts) {
                 if (Strings.hasLength(part)) {
                     joiner.add(part);

client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java

@@ -219,6 +219,7 @@ public class RestHighLevelClient implements Closeable {
     private final WatcherClient watcherClient = new WatcherClient(this);
     private final GraphClient graphClient = new GraphClient(this);
     private final LicenseClient licenseClient = new LicenseClient(this);
+    private final IndexLifecycleClient indexLifecycleClient = new IndexLifecycleClient(this);
     private final MigrationClient migrationClient = new MigrationClient(this);
     private final MachineLearningClient machineLearningClient = new MachineLearningClient(this);
     private final SecurityClient securityClient = new SecurityClient(this);
@@ -368,6 +369,16 @@ public final XPackClient xpack() {
      */
     public LicenseClient license() { return licenseClient; }
 
+    /**
+     * Provides methods for accessing the Elastic Licensed Index Lifecycle APIs that are shipped with the default distribution of
+     * Elasticsearch. All of these APIs will 404 if run against the OSS distribution of Elasticsearch.
+     * <p>
+     * See the <a href="http://FILL-ME-IN-WE-HAVE-NO-DOCS-YET.com"> X-Pack APIs on elastic.co</a> for more information.
+     */
+    public IndexLifecycleClient indexLifecycle() {
+        return indexLifecycleClient;
+    }
+
     /**
      * Provides methods for accessing the Elastic Licensed Licensing APIs that
      * are shipped with the default distribution of Elasticsearch. All of

client/rest-high-level/src/main/java/org/elasticsearch/client/TimedRequest.java

@@ -28,7 +28,7 @@
  * Please note, any requests that use a ackTimeout should set timeout as they
  * represent the same backing field on the server.
  */
-public class TimedRequest implements Validatable {
+public abstract class TimedRequest implements Validatable {
 
     public static final TimeValue DEFAULT_ACK_TIMEOUT = timeValueSeconds(30);
     public static final TimeValue DEFAULT_MASTER_NODE_TIMEOUT = TimeValue.timeValueSeconds(30);

client/rest-high-level/src/main/java/org/elasticsearch/client/XPackClient.java

@@ -94,4 +94,5 @@ public void usageAsync(XPackUsageRequest request, RequestOptions options, Action
         restHighLevelClient.performRequestAsyncAndParseEntity(request, XPackRequestConverters::usage, options,
             XPackUsageResponse::fromXContent, listener, emptySet());
     }
+
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/indexlifecycle/AllocateAction.java

@@ -0,0 +1,147 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.elasticsearch.client.indexlifecycle;
+
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContent;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+
+public class AllocateAction implements LifecycleAction, ToXContentObject {
+
+    public static final String NAME = "allocate";
+    static final ParseField NUMBER_OF_REPLICAS_FIELD = new ParseField("number_of_replicas");
+    static final ParseField INCLUDE_FIELD = new ParseField("include");
+    static final ParseField EXCLUDE_FIELD = new ParseField("exclude");
+    static final ParseField REQUIRE_FIELD = new ParseField("require");
+
+    @SuppressWarnings("unchecked")
+    private static final ConstructingObjectParser<AllocateAction, Void> PARSER = new ConstructingObjectParser<>(NAME,
+            a -> new AllocateAction((Integer) a[0], (Map<String, String>) a[1], (Map<String, String>) a[2], (Map<String, String>) a[3]));
+
+    static {
+        PARSER.declareInt(ConstructingObjectParser.optionalConstructorArg(), NUMBER_OF_REPLICAS_FIELD);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> p.mapStrings(), INCLUDE_FIELD);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> p.mapStrings(), EXCLUDE_FIELD);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> p.mapStrings(), REQUIRE_FIELD);
+    }
+
+    private final Integer numberOfReplicas;
+    private final Map<String, String> include;
+    private final Map<String, String> exclude;
+    private final Map<String, String> require;
+
+    public static AllocateAction parse(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    public AllocateAction(Integer numberOfReplicas, Map<String, String> include, Map<String, String> exclude, Map<String, String> require) {
+        if (include == null) {
+            this.include = Collections.emptyMap();
+        } else {
+            this.include = include;
+        }
+        if (exclude == null) {
+            this.exclude = Collections.emptyMap();
+        } else {
+            this.exclude = exclude;
+        }
+        if (require == null) {
+            this.require = Collections.emptyMap();
+        } else {
+            this.require = require;
+        }
+        if (this.include.isEmpty() && this.exclude.isEmpty() && this.require.isEmpty() && numberOfReplicas == null) {
+            throw new IllegalArgumentException(
+                    "At least one of " + INCLUDE_FIELD.getPreferredName() + ", " + EXCLUDE_FIELD.getPreferredName() + " or "
+                            + REQUIRE_FIELD.getPreferredName() + "must contain attributes for action " + NAME);
+        }
+        if (numberOfReplicas != null && numberOfReplicas < 0) {
+            throw new IllegalArgumentException("[" + NUMBER_OF_REPLICAS_FIELD.getPreferredName() + "] must be >= 0");
+        }
+        this.numberOfReplicas = numberOfReplicas;
+    }
+
+    public Integer getNumberOfReplicas() {
+        return numberOfReplicas;
+    }
+
+    public Map<String, String> getInclude() {
+        return include;
+    }
+
+    public Map<String, String> getExclude() {
+        return exclude;
+    }
+
+    public Map<String, String> getRequire() {
+        return require;
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
+        builder.startObject();
+        if (numberOfReplicas != null) {
+            builder.field(NUMBER_OF_REPLICAS_FIELD.getPreferredName(), numberOfReplicas);
+        }
+        builder.field(INCLUDE_FIELD.getPreferredName(), include);
+        builder.field(EXCLUDE_FIELD.getPreferredName(), exclude);
+        builder.field(REQUIRE_FIELD.getPreferredName(), require);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(numberOfReplicas, include, exclude, require);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (obj.getClass() != getClass()) {
+            return false;
+        }
+        AllocateAction other = (AllocateAction) obj;
+        return Objects.equals(numberOfReplicas, other.numberOfReplicas) &&
+            Objects.equals(include, other.include) &&
+            Objects.equals(exclude, other.exclude) &&
+            Objects.equals(require, other.require);
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(this);
+    }
+}