Merge pull request #147 from bpintea/rest_endpoint

ESQL: add REST endpoint

Author: bpintea

x-pack/plugin/esql/qa/build.gradle

@@ -0,0 +1 @@
+description = 'Integration tests for ESQL'

x-pack/plugin/esql/qa/server/build.gradle

@@ -0,0 +1,54 @@
+apply plugin: 'elasticsearch.java'
+
+description = 'Integration tests for ESQL'
+
+dependencies {
+  api project(":test:framework")
+
+  // Common utilities from QL
+  api project(xpackModule('ql:test-fixtures'))
+}
+
+subprojects {
+  if (subprojects.isEmpty()) {
+    // leaf project
+  } else {
+    apply plugin: 'elasticsearch.java'
+    apply plugin: 'elasticsearch.standalone-rest-test'
+  }
+
+
+  if (project.name != 'security') {
+    // The security project just configures its subprojects
+    apply plugin: 'elasticsearch.internal-java-rest-test'
+
+    testClusters.matching { it.name == "javaRestTest" }.configureEach {
+      testDistribution = 'DEFAULT'
+      setting 'xpack.ml.enabled', 'false'
+      setting 'xpack.watcher.enabled', 'false'
+    }
+
+
+  dependencies {
+    configurations.javaRestTestRuntimeClasspath {
+      resolutionStrategy.force "org.slf4j:slf4j-api:1.7.25"
+    }
+    configurations.javaRestTestRuntimeOnly {
+      // This is also required to make resolveAllDependencies work
+      resolutionStrategy.force "org.slf4j:slf4j-api:1.7.25"
+    }
+
+    /* Since we're a standalone rest test we actually get transitive
+     * dependencies but we don't really want them because they cause
+     * all kinds of trouble with the jar hell checks. So we suppress
+     * them explicitly for non-es projects. */
+    javaRestTestImplementation(project(':x-pack:plugin:esql:qa:server')) {
+      transitive = false
+    }
+    javaRestTestImplementation project(":test:framework")
+    javaRestTestRuntimeOnly project(xpackModule('ql:test-fixtures'))
+
+    javaRestTestRuntimeOnly "org.slf4j:slf4j-api:1.7.25"
+  }
+  }
+}

x-pack/plugin/esql/qa/server/single-node/build.gradle

@@ -0,0 +1,7 @@
+testClusters.matching { it.name == "javaRestTest" }.configureEach {
+  testDistribution = 'DEFAULT'
+  setting 'xpack.security.enabled', 'false'
+  setting 'xpack.license.self_generated.type', 'trial'
+  plugin ':x-pack:qa:freeze-plugin'
+}
+

x-pack/plugin/esql/qa/server/single-node/src/javaRestTest/java/org/elasticsearch/xpack/esql/qa/single_node/RestEsqlIT.java

@@ -0,0 +1,11 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+package org.elasticsearch.xpack.esql.qa.single_node;
+
+import org.elasticsearch.xpack.esql.qa.rest.RestEsqlTestCase;
+
+public class RestEsqlIT extends RestEsqlTestCase {}

