diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java index ece8c6b002316..f435281406c1c 100644 --- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java @@ -5,142 +5,93 @@ */ package org.elasticsearch.xpack.core.enrich; +import java.io.IOException; +import java.util.Objects; + +import org.elasticsearch.Version; import org.elasticsearch.common.ParseField; import org.elasticsearch.common.Strings; -import org.elasticsearch.common.bytes.BytesReference; import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.common.xcontent.ConstructingObjectParser; -import org.elasticsearch.common.xcontent.ToXContent; +import org.elasticsearch.common.xcontent.ObjectParser; import org.elasticsearch.common.xcontent.ToXContentFragment; import org.elasticsearch.common.xcontent.XContentBuilder; -import org.elasticsearch.common.xcontent.XContentHelper; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.common.xcontent.XContentType; - -import java.io.IOException; -import java.util.List; -import java.util.Map; -import java.util.Objects; -/** - * Represents an enrich policy including its configuration. - */ -public final class EnrichPolicy implements Writeable, ToXContentFragment { +public class EnrichPolicy implements Writeable, ToXContentFragment { public static final String ENRICH_INDEX_NAME_BASE = ".enrich-"; - public static final String EXACT_MATCH_TYPE = "exact_match"; - public static final String[] SUPPORTED_POLICY_TYPES = new String[]{EXACT_MATCH_TYPE}; - - private static final ParseField TYPE = new ParseField("type"); - private static final ParseField QUERY = new ParseField("query"); - private static final ParseField INDICES = new ParseField("indices"); - private static final ParseField ENRICH_KEY = new ParseField("enrich_key"); - private static final ParseField ENRICH_VALUES = new ParseField("enrich_values"); + private static final ParseField NAME = new ParseField("name"); + private static final ParseField VERSION_CREATED = new ParseField("version_created"); + private static final ParseField DEFINITION = new ParseField("definition"); - @SuppressWarnings("unchecked") private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy", args -> new EnrichPolicy( (String) args[0], - (QuerySource) args[1], - (List) args[2], - (String) args[3], - (List) args[4] + (Version) args[1], + (EnrichPolicyDefinition) args[2] ) ); static { - declareParserOptions(PARSER); - } - - private static void declareParserOptions(ConstructingObjectParser parser) { - parser.declareString(ConstructingObjectParser.constructorArg(), TYPE); - parser.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> { - XContentBuilder contentBuilder = XContentBuilder.builder(p.contentType().xContent()); - contentBuilder.generator().copyCurrentStructure(p); - return new QuerySource(BytesReference.bytes(contentBuilder), contentBuilder.contentType()); - }, QUERY); - parser.declareStringArray(ConstructingObjectParser.constructorArg(), INDICES); - parser.declareString(ConstructingObjectParser.constructorArg(), ENRICH_KEY); - parser.declareStringArray(ConstructingObjectParser.constructorArg(), ENRICH_VALUES); + PARSER.declareString(ConstructingObjectParser.constructorArg(), NAME); + PARSER.declareField(ConstructingObjectParser.constructorArg(), (p, c) -> Version.fromString(p.text()), VERSION_CREATED, + ObjectParser.ValueType.STRING); + PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, c) -> EnrichPolicyDefinition.fromXContent(p), DEFINITION); } public static EnrichPolicy fromXContent(XContentParser parser) throws IOException { return PARSER.parse(parser, null); } - private final String type; - private final QuerySource query; - private final List indices; - private final String enrichKey; - private final List enrichValues; + private final String name; + private final Version versionCreated; + private final EnrichPolicyDefinition definition; public EnrichPolicy(StreamInput in) throws IOException { this( in.readString(), - in.readOptionalWriteable(QuerySource::new), - in.readStringList(), - in.readString(), - in.readStringList() + Version.readVersion(in), + new EnrichPolicyDefinition(in) ); } - public EnrichPolicy(String type, - QuerySource query, - List indices, - String enrichKey, - List enrichValues) { - this.type = type; - this.query= query; - this.indices = indices; - this.enrichKey = enrichKey; - this.enrichValues = enrichValues; + public EnrichPolicy(String name, Version versionCreated, EnrichPolicyDefinition definition) { + this.name = name; + this.versionCreated = versionCreated; + this.definition = definition; } - public String getType() { - return type; + public String getName() { + return name; } - public QuerySource getQuery() { - return query; + public Version getVersionCreated() { + return versionCreated; } - public List getIndices() { - return indices; - } - - public String getEnrichKey() { - return enrichKey; - } - - public List getEnrichValues() { - return enrichValues; - } - - public static String getBaseName(String policyName) { - return ENRICH_INDEX_NAME_BASE + policyName; + public EnrichPolicyDefinition getDefinition() { + return definition; } @Override public void writeTo(StreamOutput out) throws IOException { - out.writeString(type); - out.writeOptionalWriteable(query); - out.writeStringCollection(indices); - out.writeString(enrichKey); - out.writeStringCollection(enrichValues); + out.writeString(name); + Version.writeVersion(versionCreated, out); + definition.writeTo(out); } @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { - builder.field(TYPE.getPreferredName(), type); - if (query != null) { - builder.field(QUERY.getPreferredName(), query.getQueryAsMap()); - } - builder.array(INDICES.getPreferredName(), indices.toArray(new String[0])); - builder.field(ENRICH_KEY.getPreferredName(), enrichKey); - builder.array(ENRICH_VALUES.getPreferredName(), enrichValues.toArray(new String[0])); + builder.field(NAME.getPreferredName(), name); + builder.field(VERSION_CREATED.getPreferredName()); + versionCreated.toXContent(builder, params); + builder.startObject(DEFINITION.getPreferredName()); + definition.toXContent(builder, params); + builder.endObject(); return builder; } @@ -149,149 +100,18 @@ public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; EnrichPolicy policy = (EnrichPolicy) o; - return type.equals(policy.type) && - Objects.equals(query, policy.query) && - indices.equals(policy.indices) && - enrichKey.equals(policy.enrichKey) && - enrichValues.equals(policy.enrichValues); + return name.equals(policy.name) && + Objects.equals(versionCreated, policy.versionCreated) && + Objects.equals(definition, policy.definition); } @Override public int hashCode() { - return Objects.hash( - type, - query, - indices, - enrichKey, - enrichValues - ); + return Objects.hash(name, versionCreated, definition); } + @Override public String toString() { return Strings.toString(this); } - - public static class QuerySource implements Writeable { - - private final BytesReference query; - private final XContentType contentType; - - QuerySource(StreamInput in) throws IOException { - this(in.readBytesReference(), in.readEnum(XContentType.class)); - } - - public QuerySource(BytesReference query, XContentType contentType) { - this.query = query; - this.contentType = contentType; - } - - public BytesReference getQuery() { - return query; - } - - public Map getQueryAsMap() { - return XContentHelper.convertToMap(query, true, contentType).v2(); - } - - public XContentType getContentType() { - return contentType; - } - - @Override - public void writeTo(StreamOutput out) throws IOException { - out.writeBytesReference(query); - out.writeEnum(contentType); - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - QuerySource that = (QuerySource) o; - return query.equals(that.query) && - contentType == that.contentType; - } - - @Override - public int hashCode() { - return Objects.hash(query, contentType); - } - } - - public static class NamedPolicy implements Writeable, ToXContent { - - static final ParseField NAME = new ParseField("name"); - @SuppressWarnings("unchecked") - static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("named_policy", - args -> new NamedPolicy( - (String) args[0], - new EnrichPolicy((String) args[1], - (QuerySource) args[2], - (List) args[3], - (String) args[4], - (List) args[5]) - ) - ); - - static { - PARSER.declareString(ConstructingObjectParser.constructorArg(), NAME); - declareParserOptions(PARSER); - } - - private final String name; - private final EnrichPolicy policy; - - public NamedPolicy(String name, EnrichPolicy policy) { - this.name = name; - this.policy = policy; - } - - public NamedPolicy(StreamInput in) throws IOException { - name = in.readString(); - policy = new EnrichPolicy(in); - } - - public String getName() { - return name; - } - - public EnrichPolicy getPolicy() { - return policy; - } - - @Override - public void writeTo(StreamOutput out) throws IOException { - out.writeString(name); - policy.writeTo(out); - } - - @Override - public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { - builder.startObject(); - { - builder.field(NAME.getPreferredName(), name); - policy.toXContent(builder, params); - } - builder.endObject(); - return builder; - } - - public static NamedPolicy fromXContent(XContentParser parser) throws IOException { - return PARSER.parse(parser, null); - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - NamedPolicy that = (NamedPolicy) o; - return name.equals(that.name) && - policy.equals(that.policy); - } - - @Override - public int hashCode() { - return Objects.hash(name, policy); - } - } } diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicyDefinition.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicyDefinition.java new file mode 100644 index 0000000000000..54141820c3d53 --- /dev/null +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicyDefinition.java @@ -0,0 +1,219 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ +package org.elasticsearch.xpack.core.enrich; + +import org.elasticsearch.common.ParseField; +import org.elasticsearch.common.Strings; +import org.elasticsearch.common.bytes.BytesReference; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; +import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.common.xcontent.ConstructingObjectParser; +import org.elasticsearch.common.xcontent.ToXContentFragment; +import org.elasticsearch.common.xcontent.XContentBuilder; +import org.elasticsearch.common.xcontent.XContentHelper; +import org.elasticsearch.common.xcontent.XContentParser; +import org.elasticsearch.common.xcontent.XContentType; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** + * Represents an enrich policy including its configuration. + */ +public final class EnrichPolicyDefinition implements Writeable, ToXContentFragment { + + private static final String ENRICH_INDEX_NAME_BASE = ".enrich-"; + + public static final String EXACT_MATCH_TYPE = "exact_match"; + public static final String[] SUPPORTED_POLICY_TYPES = new String[]{EXACT_MATCH_TYPE}; + + private static final ParseField TYPE = new ParseField("type"); + private static final ParseField QUERY = new ParseField("query"); + private static final ParseField INDICES = new ParseField("indices"); + private static final ParseField ENRICH_KEY = new ParseField("enrich_key"); + private static final ParseField ENRICH_VALUES = new ParseField("enrich_values"); + + @SuppressWarnings("unchecked") + private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy_definition", + args -> new EnrichPolicyDefinition( + (String) args[0], + (QuerySource) args[1], + (List) args[2], + (String) args[3], + (List) args[4] + ) + ); + + static { + declareParserOptions(PARSER); + } + + private static void declareParserOptions(ConstructingObjectParser parser) { + parser.declareString(ConstructingObjectParser.constructorArg(), TYPE); + parser.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> { + XContentBuilder contentBuilder = XContentBuilder.builder(p.contentType().xContent()); + contentBuilder.generator().copyCurrentStructure(p); + return new QuerySource(BytesReference.bytes(contentBuilder), contentBuilder.contentType()); + }, QUERY); + parser.declareStringArray(ConstructingObjectParser.constructorArg(), INDICES); + parser.declareString(ConstructingObjectParser.constructorArg(), ENRICH_KEY); + parser.declareStringArray(ConstructingObjectParser.constructorArg(), ENRICH_VALUES); + } + + public static EnrichPolicyDefinition fromXContent(XContentParser parser) throws IOException { + return PARSER.parse(parser, null); + } + + private final String type; + private final QuerySource query; + private final List indices; + private final String enrichKey; + private final List enrichValues; + + public EnrichPolicyDefinition(StreamInput in) throws IOException { + this( + in.readString(), + in.readOptionalWriteable(QuerySource::new), + in.readStringList(), + in.readString(), + in.readStringList() + ); + } + + public EnrichPolicyDefinition(String type, + QuerySource query, + List indices, + String enrichKey, + List enrichValues) { + this.type = type; + this.query= query; + this.indices = indices; + this.enrichKey = enrichKey; + this.enrichValues = enrichValues; + } + + public String getType() { + return type; + } + + public QuerySource getQuery() { + return query; + } + + public List getIndices() { + return indices; + } + + public String getEnrichKey() { + return enrichKey; + } + + public List getEnrichValues() { + return enrichValues; + } + + public static String getBaseName(String policyName) { + return ENRICH_INDEX_NAME_BASE + policyName; + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + out.writeString(type); + out.writeOptionalWriteable(query); + out.writeStringCollection(indices); + out.writeString(enrichKey); + out.writeStringCollection(enrichValues); + } + + @Override + public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { + builder.field(TYPE.getPreferredName(), type); + if (query != null) { + builder.field(QUERY.getPreferredName(), query.getQueryAsMap()); + } + builder.array(INDICES.getPreferredName(), indices.toArray(new String[0])); + builder.field(ENRICH_KEY.getPreferredName(), enrichKey); + builder.array(ENRICH_VALUES.getPreferredName(), enrichValues.toArray(new String[0])); + return builder; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + EnrichPolicyDefinition policy = (EnrichPolicyDefinition) o; + return type.equals(policy.type) && + Objects.equals(query, policy.query) && + indices.equals(policy.indices) && + enrichKey.equals(policy.enrichKey) && + enrichValues.equals(policy.enrichValues); + } + + @Override + public int hashCode() { + return Objects.hash( + type, + query, + indices, + enrichKey, + enrichValues + ); + } + + public String toString() { + return Strings.toString(this); + } + + public static class QuerySource implements Writeable { + + private final BytesReference query; + private final XContentType contentType; + + QuerySource(StreamInput in) throws IOException { + this(in.readBytesReference(), in.readEnum(XContentType.class)); + } + + public QuerySource(BytesReference query, XContentType contentType) { + this.query = query; + this.contentType = contentType; + } + + public BytesReference getQuery() { + return query; + } + + public Map getQueryAsMap() { + return XContentHelper.convertToMap(query, true, contentType).v2(); + } + + public XContentType getContentType() { + return contentType; + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + out.writeBytesReference(query); + out.writeEnum(contentType); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + QuerySource that = (QuerySource) o; + return query.equals(that.query) && + contentType == that.contentType; + } + + @Override + public int hashCode() { + return Objects.hash(query, contentType); + } + } +} diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/ListEnrichPolicyAction.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/ListEnrichPolicyAction.java index 93aa9abd45c15..25683e5070add 100644 --- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/ListEnrichPolicyAction.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/ListEnrichPolicyAction.java @@ -16,10 +16,10 @@ import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.io.IOException; +import java.util.Comparator; import java.util.List; import java.util.Map; import java.util.Objects; -import java.util.TreeMap; import java.util.stream.Collectors; public class ListEnrichPolicyAction extends ActionType { @@ -47,17 +47,19 @@ public ActionRequestValidationException validate() { public static class Response extends ActionResponse implements ToXContentObject { - private final List policies; + private final List policies; public Response(Map policies) { Objects.requireNonNull(policies, "policies cannot be null"); // use a treemap to guarantee ordering in the set, then transform it to the list of named policies - this.policies = new TreeMap<>(policies).entrySet().stream() - .map(entry -> new EnrichPolicy.NamedPolicy(entry.getKey(), entry.getValue())).collect(Collectors.toList()); + this.policies = policies.entrySet().stream() + .sorted(Comparator.comparing(Map.Entry::getKey)) + .map(Map.Entry::getValue) + .collect(Collectors.toList()); } public Response(StreamInput in) throws IOException { - policies = in.readList(EnrichPolicy.NamedPolicy::new); + policies = in.readList(EnrichPolicy::new); } @Override @@ -71,8 +73,10 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws { builder.startArray("policies"); { - for (EnrichPolicy.NamedPolicy policy: policies) { + for (EnrichPolicy policy: policies) { + builder.startObject(); policy.toXContent(builder, params); + builder.endObject(); } } builder.endArray(); @@ -82,7 +86,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws return builder; } - public List getPolicies() { + public List getPolicies() { return policies; } diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/PutEnrichPolicyAction.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/PutEnrichPolicyAction.java index 10c18932be28a..d634edf9d8650 100644 --- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/PutEnrichPolicyAction.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/PutEnrichPolicyAction.java @@ -12,7 +12,7 @@ import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.io.IOException; import java.util.Objects; @@ -27,15 +27,15 @@ private PutEnrichPolicyAction() { } public static Request fromXContent(XContentParser parser, String name) throws IOException { - return new Request(name, EnrichPolicy.fromXContent(parser)); + return new Request(name, EnrichPolicyDefinition.fromXContent(parser)); } public static class Request extends MasterNodeRequest { - private final EnrichPolicy policy; + private final EnrichPolicyDefinition policy; private final String name; - public Request(String name, EnrichPolicy policy) { + public Request(String name, EnrichPolicyDefinition policy) { this.name = Objects.requireNonNull(name, "name cannot be null"); this.policy = policy; } @@ -43,7 +43,7 @@ public Request(String name, EnrichPolicy policy) { public Request(StreamInput in) throws IOException { super(in); name = in.readString(); - policy = new EnrichPolicy(in); + policy = new EnrichPolicyDefinition(in); } @Override @@ -57,7 +57,7 @@ public String getName() { return name; } - public EnrichPolicy getPolicy() { + public EnrichPolicyDefinition getPolicy() { return policy; } diff --git a/x-pack/plugin/enrich/qa/rest/src/test/resources/rest-api-spec/test/enrich/10_basic.yml b/x-pack/plugin/enrich/qa/rest/src/test/resources/rest-api-spec/test/enrich/10_basic.yml index 42d0020049a7d..0b2094832b0b8 100644 --- a/x-pack/plugin/enrich/qa/rest/src/test/resources/rest-api-spec/test/enrich/10_basic.yml +++ b/x-pack/plugin/enrich/qa/rest/src/test/resources/rest-api-spec/test/enrich/10_basic.yml @@ -19,19 +19,20 @@ - do: enrich.get_policy: name: policy-crud - - match: { type: exact_match } - - match: { indices: ["bar*"] } - - match: { enrich_key: baz } - - match: { enrich_values: ["a", "b"] } + - match: { name: policy-crud } + - match: { definition.type: exact_match } + - match: { definition.indices: ["bar*"] } + - match: { definition.enrich_key: baz } + - match: { definition.enrich_values: ["a", "b"] } - do: enrich.list_policy: {} - length: { policies: 1 } - match: { policies.0.name: policy-crud } - - match: { policies.0.type: exact_match } - - match: { policies.0.indices: ["bar*"] } - - match: { policies.0.enrich_key: baz } - - match: { policies.0.enrich_values: ["a", "b"] } + - match: { policies.0.definition.type: exact_match } + - match: { policies.0.definition.indices: ["bar*"] } + - match: { policies.0.definition.enrich_key: baz } + - match: { policies.0.definition.enrich_values: ["a", "b"] } - do: enrich.delete_policy: diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutor.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutor.java index 31d01bc23299e..be9b3c47552a9 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutor.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutor.java @@ -15,6 +15,7 @@ import org.elasticsearch.common.settings.Settings; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; public class EnrichPolicyExecutor { @@ -64,7 +65,8 @@ public void onFailure(Exception e) { } } - protected Runnable createPolicyRunner(String policyName, EnrichPolicy policy, ActionListener listener) { + protected Runnable createPolicyRunner(String policyName, EnrichPolicyDefinition policy, + ActionListener listener) { return new EnrichPolicyRunner(policyName, policy, listener, clusterService, client, indexNameExpressionResolver, nowSupplier, fetchSize); } @@ -75,11 +77,11 @@ public void runPolicy(String policyId, ActionListener lis if (policy == null) { throw new IllegalArgumentException("Policy execution failed. Could not locate policy with id [" + policyId + "]"); } else { - runPolicy(policyId, policy, listener); + runPolicy(policyId, policy.getDefinition(), listener); } } - public void runPolicy(String policyName, EnrichPolicy policy, ActionListener listener) { + public void runPolicy(String policyName, EnrichPolicyDefinition policy, ActionListener listener) { policyLocks.lockPolicy(policyName); try { Runnable runnable = createPolicyRunner(policyName, policy, new PolicyUnlockingListener(policyName, listener)); diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceService.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceService.java index d4b575f8aa340..118ba0814076f 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceService.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceService.java @@ -33,6 +33,7 @@ import org.elasticsearch.threadpool.Scheduler; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; public class EnrichPolicyMaintenanceService implements LocalNodeMasterListener { @@ -180,7 +181,7 @@ private boolean shouldRemoveIndex(GetIndexResponse getIndexResponse, Map aliasMetadata = getIndexResponse.aliases().get(indexName); if (aliasMetadata == null) { logger.debug("Enrich index [{}] is not marked as a live index since it has no alias information", indexName); diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunner.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunner.java index ed247add4b999..1402b69757ecc 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunner.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunner.java @@ -49,7 +49,7 @@ import org.elasticsearch.index.reindex.ReindexAction; import org.elasticsearch.index.reindex.ReindexRequest; import org.elasticsearch.search.builder.SearchSourceBuilder; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import static org.elasticsearch.xpack.enrich.ExactMatchProcessor.ENRICH_KEY_FIELD_NAME; @@ -60,7 +60,7 @@ public class EnrichPolicyRunner implements Runnable { static final String ENRICH_POLICY_FIELD_NAME = "enrich_policy"; private final String policyName; - private final EnrichPolicy policy; + private final EnrichPolicyDefinition policy; private final ActionListener listener; private final ClusterService clusterService; private final Client client; @@ -68,7 +68,7 @@ public class EnrichPolicyRunner implements Runnable { private final LongSupplier nowSupplier; private final int fetchSize; - EnrichPolicyRunner(String policyName, EnrichPolicy policy, ActionListener listener, + EnrichPolicyRunner(String policyName, EnrichPolicyDefinition policy, ActionListener listener, ClusterService clusterService, Client client, IndexNameExpressionResolver indexNameExpressionResolver, LongSupplier nowSupplier, int fetchSize) { this.policyName = policyName; @@ -191,10 +191,10 @@ private void validateField(Map properties, String fieldName, boolean field } } - private XContentBuilder resolveEnrichMapping(final EnrichPolicy policy) { - // Currently the only supported policy type is EnrichPolicy.EXACT_MATCH_TYPE, which is a keyword type + private XContentBuilder resolveEnrichMapping(final EnrichPolicyDefinition policy) { + // Currently the only supported policy type is EnrichPolicyDefinition.EXACT_MATCH_TYPE, which is a keyword type String keyType; - if (EnrichPolicy.EXACT_MATCH_TYPE.equals(policy.getType())) { + if (EnrichPolicyDefinition.EXACT_MATCH_TYPE.equals(policy.getType())) { keyType = "keyword"; } else { throw new ElasticsearchException("Unrecognized enrich policy type [{}]", policy.getType()); @@ -230,7 +230,7 @@ private XContentBuilder resolveEnrichMapping(final EnrichPolicy policy) { private void prepareAndCreateEnrichIndex() { long nowTimestamp = nowSupplier.getAsLong(); - String enrichIndexName = EnrichPolicy.getBaseName(policyName) + "-" + nowTimestamp; + String enrichIndexName = EnrichPolicyDefinition.getBaseName(policyName) + "-" + nowTimestamp; Settings enrichIndexSettings = Settings.builder() .put("index.number_of_replicas", 0) .build(); @@ -355,7 +355,7 @@ public void onFailure(Exception e) { } private void updateEnrichPolicyAlias(final String destinationIndexName) { - String enrichIndexBase = EnrichPolicy.getBaseName(policyName); + String enrichIndexBase = EnrichPolicyDefinition.getBaseName(policyName); logger.debug("Policy [{}]: Promoting new enrich index [{}] to alias [{}]", policyName, destinationIndexName, enrichIndexBase); GetAliasesRequest aliasRequest = new GetAliasesRequest(enrichIndexBase); String[] concreteIndices = indexNameExpressionResolver.concreteIndexNames(clusterService.state(), aliasRequest); diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactory.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactory.java index df4bed9c57587..cec2948e82245 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactory.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactory.java @@ -10,6 +10,7 @@ import org.elasticsearch.ingest.ConfigurationUtils; import org.elasticsearch.ingest.Processor; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.util.List; import java.util.Map; @@ -33,8 +34,9 @@ public Processor create(Map processorFactories, Strin if (policy == null) { throw new IllegalArgumentException("policy [" + policyName + "] does not exists"); } + EnrichPolicyDefinition policyDefinition = policy.getDefinition(); - String enrichKey = ConfigurationUtils.readStringProperty(TYPE, tag, config, "enrich_key", policy.getEnrichKey()); + String enrichKey = ConfigurationUtils.readStringProperty(TYPE, tag, config, "enrich_key", policyDefinition.getEnrichKey()); boolean ignoreMissing = ConfigurationUtils.readBooleanProperty(TYPE, tag, config, "ignore_missing", false); final List specifications; @@ -45,17 +47,17 @@ public Processor create(Map processorFactories, Strin .collect(Collectors.toList()); for (EnrichSpecification specification : specifications) { - if (policy.getEnrichValues().contains(specification.sourceField) == false) { + if (policyDefinition.getEnrichValues().contains(specification.sourceField) == false) { throw new IllegalArgumentException("source field [" + specification.sourceField + "] does not exist in policy [" + policyName + "]"); } } - switch (policy.getType()) { - case EnrichPolicy.EXACT_MATCH_TYPE: + switch (policyDefinition.getType()) { + case EnrichPolicyDefinition.EXACT_MATCH_TYPE: return new ExactMatchProcessor(tag, client, policyName, enrichKey, ignoreMissing, specifications); default: - throw new IllegalArgumentException("unsupported policy type [" + policy.getType() + "]"); + throw new IllegalArgumentException("unsupported policy type [" + policyDefinition.getType() + "]"); } } diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichStore.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichStore.java index 36b399b3d3d07..1031f8588877c 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichStore.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichStore.java @@ -98,7 +98,7 @@ public static EnrichPolicy getPolicy(String name, ClusterState state) { * Gets all policies in the cluster. * * @param state the cluster state - * @return a Map of policyName, EnrichPolicy of the policies + * @return a Map of policyName, EnrichPolicyDefinition of the policies */ public static Map getPolicies(ClusterState state) { final Map policies; diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/ExactMatchProcessor.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/ExactMatchProcessor.java index 39f81fac78c92..2b8079761e32f 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/ExactMatchProcessor.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/ExactMatchProcessor.java @@ -16,7 +16,7 @@ import org.elasticsearch.ingest.IngestDocument; import org.elasticsearch.search.SearchHit; import org.elasticsearch.search.builder.SearchSourceBuilder; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.enrich.EnrichProcessorFactory.EnrichSpecification; import org.elasticsearch.xpack.enrich.action.CoordinatorProxyAction; @@ -84,7 +84,7 @@ public void execute(IngestDocument ingestDocument, BiConsumer listener ) { - EnrichStore.putPolicy(request.getName(), request.getPolicy(), clusterService, e -> { + EnrichPolicy enrichPolicy = new EnrichPolicy(request.getName(), Version.CURRENT, request.getPolicy()); + EnrichStore.putPolicy(request.getName(), enrichPolicy, clusterService, e -> { if (e == null) { listener.onResponse(new AcknowledgedResponse(true)); } else { diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/BasicEnrichTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/BasicEnrichTests.java index 2c239ad6d5f4b..07d4e819382dc 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/BasicEnrichTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/BasicEnrichTests.java @@ -17,7 +17,7 @@ import org.elasticsearch.index.reindex.ReindexPlugin; import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.ESSingleNodeTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; @@ -45,8 +45,9 @@ public void testIngestDataWithEnrichProcessor() { List keys = createSourceIndex(numDocs); String policyName = "my-policy"; - EnrichPolicy enrichPolicy = - new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); + EnrichPolicyDefinition enrichPolicy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(SOURCE_INDEX_NAME), KEY_FIELD, + List.of(DECORATE_FIELDS)); PutEnrichPolicyAction.Request request = new PutEnrichPolicyAction.Request(policyName, enrichPolicy); client().execute(PutEnrichPolicyAction.INSTANCE, request).actionGet(); client().execute(ExecuteEnrichPolicyAction.INSTANCE, new ExecuteEnrichPolicyAction.Request(policyName)).actionGet(); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMultiNodeIT.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMultiNodeIT.java index ff8262d6ceb04..67bf82005518d 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMultiNodeIT.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMultiNodeIT.java @@ -22,7 +22,7 @@ import org.elasticsearch.node.Node; import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.ESIntegTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; @@ -61,16 +61,18 @@ public void testEnrichAPIs() { for (int i = 0; i < numPolicies; i++) { String policyName = POLICY_NAME + i; - EnrichPolicy enrichPolicy = - new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); + EnrichPolicyDefinition enrichPolicy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, + List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); PutEnrichPolicyAction.Request request = new PutEnrichPolicyAction.Request(policyName, enrichPolicy); client().execute(PutEnrichPolicyAction.INSTANCE, request).actionGet(); client().execute(ExecuteEnrichPolicyAction.INSTANCE, new ExecuteEnrichPolicyAction.Request(policyName)).actionGet(); - EnrichPolicy result = - client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request(policyName)).actionGet().getPolicy(); + EnrichPolicyDefinition result = client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request(policyName)) + .actionGet() + .getPolicy() + .getDefinition(); assertThat(result, equalTo(enrichPolicy)); - String enrichIndexPrefix = EnrichPolicy.getBaseName(policyName) + "*"; + String enrichIndexPrefix = EnrichPolicyDefinition.getBaseName(policyName) + "*"; refresh(enrichIndexPrefix); SearchResponse searchResponse = client().search(new SearchRequest(enrichIndexPrefix)).actionGet(); assertThat(searchResponse.getHits().getTotalHits().relation, equalTo(TotalHits.Relation.EQUAL_TO)); @@ -156,8 +158,8 @@ private static List createSourceIndex(int numDocs) { } private static void createAndExecutePolicy() { - EnrichPolicy enrichPolicy = - new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); + EnrichPolicyDefinition enrichPolicy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, + List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); PutEnrichPolicyAction.Request request = new PutEnrichPolicyAction.Request(POLICY_NAME, enrichPolicy); client().execute(PutEnrichPolicyAction.INSTANCE, request).actionGet(); client().execute(ExecuteEnrichPolicyAction.INSTANCE, new ExecuteEnrichPolicyAction.Request(POLICY_NAME)).actionGet(); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyDefinitionTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyDefinitionTests.java new file mode 100644 index 0000000000000..8a666a90be3e3 --- /dev/null +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyDefinitionTests.java @@ -0,0 +1,96 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License; + * you may not use this file except in compliance with the Elastic License. + */ +package org.elasticsearch.xpack.enrich; + +import org.elasticsearch.common.bytes.BytesArray; +import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.common.xcontent.ToXContent; +import org.elasticsearch.common.xcontent.XContentBuilder; +import org.elasticsearch.common.xcontent.XContentFactory; +import org.elasticsearch.common.xcontent.XContentParser; +import org.elasticsearch.common.xcontent.XContentType; +import org.elasticsearch.index.query.MatchAllQueryBuilder; +import org.elasticsearch.index.query.QueryBuilder; +import org.elasticsearch.index.query.TermQueryBuilder; +import org.elasticsearch.test.AbstractSerializingTestCase; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.util.Arrays; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.nullValue; + +public class EnrichPolicyDefinitionTests extends AbstractSerializingTestCase { + + @Override + protected EnrichPolicyDefinition doParseInstance(XContentParser parser) throws IOException { + return EnrichPolicyDefinition.fromXContent(parser); + } + + @Override + protected EnrichPolicyDefinition createTestInstance() { + return randomEnrichPolicyDefinition(randomFrom(XContentType.values())); + } + + @Override + protected EnrichPolicyDefinition createXContextTestInstance(XContentType xContentType) { + return randomEnrichPolicyDefinition(xContentType); + } + + public static EnrichPolicyDefinition randomEnrichPolicyDefinition(XContentType xContentType) { + final QueryBuilder queryBuilder; + if (randomBoolean()) { + queryBuilder = new MatchAllQueryBuilder(); + } else { + queryBuilder = new TermQueryBuilder(randomAlphaOfLength(4), randomAlphaOfLength(4)); + } + + final ByteArrayOutputStream out = new ByteArrayOutputStream(); + try (XContentBuilder xContentBuilder = XContentFactory.contentBuilder(xContentType, out)) { + XContentBuilder content = queryBuilder.toXContent(xContentBuilder, ToXContent.EMPTY_PARAMS); + content.flush(); + EnrichPolicyDefinition.QuerySource querySource = new EnrichPolicyDefinition.QuerySource( + new BytesArray(out.toByteArray()), content.contentType()); + return new EnrichPolicyDefinition( + randomFrom(EnrichPolicyDefinition.SUPPORTED_POLICY_TYPES), + randomBoolean() ? querySource : null, + Arrays.asList(generateRandomStringArray(8, 4, false, false)), + randomAlphaOfLength(4), + Arrays.asList(generateRandomStringArray(8, 4, false, false)) + ); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + + } + + @Override + protected Writeable.Reader instanceReader() { + return EnrichPolicyDefinition::new; + } + + @Override + protected void assertEqualInstances(EnrichPolicyDefinition expectedInstance, EnrichPolicyDefinition newInstance) { + assertNotSame(expectedInstance, newInstance); + assertEqualPolicyDefinitions(expectedInstance, newInstance); + } + + public static void assertEqualPolicyDefinitions(EnrichPolicyDefinition expectedInstance, EnrichPolicyDefinition newInstance) { + assertThat(newInstance.getType(), equalTo(expectedInstance.getType())); + if (newInstance.getQuery() != null) { + // testFromXContent, always shuffles the xcontent and then byte wise the query is different, so we check the parsed version: + assertThat(newInstance.getQuery().getQueryAsMap(), equalTo(expectedInstance.getQuery().getQueryAsMap())); + } else { + assertThat(expectedInstance.getQuery(), nullValue()); + } + assertThat(newInstance.getIndices(), equalTo(expectedInstance.getIndices())); + assertThat(newInstance.getEnrichKey(), equalTo(expectedInstance.getEnrichKey())); + assertThat(newInstance.getEnrichValues(), equalTo(expectedInstance.getEnrichValues())); + } +} diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutorTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutorTests.java index 15496e49fa767..b3bc041c34311 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutorTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutorTests.java @@ -21,7 +21,7 @@ import org.elasticsearch.test.ESTestCase; import org.elasticsearch.threadpool.TestThreadPool; import org.elasticsearch.threadpool.ThreadPool; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.junit.AfterClass; import org.junit.BeforeClass; @@ -83,14 +83,15 @@ private static class EnrichPolicyTestExecutor extends EnrichPolicyExecutor { } private CountDownLatch currentLatch; - CountDownLatch testRunPolicy(String policyName, EnrichPolicy policy, ActionListener listener) { + CountDownLatch testRunPolicy(String policyName, EnrichPolicyDefinition policy, ActionListener listener) { currentLatch = new CountDownLatch(1); runPolicy(policyName, policy, listener); return currentLatch; } @Override - protected Runnable createPolicyRunner(String policyName, EnrichPolicy policy, ActionListener listener) { + protected Runnable createPolicyRunner(String policyName, EnrichPolicyDefinition policy, + ActionListener listener) { if (currentLatch == null) { throw new IllegalStateException("Use the testRunPolicy method on this test instance"); } @@ -100,8 +101,8 @@ protected Runnable createPolicyRunner(String policyName, EnrichPolicy policy, Ac public void testNonConcurrentPolicyExecution() throws InterruptedException { String testPolicyName = "test_policy"; - EnrichPolicy testPolicy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of("some_index"), "keyfield", - List.of("valuefield")); + EnrichPolicyDefinition testPolicy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, + List.of("some_index"), "keyfield", List.of("valuefield")); final EnrichPolicyTestExecutor testExecutor = new EnrichPolicyTestExecutor(Settings.EMPTY, null, null, testThreadPool, new IndexNameExpressionResolver(), ESTestCase::randomNonNegativeLong); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceServiceTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceServiceTests.java index ff2aed28b1066..eaf7385a0ee3f 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceServiceTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyMaintenanceServiceTests.java @@ -16,6 +16,7 @@ import java.util.function.BiConsumer; import java.util.function.Consumer; +import org.elasticsearch.Version; import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest; import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest; import org.elasticsearch.action.admin.indices.alias.get.GetAliasesResponse; @@ -29,8 +30,9 @@ import org.elasticsearch.test.ESSingleNodeTestCase; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; -import static org.elasticsearch.xpack.core.enrich.EnrichPolicy.EXACT_MATCH_TYPE; +import static org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition.EXACT_MATCH_TYPE; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.is; @@ -101,17 +103,19 @@ private void assertEnrichIndicesExist(Set activeIndices) { } } - private EnrichPolicy randomPolicy() { + private EnrichPolicyDefinition randomPolicy() { List enrichKeys = new ArrayList<>(); for (int i = 0; i < randomIntBetween(1, 3); i++) { enrichKeys.add(randomAlphaOfLength(10)); } - return new EnrichPolicy(EXACT_MATCH_TYPE, null, List.of(randomAlphaOfLength(10)), randomAlphaOfLength(10), enrichKeys); + return new EnrichPolicyDefinition(EXACT_MATCH_TYPE, null, List.of(randomAlphaOfLength(10)), randomAlphaOfLength(10), enrichKeys); } - private void addPolicy(String policyName, EnrichPolicy policy) throws InterruptedException { - doSyncronously((clusterService, exceptionConsumer) -> - EnrichStore.putPolicy(policyName, policy, clusterService, exceptionConsumer)); + private void addPolicy(String policyName, EnrichPolicyDefinition policyDefinition) throws InterruptedException { + doSyncronously((clusterService, exceptionConsumer) -> { + EnrichPolicy policy = new EnrichPolicy(policyName, Version.CURRENT, policyDefinition); + EnrichStore.putPolicy(policyName, policy, clusterService, exceptionConsumer); + }); } private void removePolicy(String policyName) throws InterruptedException { @@ -136,7 +140,7 @@ private void doSyncronously(BiConsumer> func } private String fakeRunPolicy(String forPolicy) throws IOException { - String newIndexName = EnrichPolicy.getBaseName(forPolicy) + "-" + indexNameAutoIncrementingCounter++; + String newIndexName = EnrichPolicyDefinition.getBaseName(forPolicy) + "-" + indexNameAutoIncrementingCounter++; CreateIndexRequest request = new CreateIndexRequest(newIndexName) .mapping( MapperService.SINGLE_MAPPING_NAME, JsonXContent.contentBuilder() @@ -154,7 +158,7 @@ private String fakeRunPolicy(String forPolicy) throws IOException { } private void promoteFakePolicyIndex(String indexName, String forPolicy) { - String enrichIndexBase = EnrichPolicy.getBaseName(forPolicy); + String enrichIndexBase = EnrichPolicyDefinition.getBaseName(forPolicy); GetAliasesResponse getAliasesResponse = client().admin().indices().getAliases(new GetAliasesRequest(enrichIndexBase)).actionGet(); IndicesAliasesRequest aliasToggleRequest = new IndicesAliasesRequest(); String[] indices = getAliasesResponse.getAliases().keys().toArray(String.class); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunnerTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunnerTests.java index 2000f552e0a8c..c60932e4267b5 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunnerTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunnerTests.java @@ -45,7 +45,7 @@ import org.elasticsearch.rest.RestStatus; import org.elasticsearch.search.builder.SearchSourceBuilder; import org.elasticsearch.test.ESSingleNodeTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.equalTo; @@ -91,7 +91,8 @@ public void testRunner() throws Exception { assertThat(sourceDocMap.get("field5"), is(equalTo("value5"))); List enrichFields = List.of("field2", "field5"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "field1", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "field1", enrichFields); String policyName = "test1"; final long createTime = randomNonNegativeLong(); @@ -187,7 +188,8 @@ public void testRunnerMultiSource() throws Exception { String sourceIndexPattern = baseSourceName + "*"; List enrichFields = List.of("idx", "field2", "field5"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndexPattern), "field1", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndexPattern), "field1", enrichFields); String policyName = "test1"; final long createTime = randomNonNegativeLong(); @@ -247,7 +249,8 @@ public void testRunnerNoSourceIndex() throws Exception { final String sourceIndex = "source-index"; List enrichFields = List.of("field2", "field5"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "field1", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "field1", enrichFields); String policyName = "test1"; final long createTime = randomNonNegativeLong(); @@ -274,7 +277,8 @@ public void testRunnerNoSourceMapping() throws Exception { assertTrue(createResponse.isAcknowledged()); List enrichFields = List.of("field2", "field5"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "field1", enrichFields); + EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), + "field1", enrichFields); String policyName = "test1"; final long createTime = randomNonNegativeLong(); @@ -322,7 +326,8 @@ public void testRunnerKeyNestedSourceMapping() throws Exception { String policyName = "test1"; List enrichFields = List.of("field2"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "nesting.key", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "nesting.key", enrichFields); final long createTime = randomNonNegativeLong(); final AtomicReference exception = new AtomicReference<>(); @@ -371,7 +376,8 @@ public void testRunnerValueNestedSourceMapping() throws Exception { String policyName = "test1"; List enrichFields = List.of("nesting.field2", "missingField"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "key", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "key", enrichFields); final long createTime = randomNonNegativeLong(); final AtomicReference exception = new AtomicReference<>(); @@ -451,7 +457,8 @@ public void testRunnerObjectSourceMapping() throws Exception { String policyName = "test1"; List enrichFields = List.of("data.field2", "missingField"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.field1", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.field1", enrichFields); final long createTime = randomNonNegativeLong(); final AtomicReference exception = new AtomicReference<>(); @@ -573,7 +580,8 @@ public void testRunnerExplicitObjectSourceMapping() throws Exception { String policyName = "test1"; List enrichFields = List.of("data.field2", "missingField"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.field1", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.field1", enrichFields); final long createTime = randomNonNegativeLong(); final AtomicReference exception = new AtomicReference<>(); @@ -702,8 +710,8 @@ public void testRunnerTwoObjectLevelsSourceMapping() throws Exception { String policyName = "test1"; List enrichFields = List.of("data.fields.field2", "missingField"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.fields.field1", - enrichFields); + EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), + "data.fields.field1", enrichFields); final long createTime = randomNonNegativeLong(); final AtomicReference exception = new AtomicReference<>(); @@ -824,7 +832,8 @@ public void testRunnerDottedKeyNameSourceMapping() throws Exception { String policyName = "test1"; List enrichFields = List.of("data.field2", "missingField"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.field1", enrichFields); + EnrichPolicyDefinition policy = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.field1", enrichFields); final long createTime = randomNonNegativeLong(); final AtomicReference exception = new AtomicReference<>(); @@ -885,7 +894,8 @@ public void testRunnerDottedKeyNameSourceMapping() throws Exception { ensureEnrichIndexIsReadOnly(createdEnrichIndex); } - private EnrichPolicyRunner createPolicyRunner(String policyName, EnrichPolicy policy, ActionListener listener, + private EnrichPolicyRunner createPolicyRunner(String policyName, EnrichPolicyDefinition policy, + ActionListener listener, Long createTime) { ClusterService clusterService = getInstanceFromNode(ClusterService.class); IndexNameExpressionResolver resolver = getInstanceFromNode(IndexNameExpressionResolver.class); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyTests.java index b481004506556..defa5eabe4786 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyTests.java @@ -5,27 +5,15 @@ */ package org.elasticsearch.xpack.enrich; -import org.elasticsearch.common.bytes.BytesArray; +import java.io.IOException; + +import org.elasticsearch.Version; import org.elasticsearch.common.io.stream.Writeable; -import org.elasticsearch.common.xcontent.ToXContent; -import org.elasticsearch.common.xcontent.XContentBuilder; -import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; -import org.elasticsearch.index.query.MatchAllQueryBuilder; -import org.elasticsearch.index.query.QueryBuilder; -import org.elasticsearch.index.query.TermQueryBuilder; import org.elasticsearch.test.AbstractSerializingTestCase; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.UncheckedIOException; -import java.util.Arrays; - -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.nullValue; - public class EnrichPolicyTests extends AbstractSerializingTestCase { @Override @@ -44,29 +32,11 @@ protected EnrichPolicy createXContextTestInstance(XContentType xContentType) { } public static EnrichPolicy randomEnrichPolicy(XContentType xContentType) { - final QueryBuilder queryBuilder; - if (randomBoolean()) { - queryBuilder = new MatchAllQueryBuilder(); - } else { - queryBuilder = new TermQueryBuilder(randomAlphaOfLength(4), randomAlphaOfLength(4)); - } - - final ByteArrayOutputStream out = new ByteArrayOutputStream(); - try (XContentBuilder xContentBuilder = XContentFactory.contentBuilder(xContentType, out)) { - XContentBuilder content = queryBuilder.toXContent(xContentBuilder, ToXContent.EMPTY_PARAMS); - content.flush(); - EnrichPolicy.QuerySource querySource = new EnrichPolicy.QuerySource(new BytesArray(out.toByteArray()), content.contentType()); - return new EnrichPolicy( - randomFrom(EnrichPolicy.SUPPORTED_POLICY_TYPES), - randomBoolean() ? querySource : null, - Arrays.asList(generateRandomStringArray(8, 4, false, false)), - randomAlphaOfLength(4), - Arrays.asList(generateRandomStringArray(8, 4, false, false)) - ); - } catch (IOException e) { - throw new UncheckedIOException(e); - } - + return new EnrichPolicy( + randomAlphaOfLength(4), + randomFrom(Version.getDeclaredVersions(Version.class)), + EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition(xContentType) + ); } @Override @@ -81,15 +51,8 @@ protected void assertEqualInstances(EnrichPolicy expectedInstance, EnrichPolicy } public static void assertEqualPolicies(EnrichPolicy expectedInstance, EnrichPolicy newInstance) { - assertThat(newInstance.getType(), equalTo(expectedInstance.getType())); - if (newInstance.getQuery() != null) { - // testFromXContent, always shuffles the xcontent and then byte wise the query is different, so we check the parsed version: - assertThat(newInstance.getQuery().getQueryAsMap(), equalTo(expectedInstance.getQuery().getQueryAsMap())); - } else { - assertThat(expectedInstance.getQuery(), nullValue()); - } - assertThat(newInstance.getIndices(), equalTo(expectedInstance.getIndices())); - assertThat(newInstance.getEnrichKey(), equalTo(expectedInstance.getEnrichKey())); - assertThat(newInstance.getEnrichValues(), equalTo(expectedInstance.getEnrichValues())); + assertEquals(expectedInstance.getName(), newInstance.getName()); + assertEquals(expectedInstance.getVersionCreated(), newInstance.getVersionCreated()); + EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions(expectedInstance.getDefinition(), newInstance.getDefinition()); } } diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyUpdateTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyUpdateTests.java index c834048899d75..092712bfc81b4 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyUpdateTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyUpdateTests.java @@ -13,7 +13,7 @@ import org.elasticsearch.ingest.Pipeline; import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.ESSingleNodeTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; import java.util.Collection; @@ -35,11 +35,11 @@ public void testUpdatePolicyOnly() { EnrichProcessorFactory enrichProcessorFactory = (EnrichProcessorFactory) ingestService.getProcessorFactories().get(EnrichProcessorFactory.TYPE); - EnrichPolicy instance1 = - new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of("index"), "key1", List.of("field1")); + EnrichPolicyDefinition instance1 = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of("index"), "key1", List.of("field1")); PutEnrichPolicyAction.Request putPolicyRequest = new PutEnrichPolicyAction.Request("my_policy", instance1); assertAcked(client().execute(PutEnrichPolicyAction.INSTANCE, putPolicyRequest).actionGet()); - assertThat(enrichProcessorFactory.policies.get("my_policy"), equalTo(instance1)); + assertThat(enrichProcessorFactory.policies.get("my_policy").getDefinition(), equalTo(instance1)); String pipelineConfig = "{\"processors\":[{\"enrich\": {\"policy_name\": \"my_policy\", \"enrich_values\": []}}]}"; PutPipelineRequest putPipelineRequest = new PutPipelineRequest("1", new BytesArray(pipelineConfig), XContentType.JSON); @@ -47,8 +47,8 @@ public void testUpdatePolicyOnly() { Pipeline pipelineInstance1 = ingestService.getPipeline("1"); assertThat(pipelineInstance1.getProcessors().get(0), instanceOf(ExactMatchProcessor.class)); - EnrichPolicy instance2 = - new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of("index"), "key2", List.of("field2")); + EnrichPolicyDefinition instance2 = + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of("index"), "key2", List.of("field2")); ResourceAlreadyExistsException exc = expectThrows(ResourceAlreadyExistsException.class, () -> client().execute(PutEnrichPolicyAction.INSTANCE, new PutEnrichPolicyAction.Request("my_policy", instance2)).actionGet()); assertTrue(exc.getMessage().contains("policy [my_policy] already exists")); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactoryTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactoryTests.java index 7e9ad952f4385..8f22fdc78474d 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactoryTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactoryTests.java @@ -6,9 +6,11 @@ package org.elasticsearch.xpack.enrich; import org.elasticsearch.ElasticsearchParseException; +import org.elasticsearch.Version; import org.elasticsearch.common.collect.Tuple; import org.elasticsearch.test.ESTestCase; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.enrich.EnrichProcessorFactory.EnrichSpecification; import java.util.ArrayList; @@ -25,8 +27,8 @@ public class EnrichProcessorFactoryTests extends ESTestCase { public void testCreateProcessorInstance() throws Exception { List enrichValues = List.of("globalRank", "tldRank", "tld"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of("source_index"), "my_key", - enrichValues); + EnrichPolicy policy = new EnrichPolicy("majestic", Version.CURRENT, + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of("source_index"), "my_key", enrichValues)); EnrichProcessorFactory factory = new EnrichProcessorFactory(null); factory.policies = Map.of("majestic", policy); @@ -94,8 +96,8 @@ public void testPolicyDoesNotExist() { public void testPolicyNameMissing() { List enrichValues = List.of("globalRank", "tldRank", "tld"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of("source_index"), "my_key", - enrichValues); + EnrichPolicy policy = new EnrichPolicy("_name", Version.CURRENT, + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of("source_index"), "my_key", enrichValues)); EnrichProcessorFactory factory = new EnrichProcessorFactory(null); factory.policies = Map.of("_name", policy); @@ -124,7 +126,8 @@ public void testPolicyNameMissing() { public void testUnsupportedPolicy() { List enrichValues = List.of("globalRank", "tldRank", "tld"); - EnrichPolicy policy = new EnrichPolicy("unsupported", null, List.of("source_index"), "my_key", enrichValues); + EnrichPolicy policy = new EnrichPolicy("majestic", Version.CURRENT, + new EnrichPolicyDefinition("unsupported", null, List.of("source_index"), "my_key", enrichValues)); EnrichProcessorFactory factory = new EnrichProcessorFactory(null); factory.policies = Map.of("majestic", policy); @@ -154,8 +157,8 @@ public void testUnsupportedPolicy() { public void testNonExistingDecorateField() { List enrichValues = List.of("globalRank", "tldRank", "tld"); - EnrichPolicy policy = new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of("source_index"), "my_key", - enrichValues); + EnrichPolicy policy = new EnrichPolicy("majestic", Version.CURRENT, + new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of("source_index"), "my_key", enrichValues)); EnrichProcessorFactory factory = new EnrichProcessorFactory(null); factory.policies = Map.of("majestic", policy); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichRestartIT.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichRestartIT.java index 2cdf5ed3afd8d..c05b5ffcd08fb 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichRestartIT.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichRestartIT.java @@ -9,6 +9,7 @@ import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.ESIntegTestCase; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; @@ -35,8 +36,8 @@ public void testRestart() throws Exception { final int numPolicies = randomIntBetween(2, 4); internalCluster().startNode(); - EnrichPolicy enrichPolicy = - new EnrichPolicy(EnrichPolicy.EXACT_MATCH_TYPE, null, List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); + EnrichPolicyDefinition enrichPolicy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, + List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); for (int i = 0; i < numPolicies; i++) { String policyName = POLICY_NAME + i; PutEnrichPolicyAction.Request request = new PutEnrichPolicyAction.Request(policyName, enrichPolicy); @@ -49,17 +50,17 @@ public void testRestart() throws Exception { verifyPolicies(numPolicies, enrichPolicy); } - private static void verifyPolicies(int numPolicies, EnrichPolicy enrichPolicy) { + private static void verifyPolicies(int numPolicies, EnrichPolicyDefinition enrichPolicy) { ListEnrichPolicyAction.Response response = client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet(); assertThat(response.getPolicies().size(), equalTo(numPolicies)); for (int i = 0; i < numPolicies; i++) { String policyName = POLICY_NAME + i; - Optional result = response.getPolicies().stream() - .filter(namedPolicy -> namedPolicy.getName().equals(policyName)) + Optional result = response.getPolicies().stream() + .filter(policy -> policy.getName().equals(policyName)) .findFirst(); assertThat(result.isPresent(), is(true)); - assertThat(result.get().getPolicy(), equalTo(enrichPolicy)); + assertThat(result.get().getDefinition(), equalTo(enrichPolicy)); } } diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/GetEnrichPolicyActionResponseTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/GetEnrichPolicyActionResponseTests.java index 74a63484c603b..4428533929e4e 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/GetEnrichPolicyActionResponseTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/GetEnrichPolicyActionResponseTests.java @@ -5,6 +5,8 @@ */ package org.elasticsearch.xpack.enrich.action; +import java.io.IOException; + import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; @@ -12,8 +14,6 @@ import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; -import java.io.IOException; - import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java index 6c2c91bcbb474..1c25385f1dfa4 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java @@ -33,8 +33,8 @@ protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) XContentParser.Token token; while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { assert token == XContentParser.Token.START_OBJECT; - EnrichPolicy.NamedPolicy policy = EnrichPolicy.NamedPolicy.fromXContent(parser); - policies.put(policy.getName(), policy.getPolicy()); + EnrichPolicy policy = EnrichPolicy.fromXContent(parser); + policies.put(policy.getName(), policy); } return new ListEnrichPolicyAction.Response(policies); @@ -45,7 +45,7 @@ protected ListEnrichPolicyAction.Response createTestInstance() { Map items = new HashMap<>(); for (int i = 0; i < randomIntBetween(0, 3); i++) { EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); - items.put(randomAlphaOfLength(3), policy); + items.put(policy.getName(), policy); } return new ListEnrichPolicyAction.Response(items); } @@ -58,14 +58,14 @@ protected Writeable.Reader instanceReader() { @Override protected void assertEqualInstances(ListEnrichPolicyAction.Response expectedInstance, ListEnrichPolicyAction.Response newInstance) { assertThat(expectedInstance.getPolicies().size(), equalTo(newInstance.getPolicies().size())); - for (EnrichPolicy.NamedPolicy expectedPolicy: expectedInstance.getPolicies()) { + for (EnrichPolicy expectedPolicy: expectedInstance.getPolicies()) { // contains and indexOf cannot be used here as the query source may be represented differently, so we need to check // if the name is the same and if it is, use that to ensure the policies are the same - Optional maybePolicy = newInstance.getPolicies().stream() + Optional maybePolicy = newInstance.getPolicies().stream() .filter(p -> p.getName().equals(expectedPolicy.getName())).findFirst(); assertTrue(maybePolicy.isPresent()); - EnrichPolicy.NamedPolicy newPolicy = maybePolicy.get(); - assertEqualPolicies(expectedPolicy.getPolicy(), newPolicy.getPolicy()); + EnrichPolicy newPolicy = maybePolicy.get(); + assertEqualPolicies(expectedPolicy, newPolicy); assertThat(expectedPolicy.getName(), equalTo(newPolicy.getName())); } } diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/PutEnrichPolicyActionRequestTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/PutEnrichPolicyActionRequestTests.java index 540356f7edd6c..a264d289bb4a2 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/PutEnrichPolicyActionRequestTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/PutEnrichPolicyActionRequestTests.java @@ -8,16 +8,16 @@ import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.AbstractWireSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; public class PutEnrichPolicyActionRequestTests extends AbstractWireSerializingTestCase { @Override protected PutEnrichPolicyAction.Request createTestInstance() { - final EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + final EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); return new PutEnrichPolicyAction.Request(randomAlphaOfLength(3), policy); }