copy LifecyclePolicy to protocol.xpack

This is the final PR for copying over the necessary components for
clients to parse/render LifecyclePolicy. Changes include:

- move of named-x-content server objects away from client
- move validation into the client copy of LifecyclePolicy
- move LifecycleAction into an interface with `getName`

Author: talevy

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

@@ -440,20 +440,7 @@ public List<NamedXContentRegistry.Entry> getNamedXContent() {
                         RollupJobStatus::fromXContent),
                 new NamedXContentRegistry.Entry(PersistentTaskState.class, new ParseField(RollupJobStatus.NAME),
                         RollupJobStatus::fromXContent),
-                // ILM - Custom Metadata
-                new NamedXContentRegistry.Entry(MetaData.Custom.class, new ParseField(IndexLifecycleMetadata.TYPE),
-                    parser -> IndexLifecycleMetadata.PARSER.parse(parser, null)),
-                // ILM - Lifecycle Types
-                new NamedXContentRegistry.Entry(LifecycleType.class, new ParseField(TimeseriesLifecycleType.TYPE),
-                    (p, c) -> TimeseriesLifecycleType.INSTANCE),
-                // ILM - Lifecycle Actions
-                new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(AllocateAction.NAME), AllocateAction::parse),
-                new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(ForceMergeAction.NAME), ForceMergeAction::parse),
-                new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(ReadOnlyAction.NAME), ReadOnlyAction::parse),
-                new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(RolloverAction.NAME), RolloverAction::parse),
-                new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(ShrinkAction.NAME), ShrinkAction::parse),
-                new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(DeleteAction.NAME), DeleteAction::parse),
-                // ILM - Client - Lifecycle Actions
+                // ILM
                 new NamedXContentRegistry.Entry(org.elasticsearch.protocol.xpack.indexlifecycle.LifecycleAction.class,
                     new ParseField(org.elasticsearch.protocol.xpack.indexlifecycle.AllocateAction.NAME),
                     org.elasticsearch.protocol.xpack.indexlifecycle.AllocateAction::parse),

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/indexlifecycle/LifecyclePolicy.java

@@ -34,10 +34,9 @@
 /**
  * Represents the lifecycle of an index from creation to deletion. A
  * {@link LifecyclePolicy} is made up of a set of {@link Phase}s which it will
- * move through. Soon we will constrain the phases using some kinda of lifecycle
- * type which will allow only particular {@link Phase}s to be defined, will
- * dictate the order in which the {@link Phase}s are executed and will define
- * which {@link LifecycleAction}s are allowed in each phase.
+ * move through. Policies are constrained by a {@link LifecycleType} which governs which
+ * {@link Phase}s and {@link LifecycleAction}s are allowed to be defined and in which order
+ * they are executed.
  */
 public class LifecyclePolicy extends AbstractDiffable<LifecyclePolicy>
         implements ToXContentObject, Diffable<LifecyclePolicy> {
@@ -58,9 +57,9 @@ public class LifecyclePolicy extends AbstractDiffable<LifecyclePolicy>
         }, PHASES_FIELD);
     }
 