x-pack/plugin/esql/qa/server/src/main/java/org/elasticsearch/xpack/esql/qa/rest/RestEsqlTestCase.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.qa.rest;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.entity.ContentType;
+import org.apache.http.nio.entity.NByteArrayEntity;
+import org.elasticsearch.client.Request;
+import org.elasticsearch.client.RequestOptions;
+import org.elasticsearch.client.Response;
+import org.elasticsearch.common.xcontent.XContentHelper;
+import org.elasticsearch.test.rest.ESRestTestCase;
+import org.elasticsearch.xcontent.XContentBuilder;
+import org.elasticsearch.xcontent.XContentType;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.time.ZoneId;
+import java.util.Map;
+
+import static java.util.Collections.emptySet;
+
+public class RestEsqlTestCase extends ESRestTestCase {
+
+    public static class RequestObjectBuilder {
+        private final XContentBuilder builder;
+        private boolean isBuilt = false;
+
+        public RequestObjectBuilder() throws IOException {
+            this(XContentType.JSON);
+        }
+
+        public RequestObjectBuilder(XContentType type) throws IOException {
+            builder = XContentBuilder.builder(type, emptySet(), emptySet());
+            builder.startObject();
+        }
+
+        public RequestObjectBuilder query(String query) throws IOException {
+            builder.field("query", query);
+            return this;
+        }
+
+        public RequestObjectBuilder columnar(boolean columnar) throws IOException {
+            builder.field("columnar", columnar);
+            return this;
+        }
+
+        public RequestObjectBuilder timeZone(ZoneId zoneId) throws IOException {
+            builder.field("time_zone", zoneId);
+            return this;
+        }
+
+        public RequestObjectBuilder build() throws IOException {
+            if (isBuilt == false) {
+                builder.endObject();
+                isBuilt = true;
+            }
+            return this;
+        }
+
+        public OutputStream getOutputStream() throws IOException {
+            if (isBuilt == false) {
+                throw new IllegalStateException("object not yet built");
+            }
+            builder.flush();
+            return builder.getOutputStream();
+        }
+
+        public XContentType contentType() {
+            return builder.contentType();
+        }
+
+        public static RequestObjectBuilder jsonBuilder() throws IOException {
+            return new RequestObjectBuilder(XContentType.JSON);
+        }
+    }
+
+    public void testGetAnswer() throws IOException {
+        RequestObjectBuilder builder = new RequestObjectBuilder(randomFrom(XContentType.values()));
+        Map<String, Object> answer = runEsql(builder.query(randomAlphaOfLength(10)).build());
+        assertEquals(2, answer.size());
+        assertTrue(answer.containsKey("columns"));
+        assertTrue(answer.containsKey("values"));
+    }
+
+    private static Map<String, Object> runEsql(RequestObjectBuilder requestObject) throws IOException {
+        Request request = new Request("POST", "/_esql");
+        request.addParameter("error_trace", "true");
+        String mediaType = requestObject.contentType().mediaTypeWithoutParameters();
+
+        try (ByteArrayOutputStream bos = (ByteArrayOutputStream) requestObject.getOutputStream()) {
+            request.setEntity(new NByteArrayEntity(bos.toByteArray(), ContentType.getByMimeType(mediaType)));
+        }
+
+        RequestOptions.Builder options = request.getOptions().toBuilder();
+        options.addHeader("Accept", mediaType);
+        options.addHeader("Content-Type", mediaType);
+        request.setOptions(options);
+
+        Response response = client().performRequest(request);
+        HttpEntity entity = response.getEntity();
+        try (InputStream content = entity.getContent()) {
+            XContentType xContentType = XContentType.fromMediaType(entity.getContentType().getValue());
+            assertNotNull(xContentType);
+            return XContentHelper.convertToMap(xContentType.xContent(), content, false);
+        }
+    }
+}

