honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Consolidate enrich list all and get by name APIs (#45705) 

The get and list APIs are a single API in this commit. Whether
requesting one named policy or all policies, a list of policies is
returened. The list API code has all been removed and the GET api is
what remains, which contains much of the list response code.
This commit is contained in:
Michael Basnight 2019-08-20 10:05:45 -05:00
parent 5ea0985711
commit e3373d349b
18 changed files with 323 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
client/rest-high-level/src/test/java/org/elasticsearch/client/EnrichIT.java
View File

@ -45,10 +45,13 @@ public class EnrichIT extends ESRestHighLevelClientTestCase {
Response getPolicyResponse = highLevelClient().getLowLevelClient().performRequest(getPolicyRequest);
assertThat(getPolicyResponse.getHttpResponse().getStatusLine().getStatusCode(), equalTo(200));
Map<String, Object> 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<Map<String, Object>> responsePolicies = (List<Map<String, Object>>) 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<String, Object> toMap(Response response) throws IOException {

28
docs/reference/ingest/ingest-node.asciidoc
View File

@ -967,7 +967,6 @@ Also there are several APIs in order to manage and execute enrich policies:
* <<get-policy-api,Get policy api>>.
* <<delete-policy-api,Delete policy api>>.
* <<execute-policy-api,Execute policy api>>.
* <<list-policies-api,List policies api>>.
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:

35
x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/GetEnrichPolicyAction.java
View File

@ -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<GetEnrichPolicyAction.Response> {
@ -31,6 +35,8 @@ public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Resp
private String name;
public Request() { }
public Request(String name) {
this.name = name;
}
@ -75,34 +81,43 @@ public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Resp
public static class Response extends ActionResponse implements ToXContentObject {
private final EnrichPolicy policy;
private final List<EnrichPolicy.NamedPolicy> policies;
public Response(EnrichPolicy policy) {
this.policy = Objects.requireNonNull(policy, "policy cannot be null");
public Response(Map<String, EnrichPolicy> 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<EnrichPolicy.NamedPolicy> getPolicies() {
return policies;
}
@Override
@ -110,12 +125,12 @@ public class GetEnrichPolicyAction extends ActionType<GetEnrichPolicyAction.Resp
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Response response = (Response) o;
return policy.equals(response.policy);
return policies.equals(response.policies);
}
@Override
public int hashCode() {
return Objects.hash(policy);
return Objects.hash(policies);
}
}
}

102
x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/enrich/action/ListEnrichPolicyAction.java
View File

@ -1,102 +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.core.enrich.action;
import org.elasticsearch.action.ActionType;
import org.elasticsearch.action.ActionRequestValidationException;
import org.elasticsearch.action.ActionResponse;
import org.elasticsearch.action.support.master.MasterNodeRequest;
import org.elasticsearch.common.io.stream.StreamInput;
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 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 ListEnrichPolicyAction extends ActionType<ListEnrichPolicyAction.Response> {
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<ListEnrichPolicyAction.Request> {
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<EnrichPolicy.NamedPolicy> policies;
public Response(Map<String, EnrichPolicy> 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<EnrichPolicy.NamedPolicy> 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);
}
}
}

2
x-pack/plugin/core/src/test/java/org/elasticsearch/xpack/core/security/authz/privilege/PrivilegeTests.java
View File

@ -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");

12
x-pack/plugin/enrich/qa/rest/src/test/resources/rest-api-spec/test/enrich/10_basic.yml
View File

@ -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 }

5
x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichPlugin.java
View File

@ -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)
);

17
x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyAction.java
View File

@ -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<GetEnrichPolicyAction.Request,
GetEnrichPolicyAction.Response> {
@ -55,11 +57,18 @@ public class TransportGetEnrichPolicyAction extends TransportMasterNodeReadActio
protected void masterOperation(GetEnrichPolicyAction.Request request,
ClusterState state,
ActionListener<GetEnrichPolicyAction.Response> listener) throws Exception {
final EnrichPolicy policy = EnrichStore.getPolicy(request.getName(), state);
if (policy == null) {
throw new ResourceNotFoundException("Policy [{}] was not found", request.getName());
Map<String, EnrichPolicy> 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

67
x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/action/TransportListEnrichPolicyAction.java
View File

@ -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<ListEnrichPolicyAction.Request, ListEnrichPolicyAction.Response> {
@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<ListEnrichPolicyAction.Response> listener) throws Exception {
Map<String, EnrichPolicy> 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);
}
}

1
x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestGetEnrichPolicyAction.java
View File

@ -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

33
x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/rest/RestListEnrichPolicyAction.java
View File

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

14
x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichMultiNodeIT.java
View File

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

6
x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichRestartIT.java
View File

@ -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;

37
x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/GetEnrichPolicyActionResponseTests.java
View File

@ -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<GetEnrichPolicyAction.Response> {
@Override
protected GetEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException {
EnrichPolicy policy = EnrichPolicy.fromXContent(parser);
return new GetEnrichPolicyAction.Response(policy);
Map<String, EnrichPolicy> 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<String, EnrichPolicy> 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());
}
}
}

72
x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/ListEnrichPolicyActionResponseTests.java
View File

@ -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<ListEnrichPolicyAction.Response> {
@Override
protected ListEnrichPolicyAction.Response doParseInstance(XContentParser parser) throws IOException {
Map<String, EnrichPolicy> 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<String, EnrichPolicy> 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<ListEnrichPolicyAction.Response> 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<EnrichPolicy.NamedPolicy> 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()));
}
}
}

209
x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/action/TransportGetEnrichPolicyActionTests.java Normal file
View File

@ -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<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
transportAction.execute(null,
new GetEnrichPolicyAction.Request(),
new ActionListener<GetEnrichPolicyAction.Response>() {
@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<AcknowledgedResponse> loopReference = new AtomicReference<>();
final TransportDeleteEnrichPolicyAction deleteAction = node().injector().getInstance(TransportDeleteEnrichPolicyAction.class);
deleteAction.execute(null,
new DeleteEnrichPolicyAction.Request(policy.getName()),
new ActionListener<AcknowledgedResponse>() {
@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<Exception> error = saveEnrichPolicy(name, policy, clusterService);
assertThat(error.get(), nullValue());
final CountDownLatch latch = new CountDownLatch(1);
final AtomicReference<GetEnrichPolicyAction.Response> 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<GetEnrichPolicyAction.Response>() {
@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<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
transportAction.execute(null,
new GetEnrichPolicyAction.Request(),
new ActionListener<GetEnrichPolicyAction.Response>() {
@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<Exception> 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<GetEnrichPolicyAction.Response> reference = new AtomicReference<>();
final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
transportAction.execute(null,
new GetEnrichPolicyAction.Request(name),
new ActionListener<GetEnrichPolicyAction.Response>() {
@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<Exception> error = saveEnrichPolicy(name, policy, clusterService);
assertThat(error.get(), nullValue());
final CountDownLatch latch = new CountDownLatch(1);
final AtomicReference<Exception> reference = new AtomicReference<>();
final TransportGetEnrichPolicyAction transportAction = node().injector().getInstance(TransportGetEnrichPolicyAction.class);
transportAction.execute(null,
new GetEnrichPolicyAction.Request("non-exists"),
new ActionListener<GetEnrichPolicyAction.Response>() {
@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"));
}
}

3
x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.get_policy.json
View File

@ -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",

14
x-pack/plugin/src/test/resources/rest-api-spec/api/enrich.list_policy.json
View File

@ -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
}
}