From 3fc1dacc01a74fbf04c50fdb65f7c6f124217f6f Mon Sep 17 00:00:00 2001 From: James Baiera Date: Tue, 16 Jul 2019 12:52:24 -0400 Subject: [PATCH 1/3] Rename EnrichPolicy to EnrichPolicyDefinition --- ...olicy.java => EnrichPolicyDefinition.java} | 32 +++++++++---------- .../enrich/action/GetEnrichPolicyAction.java | 10 +++--- .../enrich/action/ListEnrichPolicyAction.java | 14 ++++---- .../enrich/action/PutEnrichPolicyAction.java | 12 +++---- .../xpack/enrich/EnrichMetadata.java | 18 +++++------ .../xpack/enrich/EnrichPolicyExecutor.java | 8 ++--- .../xpack/enrich/EnrichPolicyRunner.java | 16 +++++----- .../xpack/enrich/EnrichProcessorFactory.java | 8 ++--- .../xpack/enrich/EnrichStore.java | 20 ++++++------ .../xpack/enrich/ExactMatchProcessor.java | 4 +-- .../TransportGetEnrichPolicyAction.java | 4 +-- .../TransportListEnrichPolicyAction.java | 4 +-- .../xpack/enrich/BasicEnrichTests.java | 6 ++-- .../xpack/enrich/EnrichMetadataTests.java | 12 +++---- .../xpack/enrich/EnrichMultiNodeIT.java | 14 ++++---- .../enrich/EnrichPolicyExecutorTests.java | 8 ++--- .../xpack/enrich/EnrichPolicyRunnerTests.java | 24 +++++++------- .../xpack/enrich/EnrichPolicyTests.java | 28 ++++++++-------- .../xpack/enrich/EnrichPolicyUpdateTests.java | 10 +++--- .../enrich/EnrichProcessorFactoryTests.java | 10 +++--- .../xpack/enrich/EnrichRestartIT.java | 10 +++--- .../xpack/enrich/EnrichStoreTests.java | 20 ++++++------ .../GetEnrichPolicyActionResponseTests.java | 6 ++-- .../ListEnrichPolicyActionResponseTests.java | 16 +++++----- .../PutEnrichPolicyActionRequestTests.java | 4 +-- 25 files changed, 159 insertions(+), 159 deletions(-) rename x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/{EnrichPolicy.java => EnrichPolicyDefinition.java} (89%) 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/EnrichPolicyDefinition.java similarity index 89% rename from x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java rename to x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicyDefinition.java index fb3a7a0b338a3..76c70357fea9b 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/EnrichPolicyDefinition.java @@ -27,7 +27,7 @@ /** * Represents an enrich policy including its configuration. */ -public final class EnrichPolicy implements Writeable, ToXContentFragment { +public final class EnrichPolicyDefinition implements Writeable, ToXContentFragment { private static final String ENRICH_INDEX_NAME_BASE = ".enrich-"; @@ -41,8 +41,8 @@ public final class EnrichPolicy implements Writeable, ToXContentFragment { private static final ParseField ENRICH_VALUES = new ParseField("enrich_values"); @SuppressWarnings("unchecked") - private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy", - args -> new EnrichPolicy( + private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy", + args -> new EnrichPolicyDefinition( (String) args[0], (QuerySource) args[1], (List) args[2], @@ -67,7 +67,7 @@ private static void declareParserOptions(ConstructingObjectParser parser) parser.declareStringArray(ConstructingObjectParser.constructorArg(), ENRICH_VALUES); } - public static EnrichPolicy fromXContent(XContentParser parser) throws IOException { + public static EnrichPolicyDefinition fromXContent(XContentParser parser) throws IOException { return PARSER.parse(parser, null); } @@ -77,7 +77,7 @@ public static EnrichPolicy fromXContent(XContentParser parser) throws IOExceptio private final String enrichKey; private final List enrichValues; - public EnrichPolicy(StreamInput in) throws IOException { + public EnrichPolicyDefinition(StreamInput in) throws IOException { this( in.readString(), in.readOptionalWriteable(QuerySource::new), @@ -87,11 +87,11 @@ public EnrichPolicy(StreamInput in) throws IOException { ); } - public EnrichPolicy(String type, - QuerySource query, - List indices, - String enrichKey, - List enrichValues) { + public EnrichPolicyDefinition(String type, + QuerySource query, + List indices, + String enrichKey, + List enrichValues) { this.type = type; this.query= query; this.indices = indices; @@ -148,7 +148,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; - EnrichPolicy policy = (EnrichPolicy) o; + EnrichPolicyDefinition policy = (EnrichPolicyDefinition) o; return type.equals(policy.type) && Objects.equals(query, policy.query) && indices.equals(policy.indices) && @@ -225,7 +225,7 @@ public static class NamedPolicy implements Writeable, ToXContent { static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("named_policy", args -> new NamedPolicy( (String) args[0], - new EnrichPolicy((String) args[1], + new EnrichPolicyDefinition((String) args[1], (QuerySource) args[2], (List) args[3], (String) args[4], @@ -239,23 +239,23 @@ public static class NamedPolicy implements Writeable, ToXContent { } private final String name; - private final EnrichPolicy policy; + private final EnrichPolicyDefinition policy; - public NamedPolicy(String name, EnrichPolicy policy) { + public NamedPolicy(String name, EnrichPolicyDefinition policy) { this.name = name; this.policy = policy; } public NamedPolicy(StreamInput in) throws IOException { name = in.readString(); - policy = new EnrichPolicy(in); + policy = new EnrichPolicyDefinition(in); } public String getName() { return name; } - public EnrichPolicy getPolicy() { + public EnrichPolicyDefinition getPolicy() { return policy; } diff --git a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java index d7eb229d6eda3..5accb9d0d47fa 100644 --- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java @@ -13,7 +13,7 @@ import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.ToXContentObject; import org.elasticsearch.common.xcontent.XContentBuilder; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.io.IOException; import java.util.Objects; @@ -75,14 +75,14 @@ public int hashCode() { public static class Response extends ActionResponse implements ToXContentObject { - private final EnrichPolicy policy; + private final EnrichPolicyDefinition policy; - public Response(EnrichPolicy policy) { + public Response(EnrichPolicyDefinition policy) { this.policy = Objects.requireNonNull(policy, "policy cannot be null"); } public Response(StreamInput in) throws IOException { - policy = new EnrichPolicy(in); + policy = new EnrichPolicyDefinition(in); } @Override @@ -101,7 +101,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws return builder; } - public EnrichPolicy getPolicy() { + public EnrichPolicyDefinition getPolicy() { return policy; } 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..dfffc1e9f79ee 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 @@ -13,7 +13,7 @@ import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.ToXContentObject; import org.elasticsearch.common.xcontent.XContentBuilder; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.io.IOException; import java.util.List; @@ -47,17 +47,17 @@ public ActionRequestValidationException validate() { public static class Response extends ActionResponse implements ToXContentObject { - private final List policies; + private final List policies; - public Response(Map 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()); + .map(entry -> new EnrichPolicyDefinition.NamedPolicy(entry.getKey(), entry.getValue())).collect(Collectors.toList()); } public Response(StreamInput in) throws IOException { - policies = in.readList(EnrichPolicy.NamedPolicy::new); + policies = in.readList(EnrichPolicyDefinition.NamedPolicy::new); } @Override @@ -71,7 +71,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws { builder.startArray("policies"); { - for (EnrichPolicy.NamedPolicy policy: policies) { + for (EnrichPolicyDefinition.NamedPolicy policy: policies) { policy.toXContent(builder, params); } } @@ -82,7 +82,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/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java index c791d2debd5fc..4d999518497a4 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java @@ -16,7 +16,7 @@ import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.xpack.core.XPackPlugin; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.io.IOException; import java.util.Collections; @@ -37,18 +37,18 @@ public final class EnrichMetadata extends AbstractNamedDiffable @SuppressWarnings("unchecked") private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>( "enrich_metadata", - args -> new EnrichMetadata((Map) args[0]) + args -> new EnrichMetadata((Map) args[0]) ); static { PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, c) -> { - Map patterns = new HashMap<>(); + Map patterns = new HashMap<>(); String fieldName = null; for (XContentParser.Token token = p.nextToken(); token != XContentParser.Token.END_OBJECT; token = p.nextToken()) { if (token == XContentParser.Token.FIELD_NAME) { fieldName = p.currentName(); } else if (token == XContentParser.Token.START_OBJECT) { - patterns.put(fieldName, EnrichPolicy.fromXContent(p)); + patterns.put(fieldName, EnrichPolicyDefinition.fromXContent(p)); } else { throw new ElasticsearchParseException("unexpected token [" + token + "]"); } @@ -61,17 +61,17 @@ public static EnrichMetadata fromXContent(XContentParser parser) throws IOExcept return PARSER.parse(parser, null); } - private final Map policies; + private final Map policies; public EnrichMetadata(StreamInput in) throws IOException { - this(in.readMap(StreamInput::readString, EnrichPolicy::new)); + this(in.readMap(StreamInput::readString, EnrichPolicyDefinition::new)); } - public EnrichMetadata(Map policies) { + public EnrichMetadata(Map policies) { this.policies = Collections.unmodifiableMap(policies); } - public Map getPolicies() { + public Map getPolicies() { return policies; } @@ -99,7 +99,7 @@ public void writeTo(StreamOutput out) throws IOException { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(POLICIES.getPreferredName()); - for (Map.Entry entry : policies.entrySet()) { + for (Map.Entry entry : policies.entrySet()) { builder.startObject(entry.getKey()); builder.value(entry.getValue()); builder.endObject(); 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 40218030f9250..c143c3c045297 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 @@ -17,7 +17,7 @@ import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.util.concurrent.EsRejectedExecutionException; import org.elasticsearch.threadpool.ThreadPool; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; public class EnrichPolicyExecutor { @@ -77,14 +77,14 @@ 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); } public void runPolicy(String policyId, ActionListener listener) { // Look up policy in policy store and execute it - EnrichPolicy policy = EnrichStore.getPolicy(policyId, clusterService.state()); + EnrichPolicyDefinition policy = EnrichStore.getPolicy(policyId, clusterService.state()); if (policy == null) { throw new IllegalArgumentException("Policy execution failed. Could not locate policy with id [" + policyId + "]"); } else { @@ -92,7 +92,7 @@ public void runPolicy(String policyId, ActionListener lis } } - public void runPolicy(String policyName, EnrichPolicy policy, ActionListener listener) { + public void runPolicy(String policyName, EnrichPolicyDefinition policy, ActionListener listener) { tryLockingPolicy(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/EnrichPolicyRunner.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunner.java index 722c3d1eb0861..cbaf31508bff7 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; @@ -58,7 +58,7 @@ public class EnrichPolicyRunner implements Runnable { private static final Logger logger = LogManager.getLogger(EnrichPolicyRunner.class); private final String policyName; - private final EnrichPolicy policy; + private final EnrichPolicyDefinition policy; private final ActionListener listener; private final ClusterService clusterService; private final Client client; @@ -66,7 +66,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; @@ -189,10 +189,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()); @@ -227,7 +227,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(); @@ -352,7 +352,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..377f4ab10fb98 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 @@ -9,7 +9,7 @@ import org.elasticsearch.cluster.ClusterState; 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; @@ -20,7 +20,7 @@ final class EnrichProcessorFactory implements Processor.Factory, Consumer policies = Map.of(); + volatile Map policies = Map.of(); EnrichProcessorFactory(Client client) { this.client = client; @@ -29,7 +29,7 @@ final class EnrichProcessorFactory implements Processor.Factory, Consumer processorFactories, String tag, Map config) throws Exception { String policyName = ConfigurationUtils.readStringProperty(TYPE, tag, config, "policy_name"); - EnrichPolicy policy = policies.get(policyName); + EnrichPolicyDefinition policy = policies.get(policyName); if (policy == null) { throw new IllegalArgumentException("policy [" + policyName + "] does not exists"); } @@ -52,7 +52,7 @@ public Processor create(Map processorFactories, Strin } switch (policy.getType()) { - case EnrichPolicy.EXACT_MATCH_TYPE: + case EnrichPolicyDefinition.EXACT_MATCH_TYPE: return new ExactMatchProcessor(tag, client, policyName, enrichKey, ignoreMissing, specifications); default: throw new IllegalArgumentException("unsupported policy type [" + policy.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..0eef9747233c2 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 @@ -12,7 +12,7 @@ import org.elasticsearch.cluster.metadata.MetaData; import org.elasticsearch.cluster.service.ClusterService; import org.elasticsearch.common.Strings; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.util.HashMap; import java.util.Map; @@ -34,7 +34,7 @@ private EnrichStore() {} * @param policy The policy to store * @param handler The handler that gets invoked if policy has been stored or a failure has occurred. */ - public static void putPolicy(String name, EnrichPolicy policy, ClusterService clusterService, Consumer handler) { + public static void putPolicy(String name, EnrichPolicyDefinition policy, ClusterService clusterService, Consumer handler) { assert clusterService.localNode().isMasterNode(); if (Strings.isNullOrEmpty(name)) { @@ -46,7 +46,7 @@ public static void putPolicy(String name, EnrichPolicy policy, ClusterService cl // TODO: add policy validation updateClusterState(clusterService, handler, current -> { - final Map policies = getPolicies(current); + final Map policies = getPolicies(current); if (policies.get(name) != null) { throw new ResourceAlreadyExistsException("policy [{}] already exists", name); } @@ -70,7 +70,7 @@ public static void deletePolicy(String name, ClusterService clusterService, Cons } updateClusterState(clusterService, handler, current -> { - final Map policies = getPolicies(current); + final Map policies = getPolicies(current); if (policies.containsKey(name) == false) { throw new ResourceNotFoundException("policy [{}] not found", name); } @@ -86,7 +86,7 @@ public static void deletePolicy(String name, ClusterService clusterService, Cons * @param name The name of the policy to fetch * @return enrich policy if exists or null otherwise */ - public static EnrichPolicy getPolicy(String name, ClusterState state) { + public static EnrichPolicyDefinition getPolicy(String name, ClusterState state) { if (Strings.isNullOrEmpty(name)) { throw new IllegalArgumentException("name is missing or empty"); } @@ -98,10 +98,10 @@ 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; + public static Map getPolicies(ClusterState state) { + final Map policies; final EnrichMetadata enrichMetadata = state.metaData().custom(EnrichMetadata.TYPE); if (enrichMetadata != null) { // Make a copy, because policies map inside custom metadata is read only: @@ -114,12 +114,12 @@ public static Map getPolicies(ClusterState state) { private static void updateClusterState(ClusterService clusterService, Consumer handler, - Function> function) { + Function> function) { clusterService.submitStateUpdateTask("update-enrich-metadata", new ClusterStateUpdateTask() { @Override public ClusterState execute(ClusterState currentState) throws Exception { - Map policies = function.apply(currentState); + Map policies = function.apply(currentState); MetaData metaData = MetaData.builder(currentState.metaData()) .putCustom(EnrichMetadata.TYPE, new EnrichMetadata(policies)) .build(); 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) throws Exception { - final EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state); + final EnrichPolicyDefinition policy = EnrichStore.getPolicy(request.getName(), state); if (policy == null) { throw new ResourceNotFoundException("Policy [{}] was not found", request.getName()); } diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java index af0a4288f16ce..3fd372720c894 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java @@ -18,7 +18,7 @@ import org.elasticsearch.tasks.Task; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.transport.TransportService; -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.enrich.EnrichStore; @@ -56,7 +56,7 @@ protected ListEnrichPolicyAction.Response newResponse() { @Override protected void masterOperation(Task task, ListEnrichPolicyAction.Request request, ClusterState state, ActionListener listener) throws Exception { - Map policies = EnrichStore.getPolicies(clusterService.state()); + Map policies = EnrichStore.getPolicies(clusterService.state()); listener.onResponse(new ListEnrichPolicyAction.Response(policies)); } 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..6eac7d6fb8219 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,8 @@ 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/EnrichMetadataTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java index a0474b1216bbb..5f53833c06955 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java @@ -9,7 +9,7 @@ import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.AbstractSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.io.IOException; import java.util.HashMap; @@ -37,9 +37,9 @@ protected EnrichMetadata createXContextTestInstance(XContentType xContentType) { private static EnrichMetadata randomEnrichMetadata(XContentType xContentType) { int numPolicies = randomIntBetween(8, 64); - Map policies = new HashMap<>(numPolicies); + Map policies = new HashMap<>(numPolicies); for (int i = 0; i < numPolicies; i++) { - EnrichPolicy policy = randomEnrichPolicy(xContentType); + EnrichPolicyDefinition policy = randomEnrichPolicy(xContentType); policies.put(randomAlphaOfLength(8), policy); } return new EnrichMetadata(policies); @@ -54,9 +54,9 @@ protected Writeable.Reader instanceReader() { protected void assertEqualInstances(EnrichMetadata expectedInstance, EnrichMetadata newInstance) { assertNotSame(expectedInstance, newInstance); assertThat(newInstance.getPolicies().size(), equalTo(expectedInstance.getPolicies().size())); - for (Map.Entry entry : newInstance.getPolicies().entrySet()) { - EnrichPolicy actual = entry.getValue(); - EnrichPolicy expected = expectedInstance.getPolicies().get(entry.getKey()); + for (Map.Entry entry : newInstance.getPolicies().entrySet()) { + EnrichPolicyDefinition actual = entry.getValue(); + EnrichPolicyDefinition expected = expectedInstance.getPolicies().get(entry.getKey()); EnrichPolicyTests.assertEqualPolicies(expected, actual); } } 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..6a2153d7af835 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,16 @@ 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 = + EnrichPolicyDefinition result = client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request(policyName)).actionGet().getPolicy(); 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 +156,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/EnrichPolicyExecutorTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutorTests.java index 036e6709d2759..9ff14d0d57d2d 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,14 @@ 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,7 +100,7 @@ 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", + 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/EnrichPolicyRunnerTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunnerTests.java index 2000f552e0a8c..2cc7d5093c5a5 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,7 @@ 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 +187,7 @@ 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 +247,7 @@ 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 +274,7 @@ 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 +322,7 @@ 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 +371,7 @@ 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 +451,7 @@ 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 +573,7 @@ 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,7 +702,7 @@ 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", + EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(sourceIndex), "data.fields.field1", enrichFields); final long createTime = randomNonNegativeLong(); @@ -824,7 +824,7 @@ 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 +885,7 @@ 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..f3b90654777d4 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 @@ -16,7 +16,7 @@ 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 org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -26,24 +26,24 @@ import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.nullValue; -public class EnrichPolicyTests extends AbstractSerializingTestCase { +public class EnrichPolicyTests extends AbstractSerializingTestCase { @Override - protected EnrichPolicy doParseInstance(XContentParser parser) throws IOException { - return EnrichPolicy.fromXContent(parser); + protected EnrichPolicyDefinition doParseInstance(XContentParser parser) throws IOException { + return EnrichPolicyDefinition.fromXContent(parser); } @Override - protected EnrichPolicy createTestInstance() { + protected EnrichPolicyDefinition createTestInstance() { return randomEnrichPolicy(randomFrom(XContentType.values())); } @Override - protected EnrichPolicy createXContextTestInstance(XContentType xContentType) { + protected EnrichPolicyDefinition createXContextTestInstance(XContentType xContentType) { return randomEnrichPolicy(xContentType); } - public static EnrichPolicy randomEnrichPolicy(XContentType xContentType) { + public static EnrichPolicyDefinition randomEnrichPolicy(XContentType xContentType) { final QueryBuilder queryBuilder; if (randomBoolean()) { queryBuilder = new MatchAllQueryBuilder(); @@ -55,9 +55,9 @@ public static EnrichPolicy randomEnrichPolicy(XContentType xContentType) { 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), + 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), @@ -70,17 +70,17 @@ public static EnrichPolicy randomEnrichPolicy(XContentType xContentType) { } @Override - protected Writeable.Reader instanceReader() { - return EnrichPolicy::new; + protected Writeable.Reader instanceReader() { + return EnrichPolicyDefinition::new; } @Override - protected void assertEqualInstances(EnrichPolicy expectedInstance, EnrichPolicy newInstance) { + protected void assertEqualInstances(EnrichPolicyDefinition expectedInstance, EnrichPolicyDefinition newInstance) { assertNotSame(expectedInstance, newInstance); assertEqualPolicies(expectedInstance, newInstance); } - public static void assertEqualPolicies(EnrichPolicy expectedInstance, EnrichPolicy newInstance) { + public static void assertEqualPolicies(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: 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..1bdb85ec8eee4 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,8 +35,8 @@ 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)); @@ -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..e835b125489f6 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 @@ -8,7 +8,7 @@ import org.elasticsearch.ElasticsearchParseException; 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,7 +25,7 @@ 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", + EnrichPolicyDefinition policy = 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,7 +94,7 @@ 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", + EnrichPolicyDefinition policy = 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 +124,7 @@ 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); + EnrichPolicyDefinition policy = new EnrichPolicyDefinition("unsupported", null, List.of("source_index"), "my_key", enrichValues); EnrichProcessorFactory factory = new EnrichProcessorFactory(null); factory.policies = Map.of("majestic", policy); @@ -154,7 +154,7 @@ 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", + EnrichPolicyDefinition policy = 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..3ea904d878421 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 @@ -8,7 +8,7 @@ import org.elasticsearch.index.reindex.ReindexPlugin; 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 +35,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,13 +49,13 @@ 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() + Optional result = response.getPolicies().stream() .filter(namedPolicy -> namedPolicy.getName().equals(policyName)) .findFirst(); assertThat(result.isPresent(), is(true)); diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java index c9c545b9501dc..be1a026b99ede 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java @@ -9,7 +9,7 @@ import org.elasticsearch.cluster.service.ClusterService; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.ESSingleNodeTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import java.util.Map; import java.util.concurrent.CountDownLatch; @@ -22,17 +22,17 @@ public class EnrichStoreTests extends ESSingleNodeTestCase { public void testCrud() throws Exception { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); String name = "my-policy"; AtomicReference error = saveEnrichPolicy(name, policy, clusterService); assertThat(error.get(), nullValue()); - EnrichPolicy result = EnrichStore.getPolicy(name, clusterService.state()); + EnrichPolicyDefinition result = EnrichStore.getPolicy(name, clusterService.state()); assertThat(result, equalTo(policy)); - Map listPolicies = EnrichStore.getPolicies(clusterService.state()); + Map listPolicies = EnrichStore.getPolicies(clusterService.state()); assertThat(listPolicies.size(), equalTo(1)); assertThat(listPolicies.get(name), equalTo(policy)); @@ -42,7 +42,7 @@ public void testCrud() throws Exception { } public void testImmutability() throws Exception { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); String name = "my-policy"; @@ -53,12 +53,12 @@ public void testImmutability() throws Exception { assertTrue(error.get().getMessage().contains("policy [my-policy] already exists"));; deleteEnrichPolicy(name, clusterService); - EnrichPolicy result = EnrichStore.getPolicy(name, clusterService.state()); + EnrichPolicyDefinition result = EnrichStore.getPolicy(name, clusterService.state()); assertThat(result, nullValue()); } public void testPutValidation() throws Exception { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); { @@ -105,17 +105,17 @@ public void testGetValidation() { assertThat(error.getMessage(), equalTo("name is missing or empty")); - EnrichPolicy policy = EnrichStore.getPolicy("null-policy", clusterService.state()); + EnrichPolicyDefinition policy = EnrichStore.getPolicy("null-policy", clusterService.state()); assertNull(policy); } public void testListValidation() { ClusterService clusterService = getInstanceFromNode(ClusterService.class); - Map policies = EnrichStore.getPolicies(clusterService.state()); + Map policies = EnrichStore.getPolicies(clusterService.state()); assertTrue(policies.isEmpty()); } - private AtomicReference saveEnrichPolicy(String name, EnrichPolicy policy, + private AtomicReference saveEnrichPolicy(String name, EnrichPolicyDefinition policy, ClusterService clusterService) throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); AtomicReference error = new AtomicReference<>(); 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..58ef14476db76 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 @@ -9,7 +9,7 @@ import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.AbstractSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; import java.io.IOException; @@ -21,13 +21,13 @@ public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestC @Override protected GetEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException { - EnrichPolicy policy = EnrichPolicy.fromXContent(parser); + EnrichPolicyDefinition policy = EnrichPolicyDefinition.fromXContent(parser); return new GetEnrichPolicyAction.Response(policy); } @Override protected GetEnrichPolicyAction.Response createTestInstance() { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); return new GetEnrichPolicyAction.Response(policy); } 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..a689f58dbc66e 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 @@ -9,7 +9,7 @@ import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.AbstractSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import java.io.IOException; @@ -24,7 +24,7 @@ public class ListEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { @Override protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException { - Map policies = new HashMap<>(); + Map policies = new HashMap<>(); assert parser.nextToken() == XContentParser.Token.START_OBJECT; assert parser.nextToken() == XContentParser.Token.FIELD_NAME; assert parser.currentName().equals("policies"); @@ -33,7 +33,7 @@ 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); + EnrichPolicyDefinition.NamedPolicy policy = EnrichPolicyDefinition.NamedPolicy.fromXContent(parser); policies.put(policy.getName(), policy.getPolicy()); } @@ -42,9 +42,9 @@ protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) @Override protected ListEnrichPolicyAction.Response createTestInstance() { - Map items = new HashMap<>(); + Map items = new HashMap<>(); for (int i = 0; i < randomIntBetween(0, 3); i++) { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); items.put(randomAlphaOfLength(3), policy); } return new ListEnrichPolicyAction.Response(items); @@ -58,13 +58,13 @@ 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 (EnrichPolicyDefinition.NamedPolicy 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(); + EnrichPolicyDefinition.NamedPolicy newPolicy = maybePolicy.get(); assertEqualPolicies(expectedPolicy.getPolicy(), newPolicy.getPolicy()); 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..d0e892a01b1d9 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,7 +8,7 @@ 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; @@ -17,7 +17,7 @@ public class PutEnrichPolicyActionRequestTests extends AbstractWireSerializingTe @Override protected PutEnrichPolicyAction.Request createTestInstance() { - final EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + final EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); return new PutEnrichPolicyAction.Request(randomAlphaOfLength(3), policy); } From 31d3f96b3d87b1fd111dc7292c488cfa6bd622cb Mon Sep 17 00:00:00 2001 From: James Baiera Date: Tue, 16 Jul 2019 16:03:30 -0400 Subject: [PATCH 2/3] Add new EnrichPolicy definition --- .../xpack/core/enrich/EnrichPolicy.java | 110 ++++++++++++++++++ .../core/enrich/EnrichPolicyDefinition.java | 2 +- .../xpack/enrich/EnrichMetadataTests.java | 6 +- .../enrich/EnrichPolicyDefinitionTests.java | 96 +++++++++++++++ .../xpack/enrich/EnrichPolicyTests.java | 88 ++++---------- .../xpack/enrich/EnrichStoreTests.java | 8 +- .../GetEnrichPolicyActionResponseTests.java | 8 +- .../ListEnrichPolicyActionResponseTests.java | 8 +- .../PutEnrichPolicyActionRequestTests.java | 4 +- 9 files changed, 245 insertions(+), 85 deletions(-) create mode 100644 x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java create mode 100644 x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyDefinitionTests.java 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 new file mode 100644 index 0000000000000..1600c6aeab114 --- /dev/null +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/EnrichPolicy.java @@ -0,0 +1,110 @@ +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.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.ObjectParser; +import org.elasticsearch.common.xcontent.ToXContentFragment; +import org.elasticsearch.common.xcontent.XContentBuilder; +import org.elasticsearch.common.xcontent.XContentParser; + +public class EnrichPolicy implements Writeable, ToXContentFragment { + + 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"); + + private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy", + args -> new EnrichPolicy( + (String) args[0], + (Version) args[1], + (EnrichPolicyDefinition) args[2] + ) + ); + + static { + 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 name; + private final Version versionCreated; + private final EnrichPolicyDefinition definition; + + public EnrichPolicy(StreamInput in) throws IOException { + this( + in.readString(), + Version.readVersion(in), + new EnrichPolicyDefinition(in) + ); + } + + public EnrichPolicy(String name, Version versionCreated, EnrichPolicyDefinition definition) { + this.name = name; + this.versionCreated = versionCreated; + this.definition = definition; + } + + public String getName() { + return name; + } + + public Version getVersionCreated() { + return versionCreated; + } + + public EnrichPolicyDefinition getDefinition() { + return definition; + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + out.writeString(name); + Version.writeVersion(versionCreated, out); + definition.writeTo(out); + } + + @Override + public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { + 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; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + EnrichPolicy policy = (EnrichPolicy) o; + return name.equals(policy.name) && + Objects.equals(versionCreated, policy.versionCreated) && + Objects.equals(definition, policy.definition); + } + + @Override + public int hashCode() { + return Objects.hash(name, versionCreated, definition); + } + + @Override + public String toString() { + return Strings.toString(this); + } +} 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 index 76c70357fea9b..a5d63d47f1b18 100644 --- 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 @@ -41,7 +41,7 @@ public final class EnrichPolicyDefinition implements Writeable, ToXContentFragme private static final ParseField ENRICH_VALUES = new ParseField("enrich_values"); @SuppressWarnings("unchecked") - private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy", + private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>("policy_definition", args -> new EnrichPolicyDefinition( (String) args[0], (QuerySource) args[1], diff --git a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java index 5f53833c06955..a97db2ec57578 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java @@ -15,7 +15,7 @@ import java.util.HashMap; import java.util.Map; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; import static org.hamcrest.Matchers.equalTo; public class EnrichMetadataTests extends AbstractSerializingTestCase { @@ -39,7 +39,7 @@ private static EnrichMetadata randomEnrichMetadata(XContentType xContentType) { int numPolicies = randomIntBetween(8, 64); Map policies = new HashMap<>(numPolicies); for (int i = 0; i < numPolicies; i++) { - EnrichPolicyDefinition policy = randomEnrichPolicy(xContentType); + EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(xContentType); policies.put(randomAlphaOfLength(8), policy); } return new EnrichMetadata(policies); @@ -57,7 +57,7 @@ protected void assertEqualInstances(EnrichMetadata expectedInstance, EnrichMetad for (Map.Entry entry : newInstance.getPolicies().entrySet()) { EnrichPolicyDefinition actual = entry.getValue(); EnrichPolicyDefinition expected = expectedInstance.getPolicies().get(entry.getKey()); - EnrichPolicyTests.assertEqualPolicies(expected, actual); + EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions(expected, actual); } } } 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/EnrichPolicyTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyTests.java index f3b90654777d4..668d7f177324f 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 @@ -1,95 +1,49 @@ -/* - * 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 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.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; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; -public class EnrichPolicyTests extends AbstractSerializingTestCase { +public class EnrichPolicyTests extends AbstractSerializingTestCase { @Override - protected EnrichPolicyDefinition doParseInstance(XContentParser parser) throws IOException { - return EnrichPolicyDefinition.fromXContent(parser); + protected EnrichPolicy doParseInstance(XContentParser parser) throws IOException { + return EnrichPolicy.fromXContent(parser); } @Override - protected EnrichPolicyDefinition createTestInstance() { + protected EnrichPolicy createTestInstance() { return randomEnrichPolicy(randomFrom(XContentType.values())); } @Override - protected EnrichPolicyDefinition createXContextTestInstance(XContentType xContentType) { + protected EnrichPolicy createXContextTestInstance(XContentType xContentType) { return randomEnrichPolicy(xContentType); } - public static EnrichPolicyDefinition 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(); - 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); - } - + public static EnrichPolicy randomEnrichPolicy(XContentType xContentType) { + return new EnrichPolicy( + randomAlphaOfLength(4), + randomFrom(Version.getDeclaredVersions(Version.class)), + EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition(xContentType) + ); } @Override - protected Writeable.Reader instanceReader() { - return EnrichPolicyDefinition::new; + protected Writeable.Reader instanceReader() { + return EnrichPolicy::new; } @Override - protected void assertEqualInstances(EnrichPolicyDefinition expectedInstance, EnrichPolicyDefinition newInstance) { + protected void assertEqualInstances(EnrichPolicy expectedInstance, EnrichPolicy newInstance) { assertNotSame(expectedInstance, newInstance); - assertEqualPolicies(expectedInstance, newInstance); - } - - public static void assertEqualPolicies(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())); + 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/EnrichStoreTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java index be1a026b99ede..697cadc3996aa 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java @@ -15,14 +15,14 @@ import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicReference; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.nullValue; public class EnrichStoreTests extends ESSingleNodeTestCase { public void testCrud() throws Exception { - EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); String name = "my-policy"; @@ -42,7 +42,7 @@ public void testCrud() throws Exception { } public void testImmutability() throws Exception { - EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); String name = "my-policy"; @@ -58,7 +58,7 @@ public void testImmutability() throws Exception { } public void testPutValidation() throws Exception { - EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); { 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 58ef14476db76..b8dfb3d54d1dc 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 @@ -14,8 +14,8 @@ import java.io.IOException; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { @@ -27,7 +27,7 @@ protected GetEnrichPolicyAction.Response doParseInstance(XContentParser parser) @Override protected GetEnrichPolicyAction.Response createTestInstance() { - EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); return new GetEnrichPolicyAction.Response(policy); } @@ -40,6 +40,6 @@ protected Writeable.Reader instanceReader() { protected void assertEqualInstances(GetEnrichPolicyAction.Response expectedInstance, GetEnrichPolicyAction.Response newInstance) { assertNotSame(expectedInstance, newInstance); // the tests shuffle around the policy query source xcontent type, so this is needed here - assertEqualPolicies(expectedInstance.getPolicy(), newInstance.getPolicy()); + assertEqualPolicyDefinitions(expectedInstance.getPolicy(), newInstance.getPolicy()); } } 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 a689f58dbc66e..daa785fc0f13d 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 @@ -17,8 +17,8 @@ import java.util.Map; import java.util.Optional; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; -import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions; +import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; import static org.hamcrest.Matchers.equalTo; public class ListEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { @@ -44,7 +44,7 @@ protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) protected ListEnrichPolicyAction.Response createTestInstance() { Map items = new HashMap<>(); for (int i = 0; i < randomIntBetween(0, 3); i++) { - EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); + EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); items.put(randomAlphaOfLength(3), policy); } return new ListEnrichPolicyAction.Response(items); @@ -65,7 +65,7 @@ protected void assertEqualInstances(ListEnrichPolicyAction.Response expectedInst .filter(p -> p.getName().equals(expectedPolicy.getName())).findFirst(); assertTrue(maybePolicy.isPresent()); EnrichPolicyDefinition.NamedPolicy newPolicy = maybePolicy.get(); - assertEqualPolicies(expectedPolicy.getPolicy(), newPolicy.getPolicy()); + assertEqualPolicyDefinitions(expectedPolicy.getPolicy(), newPolicy.getPolicy()); 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 d0e892a01b1d9..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 @@ -11,13 +11,13 @@ 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 EnrichPolicyDefinition policy = randomEnrichPolicy(XContentType.JSON); + final EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); return new PutEnrichPolicyAction.Request(randomAlphaOfLength(3), policy); } From 25b7288b7855e747585b52dfe2caa3cea38d4719 Mon Sep 17 00:00:00 2001 From: James Baiera Date: Thu, 18 Jul 2019 15:45:40 -0400 Subject: [PATCH 3/3] Switch everything back over to using the new EnrichPolicy --- .../xpack/core/enrich/EnrichPolicy.java | 5 ++ .../core/enrich/EnrichPolicyDefinition.java | 78 ------------------- .../enrich/action/GetEnrichPolicyAction.java | 10 +-- .../enrich/action/ListEnrichPolicyAction.java | 22 +++--- .../rest-api-spec/test/enrich/10_basic.yml | 17 ++-- .../xpack/enrich/EnrichMetadata.java | 18 ++--- .../xpack/enrich/EnrichPolicyExecutor.java | 8 +- .../xpack/enrich/EnrichProcessorFactory.java | 14 ++-- .../xpack/enrich/EnrichStore.java | 18 ++--- .../TransportGetEnrichPolicyAction.java | 4 +- .../TransportListEnrichPolicyAction.java | 4 +- .../TransportPutEnrichPolicyAction.java | 5 +- .../xpack/enrich/BasicEnrichTests.java | 3 +- .../xpack/enrich/EnrichMetadataTests.java | 16 ++-- .../xpack/enrich/EnrichMultiNodeIT.java | 14 ++-- .../enrich/EnrichPolicyExecutorTests.java | 7 +- .../xpack/enrich/EnrichPolicyRunnerTests.java | 34 +++++--- .../xpack/enrich/EnrichPolicyTests.java | 9 +++ .../xpack/enrich/EnrichPolicyUpdateTests.java | 2 +- .../enrich/EnrichProcessorFactoryTests.java | 17 ++-- .../xpack/enrich/EnrichRestartIT.java | 11 +-- .../xpack/enrich/EnrichStoreTests.java | 22 +++--- .../GetEnrichPolicyActionResponseTests.java | 16 ++-- .../ListEnrichPolicyActionResponseTests.java | 26 +++---- 24 files changed, 173 insertions(+), 207 deletions(-) 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 1600c6aeab114..da71a121c75ed 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 @@ -1,3 +1,8 @@ +/* + * 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 java.io.IOException; 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 index a5d63d47f1b18..54141820c3d53 100644 --- 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 @@ -12,7 +12,6 @@ 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.ToXContentFragment; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentHelper; @@ -217,81 +216,4 @@ 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 EnrichPolicyDefinition((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 EnrichPolicyDefinition policy; - - public NamedPolicy(String name, EnrichPolicyDefinition policy) { - this.name = name; - this.policy = policy; - } - - public NamedPolicy(StreamInput in) throws IOException { - name = in.readString(); - policy = new EnrichPolicyDefinition(in); - } - - public String getName() { - return name; - } - - public EnrichPolicyDefinition 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/action/GetEnrichPolicyAction.java b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java index 5accb9d0d47fa..d7eb229d6eda3 100644 --- a/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java +++ b/x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java @@ -13,7 +13,7 @@ import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.ToXContentObject; import org.elasticsearch.common.xcontent.XContentBuilder; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.io.IOException; import java.util.Objects; @@ -75,14 +75,14 @@ public int hashCode() { public static class Response extends ActionResponse implements ToXContentObject { - private final EnrichPolicyDefinition policy; + private final EnrichPolicy policy; - public Response(EnrichPolicyDefinition policy) { + public Response(EnrichPolicy policy) { this.policy = Objects.requireNonNull(policy, "policy cannot be null"); } public Response(StreamInput in) throws IOException { - policy = new EnrichPolicyDefinition(in); + policy = new EnrichPolicy(in); } @Override @@ -101,7 +101,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws return builder; } - public EnrichPolicyDefinition getPolicy() { + public EnrichPolicy getPolicy() { return policy; } 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 dfffc1e9f79ee..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 @@ -13,13 +13,13 @@ import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.ToXContentObject; import org.elasticsearch.common.xcontent.XContentBuilder; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +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) { + 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 EnrichPolicyDefinition.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(EnrichPolicyDefinition.NamedPolicy::new); + policies = in.readList(EnrichPolicy::new); } @Override @@ -71,8 +73,10 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws { builder.startArray("policies"); { - for (EnrichPolicyDefinition.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/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/EnrichMetadata.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java index 4d999518497a4..c791d2debd5fc 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichMetadata.java @@ -16,7 +16,7 @@ import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.xpack.core.XPackPlugin; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.io.IOException; import java.util.Collections; @@ -37,18 +37,18 @@ public final class EnrichMetadata extends AbstractNamedDiffable @SuppressWarnings("unchecked") private static final ConstructingObjectParser PARSER = new ConstructingObjectParser<>( "enrich_metadata", - args -> new EnrichMetadata((Map) args[0]) + args -> new EnrichMetadata((Map) args[0]) ); static { PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, c) -> { - Map patterns = new HashMap<>(); + Map patterns = new HashMap<>(); String fieldName = null; for (XContentParser.Token token = p.nextToken(); token != XContentParser.Token.END_OBJECT; token = p.nextToken()) { if (token == XContentParser.Token.FIELD_NAME) { fieldName = p.currentName(); } else if (token == XContentParser.Token.START_OBJECT) { - patterns.put(fieldName, EnrichPolicyDefinition.fromXContent(p)); + patterns.put(fieldName, EnrichPolicy.fromXContent(p)); } else { throw new ElasticsearchParseException("unexpected token [" + token + "]"); } @@ -61,17 +61,17 @@ public static EnrichMetadata fromXContent(XContentParser parser) throws IOExcept return PARSER.parse(parser, null); } - private final Map policies; + private final Map policies; public EnrichMetadata(StreamInput in) throws IOException { - this(in.readMap(StreamInput::readString, EnrichPolicyDefinition::new)); + this(in.readMap(StreamInput::readString, EnrichPolicy::new)); } - public EnrichMetadata(Map policies) { + public EnrichMetadata(Map policies) { this.policies = Collections.unmodifiableMap(policies); } - public Map getPolicies() { + public Map getPolicies() { return policies; } @@ -99,7 +99,7 @@ public void writeTo(StreamOutput out) throws IOException { @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(POLICIES.getPreferredName()); - for (Map.Entry entry : policies.entrySet()) { + for (Map.Entry entry : policies.entrySet()) { builder.startObject(entry.getKey()); builder.value(entry.getValue()); builder.endObject(); 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 c143c3c045297..45840361d9dfa 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 @@ -17,6 +17,7 @@ import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.util.concurrent.EsRejectedExecutionException; import org.elasticsearch.threadpool.ThreadPool; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; public class EnrichPolicyExecutor { @@ -77,18 +78,19 @@ public void onFailure(Exception e) { } } - protected Runnable createPolicyRunner(String policyName, EnrichPolicyDefinition policy, ActionListener listener) { + protected Runnable createPolicyRunner(String policyName, EnrichPolicyDefinition policy, + ActionListener listener) { return new EnrichPolicyRunner(policyName, policy, listener, clusterService, client, indexNameExpressionResolver, nowSupplier, fetchSize); } public void runPolicy(String policyId, ActionListener listener) { // Look up policy in policy store and execute it - EnrichPolicyDefinition policy = EnrichStore.getPolicy(policyId, clusterService.state()); + EnrichPolicy policy = EnrichStore.getPolicy(policyId, clusterService.state()); 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); } } 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 377f4ab10fb98..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 @@ -9,6 +9,7 @@ import org.elasticsearch.cluster.ClusterState; 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; @@ -20,7 +21,7 @@ final class EnrichProcessorFactory implements Processor.Factory, Consumer policies = Map.of(); + volatile Map policies = Map.of(); EnrichProcessorFactory(Client client) { this.client = client; @@ -29,12 +30,13 @@ final class EnrichProcessorFactory implements Processor.Factory, Consumer processorFactories, String tag, Map config) throws Exception { String policyName = ConfigurationUtils.readStringProperty(TYPE, tag, config, "policy_name"); - EnrichPolicyDefinition policy = policies.get(policyName); + EnrichPolicy policy = policies.get(policyName); 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()) { + 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 0eef9747233c2..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 @@ -12,7 +12,7 @@ import org.elasticsearch.cluster.metadata.MetaData; import org.elasticsearch.cluster.service.ClusterService; import org.elasticsearch.common.Strings; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.util.HashMap; import java.util.Map; @@ -34,7 +34,7 @@ private EnrichStore() {} * @param policy The policy to store * @param handler The handler that gets invoked if policy has been stored or a failure has occurred. */ - public static void putPolicy(String name, EnrichPolicyDefinition policy, ClusterService clusterService, Consumer handler) { + public static void putPolicy(String name, EnrichPolicy policy, ClusterService clusterService, Consumer handler) { assert clusterService.localNode().isMasterNode(); if (Strings.isNullOrEmpty(name)) { @@ -46,7 +46,7 @@ public static void putPolicy(String name, EnrichPolicyDefinition policy, Cluster // TODO: add policy validation updateClusterState(clusterService, handler, current -> { - final Map policies = getPolicies(current); + final Map policies = getPolicies(current); if (policies.get(name) != null) { throw new ResourceAlreadyExistsException("policy [{}] already exists", name); } @@ -70,7 +70,7 @@ public static void deletePolicy(String name, ClusterService clusterService, Cons } updateClusterState(clusterService, handler, current -> { - final Map policies = getPolicies(current); + final Map policies = getPolicies(current); if (policies.containsKey(name) == false) { throw new ResourceNotFoundException("policy [{}] not found", name); } @@ -86,7 +86,7 @@ public static void deletePolicy(String name, ClusterService clusterService, Cons * @param name The name of the policy to fetch * @return enrich policy if exists or null otherwise */ - public static EnrichPolicyDefinition getPolicy(String name, ClusterState state) { + public static EnrichPolicy getPolicy(String name, ClusterState state) { if (Strings.isNullOrEmpty(name)) { throw new IllegalArgumentException("name is missing or empty"); } @@ -100,8 +100,8 @@ public static EnrichPolicyDefinition getPolicy(String name, ClusterState state) * @param state the cluster state * @return a Map of policyName, EnrichPolicyDefinition of the policies */ - public static Map getPolicies(ClusterState state) { - final Map policies; + public static Map getPolicies(ClusterState state) { + final Map policies; final EnrichMetadata enrichMetadata = state.metaData().custom(EnrichMetadata.TYPE); if (enrichMetadata != null) { // Make a copy, because policies map inside custom metadata is read only: @@ -114,12 +114,12 @@ public static Map getPolicies(ClusterState state private static void updateClusterState(ClusterService clusterService, Consumer handler, - Function> function) { + Function> function) { clusterService.submitStateUpdateTask("update-enrich-metadata", new ClusterStateUpdateTask() { @Override public ClusterState execute(ClusterState currentState) throws Exception { - Map policies = function.apply(currentState); + Map policies = function.apply(currentState); MetaData metaData = MetaData.builder(currentState.metaData()) .putCustom(EnrichMetadata.TYPE, new EnrichMetadata(policies)) .build(); diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyAction.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyAction.java index 651d268579499..ab762be697152 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyAction.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyAction.java @@ -19,7 +19,7 @@ import org.elasticsearch.tasks.Task; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.transport.TransportService; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; import org.elasticsearch.xpack.enrich.EnrichStore; @@ -57,7 +57,7 @@ protected GetEnrichPolicyAction.Response read(StreamInput in) throws IOException protected void masterOperation(Task task, GetEnrichPolicyAction.Request request, ClusterState state, ActionListener listener) throws Exception { - final EnrichPolicyDefinition policy = EnrichStore.getPolicy(request.getName(), state); + final EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state); if (policy == null) { throw new ResourceNotFoundException("Policy [{}] was not found", request.getName()); } diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java index 3fd372720c894..af0a4288f16ce 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java @@ -18,7 +18,7 @@ import org.elasticsearch.tasks.Task; import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.transport.TransportService; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import org.elasticsearch.xpack.enrich.EnrichStore; @@ -56,7 +56,7 @@ protected ListEnrichPolicyAction.Response newResponse() { @Override protected void masterOperation(Task task, ListEnrichPolicyAction.Request request, ClusterState state, ActionListener listener) throws Exception { - Map policies = EnrichStore.getPolicies(clusterService.state()); + Map policies = EnrichStore.getPolicies(clusterService.state()); listener.onResponse(new ListEnrichPolicyAction.Response(policies)); } diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportPutEnrichPolicyAction.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportPutEnrichPolicyAction.java index ec1d80a355d5f..85153f81a57b1 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportPutEnrichPolicyAction.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportPutEnrichPolicyAction.java @@ -5,6 +5,7 @@ */ package org.elasticsearch.xpack.enrich.action; +import org.elasticsearch.Version; import org.elasticsearch.action.ActionListener; import org.elasticsearch.action.support.ActionFilters; import org.elasticsearch.action.support.master.AcknowledgedResponse; @@ -24,6 +25,7 @@ import org.elasticsearch.threadpool.ThreadPool; import org.elasticsearch.transport.TransportService; import org.elasticsearch.xpack.core.XPackSettings; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; import org.elasticsearch.xpack.core.security.SecurityContext; import org.elasticsearch.xpack.core.security.action.user.HasPrivilegesAction; @@ -103,7 +105,8 @@ protected void masterOperation(Task task, PutEnrichPolicyAction.Request request, } private void putPolicy(PutEnrichPolicyAction.Request request, ActionListener 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 6eac7d6fb8219..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 @@ -46,7 +46,8 @@ public void testIngestDataWithEnrichProcessor() { String policyName = "my-policy"; EnrichPolicyDefinition enrichPolicy = - new EnrichPolicyDefinition(EnrichPolicyDefinition.EXACT_MATCH_TYPE, null, List.of(SOURCE_INDEX_NAME), KEY_FIELD, List.of(DECORATE_FIELDS)); + 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/EnrichMetadataTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java index a97db2ec57578..a0474b1216bbb 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMetadataTests.java @@ -9,13 +9,13 @@ import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.AbstractSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.io.IOException; import java.util.HashMap; import java.util.Map; -import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; import static org.hamcrest.Matchers.equalTo; public class EnrichMetadataTests extends AbstractSerializingTestCase { @@ -37,9 +37,9 @@ protected EnrichMetadata createXContextTestInstance(XContentType xContentType) { private static EnrichMetadata randomEnrichMetadata(XContentType xContentType) { int numPolicies = randomIntBetween(8, 64); - Map policies = new HashMap<>(numPolicies); + Map policies = new HashMap<>(numPolicies); for (int i = 0; i < numPolicies; i++) { - EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(xContentType); + EnrichPolicy policy = randomEnrichPolicy(xContentType); policies.put(randomAlphaOfLength(8), policy); } return new EnrichMetadata(policies); @@ -54,10 +54,10 @@ protected Writeable.Reader instanceReader() { protected void assertEqualInstances(EnrichMetadata expectedInstance, EnrichMetadata newInstance) { assertNotSame(expectedInstance, newInstance); assertThat(newInstance.getPolicies().size(), equalTo(expectedInstance.getPolicies().size())); - for (Map.Entry entry : newInstance.getPolicies().entrySet()) { - EnrichPolicyDefinition actual = entry.getValue(); - EnrichPolicyDefinition expected = expectedInstance.getPolicies().get(entry.getKey()); - EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions(expected, actual); + for (Map.Entry entry : newInstance.getPolicies().entrySet()) { + EnrichPolicy actual = entry.getValue(); + EnrichPolicy expected = expectedInstance.getPolicies().get(entry.getKey()); + EnrichPolicyTests.assertEqualPolicies(expected, actual); } } } 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 6a2153d7af835..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 @@ -61,14 +61,16 @@ public void testEnrichAPIs() { for (int i = 0; i < numPolicies; i++) { String policyName = POLICY_NAME + i; - EnrichPolicyDefinition enrichPolicy = - new EnrichPolicyDefinition(EnrichPolicyDefinition.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(); - EnrichPolicyDefinition 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 = EnrichPolicyDefinition.getBaseName(policyName) + "*"; refresh(enrichIndexPrefix); @@ -156,8 +158,8 @@ private static List createSourceIndex(int numDocs) { } private static void createAndExecutePolicy() { - EnrichPolicyDefinition enrichPolicy = - new EnrichPolicyDefinition(EnrichPolicyDefinition.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/EnrichPolicyExecutorTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyExecutorTests.java index 9ff14d0d57d2d..4c17c3e551dbd 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 @@ -90,7 +90,8 @@ CountDownLatch testRunPolicy(String policyName, EnrichPolicyDefinition policy, A } @Override - protected Runnable createPolicyRunner(String policyName, EnrichPolicyDefinition 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, EnrichPolicyDefinition public void testNonConcurrentPolicyExecution() throws InterruptedException { String testPolicyName = "test_policy"; - EnrichPolicyDefinition testPolicy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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/EnrichPolicyRunnerTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichPolicyRunnerTests.java index 2cc7d5093c5a5..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 @@ -91,7 +91,8 @@ public void testRunner() throws Exception { assertThat(sourceDocMap.get("field5"), is(equalTo("value5"))); List enrichFields = List.of("field2", "field5"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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, EnrichPolicyDefinition 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 668d7f177324f..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 @@ -1,3 +1,8 @@ +/* + * 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 java.io.IOException; @@ -42,6 +47,10 @@ protected Writeable.Reader instanceReader() { @Override protected void assertEqualInstances(EnrichPolicy expectedInstance, EnrichPolicy newInstance) { assertNotSame(expectedInstance, newInstance); + assertEqualPolicies(expectedInstance, newInstance); + } + + public static void assertEqualPolicies(EnrichPolicy expectedInstance, EnrichPolicy newInstance) { 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 1bdb85ec8eee4..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 @@ -39,7 +39,7 @@ public void testUpdatePolicyOnly() { 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); 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 e835b125489f6..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,8 +6,10 @@ 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; @@ -25,8 +27,8 @@ public class EnrichProcessorFactoryTests extends ESTestCase { public void testCreateProcessorInstance() throws Exception { List enrichValues = List.of("globalRank", "tldRank", "tld"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition("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"); - EnrichPolicyDefinition policy = new EnrichPolicyDefinition(EnrichPolicyDefinition.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 3ea904d878421..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 @@ -8,6 +8,7 @@ import org.elasticsearch.index.reindex.ReindexPlugin; 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(); - EnrichPolicyDefinition enrichPolicy = - new EnrichPolicyDefinition(EnrichPolicyDefinition.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); @@ -55,11 +56,11 @@ private static void verifyPolicies(int numPolicies, EnrichPolicyDefinition enric 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/EnrichStoreTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java index 697cadc3996aa..c9c545b9501dc 100644 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichStoreTests.java @@ -9,30 +9,30 @@ import org.elasticsearch.cluster.service.ClusterService; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.ESSingleNodeTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicReference; -import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.nullValue; public class EnrichStoreTests extends ESSingleNodeTestCase { public void testCrud() throws Exception { - EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); String name = "my-policy"; AtomicReference error = saveEnrichPolicy(name, policy, clusterService); assertThat(error.get(), nullValue()); - EnrichPolicyDefinition result = EnrichStore.getPolicy(name, clusterService.state()); + EnrichPolicy result = EnrichStore.getPolicy(name, clusterService.state()); assertThat(result, equalTo(policy)); - Map listPolicies = EnrichStore.getPolicies(clusterService.state()); + Map listPolicies = EnrichStore.getPolicies(clusterService.state()); assertThat(listPolicies.size(), equalTo(1)); assertThat(listPolicies.get(name), equalTo(policy)); @@ -42,7 +42,7 @@ public void testCrud() throws Exception { } public void testImmutability() throws Exception { - EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); String name = "my-policy"; @@ -53,12 +53,12 @@ public void testImmutability() throws Exception { assertTrue(error.get().getMessage().contains("policy [my-policy] already exists"));; deleteEnrichPolicy(name, clusterService); - EnrichPolicyDefinition result = EnrichStore.getPolicy(name, clusterService.state()); + EnrichPolicy result = EnrichStore.getPolicy(name, clusterService.state()); assertThat(result, nullValue()); } public void testPutValidation() throws Exception { - EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); ClusterService clusterService = getInstanceFromNode(ClusterService.class); { @@ -105,17 +105,17 @@ public void testGetValidation() { assertThat(error.getMessage(), equalTo("name is missing or empty")); - EnrichPolicyDefinition policy = EnrichStore.getPolicy("null-policy", clusterService.state()); + EnrichPolicy policy = EnrichStore.getPolicy("null-policy", clusterService.state()); assertNull(policy); } public void testListValidation() { ClusterService clusterService = getInstanceFromNode(ClusterService.class); - Map policies = EnrichStore.getPolicies(clusterService.state()); + Map policies = EnrichStore.getPolicies(clusterService.state()); assertTrue(policies.isEmpty()); } - private AtomicReference saveEnrichPolicy(String name, EnrichPolicyDefinition policy, + private AtomicReference saveEnrichPolicy(String name, EnrichPolicy policy, ClusterService clusterService) throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); AtomicReference error = new AtomicReference<>(); 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 b8dfb3d54d1dc..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,29 +5,29 @@ */ 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; import org.elasticsearch.test.AbstractSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +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.EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions; -import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { @Override protected GetEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException { - EnrichPolicyDefinition policy = EnrichPolicyDefinition.fromXContent(parser); + EnrichPolicy policy = EnrichPolicy.fromXContent(parser); return new GetEnrichPolicyAction.Response(policy); } @Override protected GetEnrichPolicyAction.Response createTestInstance() { - EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); return new GetEnrichPolicyAction.Response(policy); } @@ -40,6 +40,6 @@ protected Writeable.Reader instanceReader() { protected void assertEqualInstances(GetEnrichPolicyAction.Response expectedInstance, GetEnrichPolicyAction.Response newInstance) { assertNotSame(expectedInstance, newInstance); // the tests shuffle around the policy query source xcontent type, so this is needed here - assertEqualPolicyDefinitions(expectedInstance.getPolicy(), newInstance.getPolicy()); + assertEqualPolicies(expectedInstance.getPolicy(), newInstance.getPolicy()); } } 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 daa785fc0f13d..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 @@ -9,7 +9,7 @@ import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.test.AbstractSerializingTestCase; -import org.elasticsearch.xpack.core.enrich.EnrichPolicyDefinition; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import java.io.IOException; @@ -17,14 +17,14 @@ import java.util.Map; import java.util.Optional; -import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.assertEqualPolicyDefinitions; -import static org.elasticsearch.xpack.enrich.EnrichPolicyDefinitionTests.randomEnrichPolicyDefinition; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; import static org.hamcrest.Matchers.equalTo; public class ListEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { @Override protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException { - Map policies = new HashMap<>(); + Map policies = new HashMap<>(); assert parser.nextToken() == XContentParser.Token.START_OBJECT; assert parser.nextToken() == XContentParser.Token.FIELD_NAME; assert parser.currentName().equals("policies"); @@ -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; - EnrichPolicyDefinition.NamedPolicy policy = EnrichPolicyDefinition.NamedPolicy.fromXContent(parser); - policies.put(policy.getName(), policy.getPolicy()); + EnrichPolicy policy = EnrichPolicy.fromXContent(parser); + policies.put(policy.getName(), policy); } return new ListEnrichPolicyAction.Response(policies); @@ -42,10 +42,10 @@ protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) @Override protected ListEnrichPolicyAction.Response createTestInstance() { - Map items = new HashMap<>(); + Map items = new HashMap<>(); for (int i = 0; i < randomIntBetween(0, 3); i++) { - EnrichPolicyDefinition policy = randomEnrichPolicyDefinition(XContentType.JSON); - items.put(randomAlphaOfLength(3), policy); + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + 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 (EnrichPolicyDefinition.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()); - EnrichPolicyDefinition.NamedPolicy newPolicy = maybePolicy.get(); - assertEqualPolicyDefinitions(expectedPolicy.getPolicy(), newPolicy.getPolicy()); + EnrichPolicy newPolicy = maybePolicy.get(); + assertEqualPolicies(expectedPolicy, newPolicy); assertThat(expectedPolicy.getName(), equalTo(newPolicy.getName())); } }