x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/EsqlActionIT.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.action;
+
+import org.elasticsearch.plugins.Plugin;
+import org.elasticsearch.test.ESIntegTestCase;
+import org.elasticsearch.xpack.esql.plugin.EsqlPlugin;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import static org.elasticsearch.test.ESIntegTestCase.Scope.SUITE;
+
+@ESIntegTestCase.ClusterScope(scope = SUITE, numDataNodes = 0, numClientNodes = 0, maxNumDataNodes = 0)
+public class EsqlActionIT extends ESIntegTestCase {
+
+    public void testEsqlAction() {
+        EsqlQueryResponse response = new EsqlQueryRequestBuilder(client(), EsqlQueryAction.INSTANCE).query(randomAlphaOfLength(10)).get();
+        assertNotNull(response);
+    }
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return Collections.singletonList(EsqlPlugin.class);
+    }
+}

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlQueryAction.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.action;
+
+import org.elasticsearch.action.ActionType;
+
+public class EsqlQueryAction extends ActionType<EsqlQueryResponse> {
+
+    public static final EsqlQueryAction INSTANCE = new EsqlQueryAction();
+    public static final String NAME = "indices:data/read/esql";
+
+    private EsqlQueryAction() {
+        super(NAME, EsqlQueryResponse::new);
+    }
+}

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlQueryRequest.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.action;
+
+import org.elasticsearch.action.ActionRequest;
+import org.elasticsearch.action.ActionRequestValidationException;
+import org.elasticsearch.action.CompositeIndicesRequest;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.xcontent.ObjectParser;
+import org.elasticsearch.xcontent.ParseField;
+import org.elasticsearch.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.time.ZoneId;
+import java.util.function.Supplier;
+
+import static org.elasticsearch.action.ValidateActions.addValidationError;
+
+public class EsqlQueryRequest extends ActionRequest implements CompositeIndicesRequest {
+
+    private static final ParseField QUERY_FIELD = new ParseField("query");
+    private static final ParseField COLUMNAR_FIELD = new ParseField("columnar"); // TODO -> "mode"?
+    private static final ParseField TIME_ZONE_FIELD = new ParseField("time_zone");
+
+    private static final ObjectParser<EsqlQueryRequest, Void> PARSER = objectParser(EsqlQueryRequest::new);
+
+    private String query;
+    private boolean columnar;
+    private ZoneId zoneId;
+
+    public EsqlQueryRequest(StreamInput in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        ActionRequestValidationException validationException = null;
+        if (Strings.hasText(query) == false) {
+            validationException = addValidationError("[query] is required", null);
+        }
+        return validationException;
+    }
+
+    public EsqlQueryRequest() {}
+
+    public void query(String query) {
+        this.query = query;
+    }
+
+    public String query() {
+        return query;
+    }
+
+    public void columnar(boolean columnar) {
+        this.columnar = columnar;
+    }
+
+    public boolean columnar() {
+        return columnar;
+    }
+
+    public void zoneId(ZoneId zoneId) {
+        this.zoneId = zoneId;
+    }
+
+    public ZoneId zoneId() {
+        return zoneId;
+    }
+
+    public static EsqlQueryRequest fromXContent(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    private static ObjectParser<EsqlQueryRequest, Void> objectParser(Supplier<EsqlQueryRequest> supplier) {
+        ObjectParser<EsqlQueryRequest, Void> parser = new ObjectParser<>("esql/query", false, supplier);
+        parser.declareString(EsqlQueryRequest::query, QUERY_FIELD);
+        parser.declareBoolean(EsqlQueryRequest::columnar, COLUMNAR_FIELD);
+        parser.declareString((request, zoneId) -> request.zoneId(ZoneId.of(zoneId)), TIME_ZONE_FIELD);
+        return parser;
+    }
+}

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlQueryRequestBuilder.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+
+package org.elasticsearch.xpack.esql.action;
+
+import org.elasticsearch.action.ActionRequestBuilder;
+import org.elasticsearch.client.internal.ElasticsearchClient;
+
+import java.time.ZoneId;
+
+public class EsqlQueryRequestBuilder extends ActionRequestBuilder<EsqlQueryRequest, EsqlQueryResponse> {
+
+    public EsqlQueryRequestBuilder(ElasticsearchClient client, EsqlQueryAction action, EsqlQueryRequest request) {
+        super(client, action, request);
+    }
+
+    public EsqlQueryRequestBuilder(ElasticsearchClient client, EsqlQueryAction action) {
+        this(client, action, new EsqlQueryRequest());
+    }
+
+    public EsqlQueryRequestBuilder query(String query) {
+        request.query(query);
+        return this;
+    }
+
+    public EsqlQueryRequestBuilder columnar(boolean columnar) {
+        request.columnar(columnar);
+        return this;
+    }
+
+    public EsqlQueryRequestBuilder timeZone(ZoneId zoneId) {
+        request.zoneId(zoneId);
+        return this;
+    }
+}