-    protected final String name;
-    protected final LifecycleType type;
-    protected final Map<String, Phase> phases;
+    private final String name;
+    private final LifecycleType type;
+    private final Map<String, Phase> phases;
 
     /**
      * @param name
@@ -97,6 +96,7 @@ public LifecyclePolicy(StreamInput in) throws IOException {
         this.type = type;
         this.type.validate(phases.values());
     }
+
     public static LifecyclePolicy parse(XContentParser parser, String name) {
         return PARSER.apply(parser, name);
     }

x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/indexlifecycle/IndexLifecycle.java

@@ -10,8 +10,10 @@
 import org.elasticsearch.action.ActionResponse;
 import org.elasticsearch.client.Client;
 import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
+import org.elasticsearch.cluster.metadata.MetaData;
 import org.elasticsearch.cluster.node.DiscoveryNodes;
 import org.elasticsearch.cluster.service.ClusterService;
+import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.inject.Module;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.io.stream.NamedWriteableRegistry.Entry;
@@ -32,8 +34,17 @@
 import org.elasticsearch.watcher.ResourceWatcherService;
 import org.elasticsearch.xpack.core.XPackPlugin;
 import org.elasticsearch.xpack.core.XPackSettings;
+import org.elasticsearch.xpack.core.indexlifecycle.AllocateAction;
+import org.elasticsearch.xpack.core.indexlifecycle.DeleteAction;
+import org.elasticsearch.xpack.core.indexlifecycle.ForceMergeAction;
+import org.elasticsearch.xpack.core.indexlifecycle.IndexLifecycleMetadata;
+import org.elasticsearch.xpack.core.indexlifecycle.LifecycleAction;
 import org.elasticsearch.xpack.core.indexlifecycle.LifecycleSettings;
+import org.elasticsearch.xpack.core.indexlifecycle.LifecycleType;
+import org.elasticsearch.xpack.core.indexlifecycle.ReadOnlyAction;
 import org.elasticsearch.xpack.core.indexlifecycle.RolloverAction;
+import org.elasticsearch.xpack.core.indexlifecycle.ShrinkAction;
+import org.elasticsearch.xpack.core.indexlifecycle.TimeseriesLifecycleType;
 import org.elasticsearch.xpack.core.indexlifecycle.action.DeleteLifecycleAction;
 import org.elasticsearch.xpack.core.indexlifecycle.action.ExplainLifecycleAction;
 import org.elasticsearch.xpack.core.indexlifecycle.action.GetLifecycleAction;
@@ -146,7 +157,21 @@ public List<Entry> getNamedWriteables() {
 
     @Override
     public List<org.elasticsearch.common.xcontent.NamedXContentRegistry.Entry> getNamedXContent() {
-        return Arrays.asList();
+        return Arrays.asList(
+            // Custom Metadata
+            new NamedXContentRegistry.Entry(MetaData.Custom.class, new ParseField(IndexLifecycleMetadata.TYPE),
+                parser -> IndexLifecycleMetadata.PARSER.parse(parser, null)),
+            // Lifecycle Types
+            new NamedXContentRegistry.Entry(LifecycleType.class, new ParseField(TimeseriesLifecycleType.TYPE),
+                (p, c) -> TimeseriesLifecycleType.INSTANCE),
+            // Lifecycle Actions
+            new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(AllocateAction.NAME), AllocateAction::parse),
+            new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(ForceMergeAction.NAME), ForceMergeAction::parse),
+            new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(ReadOnlyAction.NAME), ReadOnlyAction::parse),
+            new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(RolloverAction.NAME), RolloverAction::parse),
+            new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(ShrinkAction.NAME), ShrinkAction::parse),
+            new NamedXContentRegistry.Entry(LifecycleAction.class, new ParseField(DeleteAction.NAME), DeleteAction::parse)
+        );
     }
 
     @Override

x-pack/protocol/src/main/java/org/elasticsearch/protocol/xpack/indexlifecycle/AllocateAction.java

@@ -31,7 +31,7 @@
 import java.util.Map;
 import java.util.Objects;
 
-public class AllocateAction extends LifecycleAction implements ToXContentObject {
+public class AllocateAction implements LifecycleAction, ToXContentObject {
 
     public static final String NAME = "allocate";
     static final ParseField NUMBER_OF_REPLICAS_FIELD = new ParseField("number_of_replicas");
@@ -102,6 +102,11 @@ 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();

x-pack/protocol/src/main/java/org/elasticsearch/protocol/xpack/indexlifecycle/DeleteAction.java

@@ -27,7 +27,7 @@
 
 import java.io.IOException;
 
-public class DeleteAction extends LifecycleAction implements ToXContentObject {
+public class DeleteAction implements LifecycleAction, ToXContentObject {
     public static final String NAME = "delete";
 
     private static final ObjectParser<DeleteAction, Void> PARSER = new ObjectParser<>(NAME, DeleteAction::new);
@@ -46,6 +46,11 @@ public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params par
         return builder;
     }
 
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
     @Override
     public int hashCode() {
         return 1;

x-pack/protocol/src/main/java/org/elasticsearch/protocol/xpack/indexlifecycle/ForceMergeAction.java

@@ -28,7 +28,7 @@
 import java.io.IOException;
 import java.util.Objects;
 
-public class ForceMergeAction extends LifecycleAction implements ToXContentObject {
+public class ForceMergeAction implements LifecycleAction, ToXContentObject {
     public static final String NAME = "forcemerge";
     private static final ParseField MAX_NUM_SEGMENTS_FIELD = new ParseField("max_num_segments");
 
@@ -60,6 +60,11 @@ public int getMaxNumSegments() {
         return maxNumSegments;
     }
 
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startObject();

x-pack/protocol/src/main/java/org/elasticsearch/protocol/xpack/indexlifecycle/LifecycleAction.java

@@ -19,7 +19,12 @@
 package org.elasticsearch.protocol.xpack.indexlifecycle;
 
 /**
- * Marker interface for index lifecycle management actions
+ * interface for index lifecycle management actions
  */
