Adds Index lifecycle feature

.ci/java-versions.properties

@@ -8,3 +8,4 @@ ES_BUILD_JAVA=java11
 ES_RUNTIME_JAVA=java8
 GRADLE_TASK=build
 
+GRADLE_EXTRA_ARGS=-Dtests.bwc.refspec=elastic/index-lifecycle-6.x

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;
 
@@ -1007,7 +1008,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

@@ -224,6 +224,7 @@ public class RestHighLevelClient implements Closeable {
     private final MigrationClient migrationClient = new MigrationClient(this);
     private final MachineLearningClient machineLearningClient = new MachineLearningClient(this);
     private final SecurityClient securityClient = new SecurityClient(this);
+    private final IndexLifecycleClient ilmClient = new IndexLifecycleClient(this);
     private final RollupClient rollupClient = new RollupClient(this);
 
     /**
@@ -370,6 +371,17 @@ public final XPackClient xpack() {
      */
     public LicenseClient license() { return licenseClient; }
 
+    /**
+     * A wrapper for the {@link RestHighLevelClient} that provides methods for
+     * accessing the Elastic Index Lifecycle APIs.
+     * <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 ilmClient;
+    }
+
     /**
      * 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);
@@ -38,7 +38,6 @@ public class TimedRequest implements Validatable {
 
     public void setTimeout(TimeValue timeout) {
         this.timeout = timeout;
-
     }
 
     public void setMasterTimeout(TimeValue masterTimeout) {

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);
+    }
+}