diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/EnrichIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/EnrichIT.java index 4d071de6014..abe44fd7155 100644 --- a/client/rest-high-level/src/test/java/org/elasticsearch/client/EnrichIT.java +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/EnrichIT.java @@ -45,10 +45,13 @@ public class EnrichIT extends ESRestHighLevelClientTestCase { Response getPolicyResponse = highLevelClient().getLowLevelClient().performRequest(getPolicyRequest); assertThat(getPolicyResponse.getHttpResponse().getStatusLine().getStatusCode(), equalTo(200)); Map responseBody = toMap(getPolicyResponse); - assertThat(responseBody.get("type"), equalTo(putPolicyRequest.getType())); - assertThat(responseBody.get("indices"), equalTo(putPolicyRequest.getIndices())); - assertThat(responseBody.get("match_field"), equalTo(putPolicyRequest.getMatchField())); - assertThat(responseBody.get("enrich_fields"), equalTo(putPolicyRequest.getEnrichFields())); + @SuppressWarnings("unchecked") + List> responsePolicies = (List>) responseBody.get("policies"); + assertThat(responsePolicies.size(), equalTo(1)); + assertThat(responsePolicies.get(0).get("type"), equalTo(putPolicyRequest.getType())); + assertThat(responsePolicies.get(0).get("indices"), equalTo(putPolicyRequest.getIndices())); + assertThat(responsePolicies.get(0).get("match_field"), equalTo(putPolicyRequest.getMatchField())); + assertThat(responsePolicies.get(0).get("enrich_fields"), equalTo(putPolicyRequest.getEnrichFields())); } private static Map toMap(Response response) throws IOException { diff --git a/docs/reference/ingest/ingest-node.asciidoc b/docs/reference/ingest/ingest-node.asciidoc index afb3821fd9d..8e947998e3a 100644 --- a/docs/reference/ingest/ingest-node.asciidoc +++ b/docs/reference/ingest/ingest-node.asciidoc @@ -967,7 +967,6 @@ Also there are several APIs in order to manage and execute enrich policies: * <>. * <>. * <>. -* <>. If security is enabled then the user managing enrich policies will need to have the `enrich_user` builtin role. Also the user will need to have read privileges @@ -1008,7 +1007,7 @@ Response: The get policy api allows a policy to be retrieved by id. -Request" +Request: [source,js] -------------------------------------------------- @@ -1022,18 +1021,27 @@ Response: [source,js] -------------------------------------------------- { - "type": "exact_match", - "indices": ["users"], - "match_field": "email", - "enrich_fields": ["first_name", "last_name", "address", "city", "zip", "state"] + "policies": [ + { + "name" : "my-policy", + "type" : "exact_match", + "indices" : ["users"], + "match_field" : "email", + "enrich_fields" : [ + "first_name", + "last_name", + "address", + "city", + "zip", + "state" + ] + } + ] } -------------------------------------------------- // TESTRESPONSE -[[list-policies-api]] -==== List Policies API - -The list policies api allows all policies to be returned. +The get policy api allows all policies to be returned. Request: 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 991b212dbfb..ceedb74f461 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 @@ -16,7 +16,11 @@ import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import java.io.IOException; +import java.util.List; +import java.util.Map; import java.util.Objects; +import java.util.TreeMap; +import java.util.stream.Collectors; public class GetEnrichPolicyAction extends ActionType { @@ -31,6 +35,8 @@ public class GetEnrichPolicyAction extends ActionType policies; - public Response(EnrichPolicy policy) { - this.policy = Objects.requireNonNull(policy, "policy cannot be null"); + 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()); } public Response(StreamInput in) throws IOException { - policy = new EnrichPolicy(in); + policies = in.readList(EnrichPolicy.NamedPolicy::new); } @Override public void writeTo(StreamOutput out) throws IOException { - policy.writeTo(out); + out.writeList(policies); } @Override public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { builder.startObject(); { - policy.toXContent(builder, params); + builder.startArray("policies"); + { + for (EnrichPolicy.NamedPolicy policy: policies) { + policy.toXContent(builder, params); + } + } + builder.endArray(); } builder.endObject(); return builder; } - public EnrichPolicy getPolicy() { - return policy; + public List getPolicies() { + return policies; } @Override @@ -110,12 +125,12 @@ public class GetEnrichPolicyAction extends ActionType { - - public static final ListEnrichPolicyAction INSTANCE = new ListEnrichPolicyAction(); - public static final String NAME = "cluster:admin/xpack/enrich/list"; - - private ListEnrichPolicyAction() { - super(NAME, Response::new); - } - - public static class Request extends MasterNodeRequest { - - public Request() {} - - public Request(StreamInput in) throws IOException { - super(in); - } - - @Override - public ActionRequestValidationException validate() { - return null; - } - } - - public static class Response extends ActionResponse implements ToXContentObject { - - private final List policies; - - public Response(Map policies) { - Objects.requireNonNull(policies, "policies cannot be null"); - // use a treemap to guarantee ordering in the set, then transform it to the list of named policies - this.policies = new TreeMap<>(policies).entrySet().stream() - .map(entry -> new EnrichPolicy.NamedPolicy(entry.getKey(), entry.getValue())).collect(Collectors.toList()); - } - - public Response(StreamInput in) throws IOException { - policies = in.readList(EnrichPolicy.NamedPolicy::new); - } - - @Override - public void writeTo(StreamOutput out) throws IOException { - out.writeList(policies); - } - - @Override - public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException { - builder.startObject(); - { - builder.startArray("policies"); - { - for (EnrichPolicy.NamedPolicy policy: policies) { - policy.toXContent(builder, params); - } - } - builder.endArray(); - } - builder.endObject(); - - return builder; - } - - public List getPolicies() { - return policies; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - Response response = (Response) o; - return policies.equals(response.policies); - } - - @Override - public int hashCode() { - return Objects.hash(policies); - } - } -} diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/security/authz/privilege/PrivilegeTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/security/authz/privilege/PrivilegeTests.java index 4231b02bea6..3dafc654840 100644 --- a/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/security/authz/privilege/PrivilegeTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/security/authz/privilege/PrivilegeTests.java @@ -11,7 +11,6 @@ import org.elasticsearch.test.ESTestCase; import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; import org.elasticsearch.transport.TransportRequest; import org.elasticsearch.xpack.core.security.authz.permission.ClusterPermission; @@ -185,7 +184,6 @@ public class PrivilegeTests extends ESTestCase { verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, DeleteEnrichPolicyAction.NAME); verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, ExecuteEnrichPolicyAction.NAME); verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, GetEnrichPolicyAction.NAME); - verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, ListEnrichPolicyAction.NAME); verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, PutEnrichPolicyAction.NAME); verifyClusterActionAllowed(ClusterPrivilegeResolver.MANAGE_ENRICH, "cluster:admin/xpack/enrich/brand_new_api"); verifyClusterActionDenied(ClusterPrivilegeResolver.MANAGE_ENRICH, "cluster:admin/xpack/whatever"); 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 e0b5a40580d..e6a48d64134 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,13 +19,15 @@ - do: enrich.get_policy: name: policy-crud - - match: { type: exact_match } - - match: { indices: ["bar*"] } - - match: { match_field: baz } - - match: { enrich_fields: ["a", "b"] } + - length: { policies: 1 } + - match: { policies.0.name: policy-crud } + - match: { policies.0.type: exact_match } + - match: { policies.0.indices: ["bar*"] } + - match: { policies.0.match_field: baz } + - match: { policies.0.enrich_fields: ["a", "b"] } - do: - enrich.list_policy: {} + enrich.get_policy: {} - length: { policies: 1 } - match: { policies.0.name: policy-crud } - match: { policies.0.type: exact_match } diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPlugin.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPlugin.java index 06371b7a595..1245a6c546c 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPlugin.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPlugin.java @@ -38,19 +38,16 @@ import org.elasticsearch.xpack.core.XPackPlugin; import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; import org.elasticsearch.xpack.enrich.action.CoordinatorProxyAction; import org.elasticsearch.xpack.enrich.action.EnrichShardMultiSearchAction; import org.elasticsearch.xpack.enrich.action.TransportDeleteEnrichPolicyAction; import org.elasticsearch.xpack.enrich.action.TransportExecuteEnrichPolicyAction; import org.elasticsearch.xpack.enrich.action.TransportGetEnrichPolicyAction; -import org.elasticsearch.xpack.enrich.action.TransportListEnrichPolicyAction; import org.elasticsearch.xpack.enrich.action.TransportPutEnrichPolicyAction; import org.elasticsearch.xpack.enrich.rest.RestDeleteEnrichPolicyAction; import org.elasticsearch.xpack.enrich.rest.RestExecuteEnrichPolicyAction; import org.elasticsearch.xpack.enrich.rest.RestGetEnrichPolicyAction; -import org.elasticsearch.xpack.enrich.rest.RestListEnrichPolicyAction; import org.elasticsearch.xpack.enrich.rest.RestPutEnrichPolicyAction; import java.util.Arrays; @@ -115,7 +112,6 @@ public class EnrichPlugin extends Plugin implements ActionPlugin, IngestPlugin { return Arrays.asList( new ActionHandler<>(GetEnrichPolicyAction.INSTANCE, TransportGetEnrichPolicyAction.class), new ActionHandler<>(DeleteEnrichPolicyAction.INSTANCE, TransportDeleteEnrichPolicyAction.class), - new ActionHandler<>(ListEnrichPolicyAction.INSTANCE, TransportListEnrichPolicyAction.class), new ActionHandler<>(PutEnrichPolicyAction.INSTANCE, TransportPutEnrichPolicyAction.class), new ActionHandler<>(ExecuteEnrichPolicyAction.INSTANCE, TransportExecuteEnrichPolicyAction.class), new ActionHandler<>(CoordinatorProxyAction.INSTANCE, CoordinatorProxyAction.TransportAction.class), @@ -134,7 +130,6 @@ public class EnrichPlugin extends Plugin implements ActionPlugin, IngestPlugin { return Arrays.asList( new RestGetEnrichPolicyAction(restController), new RestDeleteEnrichPolicyAction(restController), - new RestListEnrichPolicyAction(restController), new RestPutEnrichPolicyAction(restController), new RestExecuteEnrichPolicyAction(restController) ); 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 b2ad49ed9dc..ac3d2f1a01d 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 @@ -23,6 +23,8 @@ import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; import org.elasticsearch.xpack.enrich.EnrichStore; import java.io.IOException; +import java.util.Collections; +import java.util.Map; public class TransportGetEnrichPolicyAction extends TransportMasterNodeReadAction { @@ -55,11 +57,18 @@ public class TransportGetEnrichPolicyAction extends TransportMasterNodeReadActio protected void masterOperation(GetEnrichPolicyAction.Request request, ClusterState state, ActionListener listener) throws Exception { - final EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state); - if (policy == null) { - throw new ResourceNotFoundException("Policy [{}] was not found", request.getName()); + Map policies; + if (request.getName() == null || request.getName().isEmpty()) { + policies = EnrichStore.getPolicies(state); + } else { + EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state); + if (policy == null) { + throw new ResourceNotFoundException("Policy [{}] was not found", request.getName()); + } + policies = Collections.singletonMap(request.getName(), policy); + } - listener.onResponse(new GetEnrichPolicyAction.Response(policy)); + listener.onResponse(new GetEnrichPolicyAction.Response(policies)); } @Override 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 deleted file mode 100644 index 8de359b07b4..00000000000 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * 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.action; - -import org.elasticsearch.action.ActionListener; -import org.elasticsearch.action.support.ActionFilters; -import org.elasticsearch.action.support.master.TransportMasterNodeAction; -import org.elasticsearch.cluster.ClusterState; -import org.elasticsearch.cluster.block.ClusterBlockException; -import org.elasticsearch.cluster.block.ClusterBlockLevel; -import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver; -import org.elasticsearch.cluster.service.ClusterService; -import org.elasticsearch.common.inject.Inject; -import org.elasticsearch.common.io.stream.StreamInput; -import org.elasticsearch.threadpool.ThreadPool; -import org.elasticsearch.transport.TransportService; -import org.elasticsearch.xpack.core.enrich.EnrichPolicy; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; -import org.elasticsearch.xpack.enrich.EnrichStore; - -import java.io.IOException; -import java.util.Map; - -public class TransportListEnrichPolicyAction - extends TransportMasterNodeAction { - - @Inject - public TransportListEnrichPolicyAction(TransportService transportService, - ClusterService clusterService, - ThreadPool threadPool, - ActionFilters actionFilters, - IndexNameExpressionResolver indexNameExpressionResolver) { - super(ListEnrichPolicyAction.NAME, transportService, clusterService, threadPool, actionFilters, - ListEnrichPolicyAction.Request::new, indexNameExpressionResolver); - } - - @Override - protected String executor() { - return ThreadPool.Names.SAME; - } - - @Override - protected ListEnrichPolicyAction.Response read(StreamInput in) throws IOException { - return new ListEnrichPolicyAction.Response(in); - } - - protected ListEnrichPolicyAction.Response newResponse() { - throw new UnsupportedOperationException("usage of Streamable is to be replaced by Writeable"); - } - - @Override - protected void masterOperation(ListEnrichPolicyAction.Request request, ClusterState state, - ActionListener listener) throws Exception { - Map policies = EnrichStore.getPolicies(clusterService.state()); - listener.onResponse(new ListEnrichPolicyAction.Response(policies)); - } - - @Override - protected ClusterBlockException checkBlock(ListEnrichPolicyAction.Request request, ClusterState state) { - return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE); - } - - -} diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestGetEnrichPolicyAction.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestGetEnrichPolicyAction.java index 2b757908015..11ad6b3ebb8 100644 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestGetEnrichPolicyAction.java +++ b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestGetEnrichPolicyAction.java @@ -18,6 +18,7 @@ public class RestGetEnrichPolicyAction extends BaseRestHandler { public RestGetEnrichPolicyAction(final RestController controller) { controller.registerHandler(RestRequest.Method.GET, "/_enrich/policy/{name}", this); + controller.registerHandler(RestRequest.Method.GET, "/_enrich/policy", this); } @Override diff --git a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestListEnrichPolicyAction.java b/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestListEnrichPolicyAction.java deleted file mode 100644 index af022338c42..00000000000 --- a/x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestListEnrichPolicyAction.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * 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.rest; - -import org.elasticsearch.client.node.NodeClient; -import org.elasticsearch.rest.BaseRestHandler; -import org.elasticsearch.rest.RestController; -import org.elasticsearch.rest.RestRequest; -import org.elasticsearch.rest.action.RestToXContentListener; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; - -import java.io.IOException; - -public class RestListEnrichPolicyAction extends BaseRestHandler { - - public RestListEnrichPolicyAction(final RestController controller) { - controller.registerHandler(RestRequest.Method.GET, "/_enrich/policy", this); - } - - @Override - public String getName() { - return "list_enrich_policy"; - } - - @Override - protected RestChannelConsumer prepareRequest(final RestRequest restRequest, final NodeClient client) throws IOException { - final ListEnrichPolicyAction.Request request = new ListEnrichPolicyAction.Request(); - return channel -> client.execute(ListEnrichPolicyAction.INSTANCE, request, new RestToXContentListener<>(channel)); - } -} 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 05f682bd153..7c649d9c9a3 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 @@ -27,7 +27,6 @@ import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.ExecuteEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; import java.util.ArrayList; @@ -82,9 +81,10 @@ public class EnrichMultiNodeIT extends ESIntegTestCase { client().execute(PutEnrichPolicyAction.INSTANCE, request).actionGet(); client().execute(ExecuteEnrichPolicyAction.INSTANCE, new ExecuteEnrichPolicyAction.Request(policyName)).actionGet(); - EnrichPolicy result = - client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request(policyName)).actionGet().getPolicy(); - assertThat(result, equalTo(enrichPolicy)); + EnrichPolicy.NamedPolicy result = + client().execute(GetEnrichPolicyAction.INSTANCE, + new GetEnrichPolicyAction.Request(policyName)).actionGet().getPolicies().get(0); + assertThat(result, equalTo(new EnrichPolicy.NamedPolicy(policyName, enrichPolicy))); String enrichIndexPrefix = EnrichPolicy.getBaseName(policyName) + "*"; refresh(enrichIndexPrefix); SearchResponse searchResponse = client().search(new SearchRequest(enrichIndexPrefix)).actionGet(); @@ -92,8 +92,8 @@ public class EnrichMultiNodeIT extends ESIntegTestCase { assertThat(searchResponse.getHits().getTotalHits().value, equalTo((long) numDocsInSourceIndex)); } - ListEnrichPolicyAction.Response response = - client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet(); + GetEnrichPolicyAction.Response response = + client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request()).actionGet(); assertThat(response.getPolicies().size(), equalTo(numPolicies)); for (int i = 0; i < numPolicies; i++) { @@ -101,7 +101,7 @@ public class EnrichMultiNodeIT extends ESIntegTestCase { client().execute(DeleteEnrichPolicyAction.INSTANCE, new DeleteEnrichPolicyAction.Request(policyName)).actionGet(); } - response = client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet(); + response = client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request()).actionGet(); assertThat(response.getPolicies().size(), equalTo(0)); } 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 f26a7e48463..f6c36e79a46 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 @@ -11,7 +11,7 @@ import org.elasticsearch.plugins.Plugin; import org.elasticsearch.test.ESIntegTestCase; import org.elasticsearch.xpack.core.XPackSettings; import org.elasticsearch.xpack.core.enrich.EnrichPolicy; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; +import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; import org.elasticsearch.xpack.core.enrich.action.PutEnrichPolicyAction; import java.util.Arrays; @@ -63,8 +63,8 @@ public class EnrichRestartIT extends ESIntegTestCase { } private static void verifyPolicies(int numPolicies, EnrichPolicy enrichPolicy) { - ListEnrichPolicyAction.Response response = - client().execute(ListEnrichPolicyAction.INSTANCE, new ListEnrichPolicyAction.Request()).actionGet(); + GetEnrichPolicyAction.Response response = + client().execute(GetEnrichPolicyAction.INSTANCE, new GetEnrichPolicyAction.Request()).actionGet(); assertThat(response.getPolicies().size(), equalTo(numPolicies)); for (int i = 0; i < numPolicies; i++) { String policyName = POLICY_NAME + i; 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 74a63484c60..4403649739a 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 @@ -13,22 +13,41 @@ import org.elasticsearch.xpack.core.enrich.EnrichPolicy; import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; import java.io.IOException; +import java.util.HashMap; +import java.util.Map; import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.hamcrest.core.IsEqual.equalTo; public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { @Override protected GetEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException { - EnrichPolicy policy = EnrichPolicy.fromXContent(parser); - return new GetEnrichPolicyAction.Response(policy); + Map policies = new HashMap<>(); + assert parser.nextToken() == XContentParser.Token.START_OBJECT; + assert parser.nextToken() == XContentParser.Token.FIELD_NAME; + assert parser.currentName().equals("policies"); + assert parser.nextToken() == XContentParser.Token.START_ARRAY; + + XContentParser.Token token; + while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { + assert token == XContentParser.Token.START_OBJECT; + EnrichPolicy.NamedPolicy policy = EnrichPolicy.NamedPolicy.fromXContent(parser); + policies.put(policy.getName(), policy.getPolicy()); + } + + return new GetEnrichPolicyAction.Response(policies); } @Override protected GetEnrichPolicyAction.Response createTestInstance() { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); - return new GetEnrichPolicyAction.Response(policy); + Map items = new HashMap<>(); + for (int i = 0; i < randomIntBetween(0, 3); i++) { + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + items.put(randomAlphaOfLength(3), policy); + } + return new GetEnrichPolicyAction.Response(items); } @Override @@ -40,6 +59,14 @@ public class GetEnrichPolicyActionResponseTests extends AbstractSerializingTestC 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()); + assertThat(expectedInstance.getPolicies().size(), equalTo(newInstance.getPolicies().size())); + // since the backing store is a treemap the list will be sorted so we can just check each + // instance is the same + for (int i = 0; i < expectedInstance.getPolicies().size(); i++) { + EnrichPolicy.NamedPolicy expected = expectedInstance.getPolicies().get(i); + EnrichPolicy.NamedPolicy newed = newInstance.getPolicies().get(i); + assertThat(expected.getName(), equalTo(newed.getName())); + assertEqualPolicies(expected.getPolicy(), newed.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 deleted file mode 100644 index 6c2c91bcbb4..00000000000 --- a/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * 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.action; - -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.EnrichPolicy; -import org.elasticsearch.xpack.core.enrich.action.ListEnrichPolicyAction; - -import java.io.IOException; -import java.util.HashMap; -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.hamcrest.Matchers.equalTo; - -public class ListEnrichPolicyActionResponseTests extends AbstractSerializingTestCase { - @Override - protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException { - Map policies = new HashMap<>(); - assert parser.nextToken() == XContentParser.Token.START_OBJECT; - assert parser.nextToken() == XContentParser.Token.FIELD_NAME; - assert parser.currentName().equals("policies"); - assert parser.nextToken() == XContentParser.Token.START_ARRAY; - - XContentParser.Token token; - while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { - assert token == XContentParser.Token.START_OBJECT; - EnrichPolicy.NamedPolicy policy = EnrichPolicy.NamedPolicy.fromXContent(parser); - policies.put(policy.getName(), policy.getPolicy()); - } - - return new ListEnrichPolicyAction.Response(policies); - } - - @Override - protected ListEnrichPolicyAction.Response createTestInstance() { - Map items = new HashMap<>(); - for (int i = 0; i < randomIntBetween(0, 3); i++) { - EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); - items.put(randomAlphaOfLength(3), policy); - } - return new ListEnrichPolicyAction.Response(items); - } - - @Override - protected Writeable.Reader instanceReader() { - return ListEnrichPolicyAction.Response::new; - } - - @Override - protected void assertEqualInstances(ListEnrichPolicyAction.Response expectedInstance, ListEnrichPolicyAction.Response newInstance) { - assertThat(expectedInstance.getPolicies().size(), equalTo(newInstance.getPolicies().size())); - for (EnrichPolicy.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() - .filter(p -> p.getName().equals(expectedPolicy.getName())).findFirst(); - assertTrue(maybePolicy.isPresent()); - EnrichPolicy.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/TransportGetEnrichPolicyActionTests.java b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyActionTests.java new file mode 100644 index 00000000000..a3dab01bce1 --- /dev/null +++ b/x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyActionTests.java @@ -0,0 +1,209 @@ +/* + * 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.action; + +import org.elasticsearch.ResourceNotFoundException; +import org.elasticsearch.action.ActionListener; +import org.elasticsearch.action.support.master.AcknowledgedResponse; +import org.elasticsearch.cluster.service.ClusterService; +import org.elasticsearch.common.xcontent.XContentType; +import org.elasticsearch.xpack.core.enrich.EnrichPolicy; +import org.elasticsearch.xpack.core.enrich.action.DeleteEnrichPolicyAction; +import org.elasticsearch.xpack.core.enrich.action.GetEnrichPolicyAction; +import org.elasticsearch.xpack.enrich.AbstractEnrichTestCase; +import org.junit.After; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.atomic.AtomicReference; + +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.assertEqualPolicies; +import static org.elasticsearch.xpack.enrich.EnrichPolicyTests.randomEnrichPolicy; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.nullValue; +import static org.hamcrest.core.IsInstanceOf.instanceOf; + +public class TransportGetEnrichPolicyActionTests extends AbstractEnrichTestCase { + + @After + private void cleanupPolicies() throws InterruptedException { + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference reference = new AtomicReference<>(); + final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class); + transportAction.execute(null, + new GetEnrichPolicyAction.Request(), + new ActionListener() { + @Override + public void onResponse(GetEnrichPolicyAction.Response response) { + reference.set(response); + latch.countDown(); + + } + + public void onFailure(final Exception e) { + fail(); + } + }); + latch.await(); + assertNotNull(reference.get()); + GetEnrichPolicyAction.Response response = reference.get(); + + for (EnrichPolicy.NamedPolicy policy: response.getPolicies()) { + final CountDownLatch loopLatch = new CountDownLatch(1); + final AtomicReference loopReference = new AtomicReference<>(); + final TransportDeleteEnrichPolicyAction deleteAction = node().injector().getInstance(TransportDeleteEnrichPolicyAction.class); + deleteAction.execute(null, + new DeleteEnrichPolicyAction.Request(policy.getName()), + new ActionListener() { + @Override + public void onResponse(AcknowledgedResponse acknowledgedResponse) { + loopReference.set(acknowledgedResponse); + loopLatch.countDown(); + } + + public void onFailure(final Exception e) { + fail(); + } + }); + loopLatch.await(); + assertNotNull(loopReference.get()); + assertTrue(loopReference.get().isAcknowledged()); + } + } + + public void testListPolicies() throws InterruptedException { + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + ClusterService clusterService = getInstanceFromNode(ClusterService.class); + String name = "my-policy"; + + AtomicReference error = saveEnrichPolicy(name, policy, clusterService); + assertThat(error.get(), nullValue()); + + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference reference = new AtomicReference<>(); + final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class); + transportAction.execute(null, + // empty or null should return the same + randomBoolean() ? new GetEnrichPolicyAction.Request() : new GetEnrichPolicyAction.Request(""), + new ActionListener() { + @Override + public void onResponse(GetEnrichPolicyAction.Response response) { + reference.set(response); + latch.countDown(); + + } + + public void onFailure(final Exception e) { + fail(); + } + }); + latch.await(); + assertNotNull(reference.get()); + GetEnrichPolicyAction.Response response = reference.get(); + + assertThat(response.getPolicies().size(), equalTo(1)); + + EnrichPolicy.NamedPolicy actualPolicy = response.getPolicies().get(0); + assertThat(name, equalTo(actualPolicy.getName())); + assertEqualPolicies(policy, actualPolicy.getPolicy()); + } + + public void testListEmptyPolicies() throws InterruptedException { + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference reference = new AtomicReference<>(); + final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class); + transportAction.execute(null, + new GetEnrichPolicyAction.Request(), + new ActionListener() { + @Override + public void onResponse(GetEnrichPolicyAction.Response response) { + reference.set(response); + latch.countDown(); + + } + + public void onFailure(final Exception e) { + fail(); + } + }); + latch.await(); + assertNotNull(reference.get()); + GetEnrichPolicyAction.Response response = reference.get(); + + assertThat(response.getPolicies().size(), equalTo(0)); + } + + public void testGetPolicy() throws InterruptedException { + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + ClusterService clusterService = getInstanceFromNode(ClusterService.class); + String name = "my-policy"; + + AtomicReference error = saveEnrichPolicy(name, policy, clusterService); + assertThat(error.get(), nullValue()); + + // save a second one to verify the count below on GET + error = saveEnrichPolicy("something-else", randomEnrichPolicy(XContentType.JSON), clusterService); + assertThat(error.get(), nullValue()); + + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference reference = new AtomicReference<>(); + final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class); + transportAction.execute(null, + new GetEnrichPolicyAction.Request(name), + new ActionListener() { + @Override + public void onResponse(GetEnrichPolicyAction.Response response) { + reference.set(response); + latch.countDown(); + + } + + public void onFailure(final Exception e) { + fail(); + } + }); + latch.await(); + assertNotNull(reference.get()); + GetEnrichPolicyAction.Response response = reference.get(); + + assertThat(response.getPolicies().size(), equalTo(1)); + + EnrichPolicy.NamedPolicy actualPolicy = response.getPolicies().get(0); + assertThat(name, equalTo(actualPolicy.getName())); + assertEqualPolicies(policy, actualPolicy.getPolicy()); + } + + public void testGetPolicyThrowsError() throws InterruptedException { + EnrichPolicy policy = randomEnrichPolicy(XContentType.JSON); + ClusterService clusterService = getInstanceFromNode(ClusterService.class); + String name = "my-policy"; + + AtomicReference error = saveEnrichPolicy(name, policy, clusterService); + assertThat(error.get(), nullValue()); + + final CountDownLatch latch = new CountDownLatch(1); + final AtomicReference reference = new AtomicReference<>(); + final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class); + transportAction.execute(null, + new GetEnrichPolicyAction.Request("non-exists"), + new ActionListener() { + @Override + public void onResponse(GetEnrichPolicyAction.Response response) { + fail(); + } + + public void onFailure(final Exception e) { + reference.set(e); + latch.countDown(); + } + }); + latch.await(); + assertNotNull(reference.get()); + assertThat(reference.get(), instanceOf(ResourceNotFoundException.class)); + assertThat(reference.get().getMessage(), + equalTo("Policy [non-exists] was not found")); + } +} diff --git a/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.get_policy.json b/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.get_policy.json index 993572f861f..c2629eb3a6c 100644 --- a/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.get_policy.json +++ b/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.get_policy.json @@ -4,8 +4,7 @@ "stability" : "stable", "methods": [ "GET" ], "url": { - "path": "/_enrich/policy/{name}", - "paths": ["/_enrich/policy/{name}"], + "paths": ["/_enrich/policy/{name}", "/_enrich/policy/"], "parts": { "name": { "type" : "string", diff --git a/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.list_policy.json b/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.list_policy.json deleted file mode 100644 index f275f2de6a6..00000000000 --- a/x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.list_policy.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "enrich.list_policy": { - "documentation": "https://www.elastic.co/guide/en/elasticsearch/reference/current/enrich-list-policy.html", - "stability" : "stable", - "methods": [ "GET" ], - "url": { - "path": "/_enrich/policy", - "paths": ["/_enrich/policy"], - "parts": {}, - "params": {} - }, - "body": null - } -}