-public class LifecycleAction {
+public interface LifecycleAction {
+
+    /**
+     * @return the name of this action
+     */
+    String getName();
 }

x-pack/protocol/src/main/java/org/elasticsearch/protocol/xpack/indexlifecycle/LifecyclePolicy.java

@@ -0,0 +1,149 @@
+/*
+ * 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.protocol.xpack.indexlifecycle;
+
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.util.set.Sets;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+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.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Represents the lifecycle of an index from creation to deletion. A
+ * {@link LifecyclePolicy} is made up of a set of {@link Phase}s which it will
+ * move through.
+ */
+public class LifecyclePolicy implements ToXContentObject {
+    static final ParseField PHASES_FIELD = new ParseField("phases");
+
+    @SuppressWarnings("unchecked")
+    public static ConstructingObjectParser<LifecyclePolicy, String> PARSER = new ConstructingObjectParser<>("lifecycle_policy", false,
+        (a, name) -> {
+            List<Phase> phases = (List<Phase>) a[0];
+            Map<String, Phase> phaseMap = phases.stream().collect(Collectors.toMap(Phase::getName, Function.identity()));
+            return new LifecyclePolicy(name, phaseMap);
+        });
+    static {
+        PARSER.declareNamedObjects(ConstructingObjectParser.constructorArg(), (p, c, n) -> Phase.parse(p, n), v -> {
+            throw new IllegalArgumentException("ordered " + PHASES_FIELD.getPreferredName() + " are not supported");
+        }, PHASES_FIELD);
+    }
+
+    private final String name;
+    private final Map<String, Phase> phases;
+
+    /**
+     * @param name
+     *            the name of this {@link LifecyclePolicy}
+     * @param phases
+     *            a {@link Map} of {@link Phase}s which make up this
+     *            {@link LifecyclePolicy}.
+     */
+    public LifecyclePolicy(String name, Map<String, Phase> phases) {
+        this.name = name;
+        this.phases = phases;
+        validate(phases.values());
+    }
+
+    public static LifecyclePolicy parse(XContentParser parser, String name) {
+        return PARSER.apply(parser, name);
+    }
+
+    /**
+     * @return the name of this {@link LifecyclePolicy}
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * @return the {@link Phase}s for this {@link LifecyclePolicy} in the order
+     *         in which they will be executed.
+     */
+    public Map<String, Phase> getPhases() {
+        return phases;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.startObject(PHASES_FIELD.getPreferredName());
+        for (Phase phase : phases.values()) {
+            builder.field(phase.getName(), phase);
+        }
+        builder.endObject();
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, phases);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (obj.getClass() != getClass()) {
+            return false;
+        }
+        LifecyclePolicy other = (LifecyclePolicy) obj;
+        return Objects.equals(name, other.name) &&
+            Objects.equals(phases, other.phases);
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(this, true, true);
+    }
+
+    static void validate(Collection<Phase> phases) {
+        Set<String> allowedPhases = Sets.newHashSet("hot", "warm", "cold", "delete");
+        Map<String, Set<String>> allowedActions = new HashMap<>(allowedPhases.size());
+        allowedActions.put("hot", Sets.newHashSet(RolloverAction.NAME));
+        allowedActions.put("warm", Sets.newHashSet(AllocateAction.NAME, ForceMergeAction.NAME, ReadOnlyAction.NAME, ShrinkAction.NAME));
+        allowedActions.put("cold", Sets.newHashSet(AllocateAction.NAME));
+        allowedActions.put("delete", Sets.newHashSet(DeleteAction.NAME));
+        phases.forEach(phase -> {
+            if (allowedPhases.contains(phase.getName()) == false) {
+                throw new IllegalArgumentException("Lifecycle does not support phase [" + phase.getName() + "]");
+            }
+            phase.getActions().forEach((actionName, action) -> {
+                if (allowedActions.get(phase.getName()).contains(actionName) == false) {
+                    throw new IllegalArgumentException("invalid action [" + actionName + "] " +
+                        "defined in phase [" + phase.getName() +"]");
+                }
+            });
+        });
+    }
+}