Add MultiSearchTemplate support to High Level Rest client

client/rest-high-level/src/main/java/org/elasticsearch/client/RequestConverters.java

@@ -103,6 +103,7 @@
 import org.elasticsearch.index.VersionType;
 import org.elasticsearch.index.rankeval.RankEvalRequest;
 import org.elasticsearch.rest.action.search.RestSearchAction;
+import org.elasticsearch.script.mustache.MultiSearchTemplateRequest;
 import org.elasticsearch.script.mustache.SearchTemplateRequest;
 import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
 import org.elasticsearch.tasks.TaskId;
@@ -604,6 +605,21 @@ static Request searchTemplate(SearchTemplateRequest searchTemplateRequest) throw
         request.setEntity(createEntity(searchTemplateRequest, REQUEST_BODY_CONTENT_TYPE));
         return request;
     }
+
+    static Request multiSearchTemplate(MultiSearchTemplateRequest multiSearchTemplateRequest) throws IOException {
+        Request request = new Request(HttpPost.METHOD_NAME, "/_msearch/template");
+
+        Params params = new Params(request);
+        params.putParam(RestSearchAction.TYPED_KEYS_PARAM, "true");
+        if (multiSearchTemplateRequest.maxConcurrentSearchRequests() != MultiSearchRequest.MAX_CONCURRENT_SEARCH_REQUESTS_DEFAULT) {
+            params.putParam("max_concurrent_searches", Integer.toString(multiSearchTemplateRequest.maxConcurrentSearchRequests()));
+        }
+
+        XContent xContent = REQUEST_BODY_CONTENT_TYPE.xContent();
+        byte[] source = MultiSearchTemplateRequest.writeMultiLineFormat(multiSearchTemplateRequest, xContent);
+        request.setEntity(new ByteArrayEntity(source, createContentType(xContent.type())));
+        return request;
+    }    
 
     static Request existsAlias(GetAliasesRequest getAliasesRequest) {
         if ((getAliasesRequest.indices() == null || getAliasesRequest.indices().length == 0) &&

client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java

@@ -68,6 +68,8 @@
 import org.elasticsearch.plugins.spi.NamedXContentProvider;
 import org.elasticsearch.rest.BytesRestResponse;
 import org.elasticsearch.rest.RestStatus;
+import org.elasticsearch.script.mustache.MultiSearchTemplateRequest;
+import org.elasticsearch.script.mustache.MultiSearchTemplateResponse;
 import org.elasticsearch.script.mustache.SearchTemplateRequest;
 import org.elasticsearch.script.mustache.SearchTemplateResponse;
 import org.elasticsearch.search.aggregations.Aggregation;
@@ -666,6 +668,32 @@ public final RankEvalResponse rankEval(RankEvalRequest rankEvalRequest, RequestO
                 emptySet());
     }
 
+
+    /**
+     * Executes a request using the Multi Search Template API.
+     *
+     * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-search-template.html">Multi Search Template API
+     * on elastic.co</a>.
+     */
+    public final MultiSearchTemplateResponse multiSearchTemplate(MultiSearchTemplateRequest multiSearchTemplateRequest,
+            RequestOptions options) throws IOException {
+        return performRequestAndParseEntity(multiSearchTemplateRequest, RequestConverters::multiSearchTemplate,
+                options, MultiSearchTemplateResponse::fromXContext, emptySet());        
+    }   
+
+    /**
+     * Asynchronously executes a request using the Multi Search Template API
+     *
+     * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/multi-search-template.html">Multi Search Template API
+     * on elastic.co</a>.
+     */
+    public final void multiSearchTemplateAsync(MultiSearchTemplateRequest multiSearchTemplateRequest,
+                                          RequestOptions options,
+                                          ActionListener<MultiSearchTemplateResponse> listener) {
+        performRequestAsyncAndParseEntity(multiSearchTemplateRequest, RequestConverters::multiSearchTemplate,
+            options, MultiSearchTemplateResponse::fromXContext, listener, emptySet());
+    }    
+
     /**
      * Asynchronously executes a request using the Ranking Evaluation API.
      * See <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/search-rank-eval.html">Ranking Evaluation API

client/rest-high-level/src/test/java/org/elasticsearch/client/RequestConvertersTests.java

@@ -124,6 +124,7 @@
 import org.elasticsearch.repositories.fs.FsRepository;
 import org.elasticsearch.rest.action.search.RestSearchAction;
 import org.elasticsearch.script.ScriptType;
+import org.elasticsearch.script.mustache.MultiSearchTemplateRequest;
 import org.elasticsearch.script.mustache.SearchTemplateRequest;
 import org.elasticsearch.search.Scroll;
 import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
@@ -1373,7 +1374,53 @@ public void testRenderSearchTemplate() throws Exception {
         assertEquals(Collections.emptyMap(), request.getParameters());
         assertToXContentBody(searchTemplateRequest, request.getEntity());
     }
-
+
+    public void testMultiSearchTemplate() throws Exception {
+        final int numSearchRequests = randomIntBetween(1, 10);
+        MultiSearchTemplateRequest multiSearchTemplateRequest = new MultiSearchTemplateRequest();
+
+        for (int i = 0; i < numSearchRequests; i++) {
+            // Create a random request.
+            String[] indices = randomIndicesNames(0, 5);
+            SearchRequest searchRequest = new SearchRequest(indices);
+
+            Map<String, String> expectedParams = new HashMap<>();
+            setRandomSearchParams(searchRequest, expectedParams);
+
+            // scroll is not supported in the current msearch or msearchtemplate api, so unset it:
+            searchRequest.scroll((Scroll) null);
+            // batched reduce size is currently not set-able on a per-request basis as it is a query string parameter only
+            searchRequest.setBatchedReduceSize(SearchRequest.DEFAULT_BATCHED_REDUCE_SIZE);
+
+            setRandomIndicesOptions(searchRequest::indicesOptions, searchRequest::indicesOptions, expectedParams);
+
+            SearchTemplateRequest searchTemplateRequest = new SearchTemplateRequest(searchRequest);
+
+            searchTemplateRequest.setScript("{\"query\": { \"match\" : { \"{{field}}\" : \"{{value}}\" }}}");
+            searchTemplateRequest.setScriptType(ScriptType.INLINE);
+            searchTemplateRequest.setProfile(randomBoolean());
+
+            Map<String, Object> scriptParams = new HashMap<>();
+            scriptParams.put("field", "name");
+            scriptParams.put("value", randomAlphaOfLengthBetween(2, 5));
+            searchTemplateRequest.setScriptParams(scriptParams);
+
+            multiSearchTemplateRequest.add(searchTemplateRequest);            
+        }
+
+        Request multiRequest = RequestConverters.multiSearchTemplate(multiSearchTemplateRequest);
+
+        assertEquals(HttpPost.METHOD_NAME, multiRequest.getMethod());
+        assertEquals("/_msearch/template", multiRequest.getEndpoint());
+        List<SearchTemplateRequest> searchRequests = multiSearchTemplateRequest.requests();
+        assertEquals(numSearchRequests, searchRequests.size());
+
+        HttpEntity actualEntity = multiRequest.getEntity();
+        byte[] expectedBytes = MultiSearchTemplateRequest.writeMultiLineFormat(multiSearchTemplateRequest, XContentType.JSON.xContent());
+        assertEquals(XContentType.JSON.mediaTypeWithoutParameters(), actualEntity.getContentType().getValue());
+        assertEquals(new BytesArray(expectedBytes), new BytesArray(EntityUtils.toByteArray(actualEntity)));        
+    }
+
     public void testExistsAlias() {
         GetAliasesRequest getAliasesRequest = new GetAliasesRequest();
         String[] indices = randomBoolean() ? null : randomIndicesNames(0, 5);
@@ -2385,7 +2432,7 @@ private static void setRandomSearchParams(SearchRequest searchRequest,
             expectedParams.put("preference", searchRequest.preference());
         }
         if (randomBoolean()) {
-            searchRequest.searchType(randomFrom(SearchType.values()));
+            searchRequest.searchType(randomFrom(SearchType.CURRENTLY_SUPPORTED));
         }
         expectedParams.put("search_type", searchRequest.searchType().name().toLowerCase(Locale.ROOT));
         if (randomBoolean()) {

client/rest-high-level/src/test/java/org/elasticsearch/client/SearchIT.java

@@ -54,6 +54,9 @@
 import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.script.ScriptType;
+import org.elasticsearch.script.mustache.MultiSearchTemplateRequest;
+import org.elasticsearch.script.mustache.MultiSearchTemplateResponse;
+import org.elasticsearch.script.mustache.MultiSearchTemplateResponse.Item;
 import org.elasticsearch.script.mustache.SearchTemplateRequest;
 import org.elasticsearch.script.mustache.SearchTemplateResponse;
 import org.elasticsearch.search.SearchHit;
@@ -875,6 +878,105 @@ public void testRenderSearchTemplate() throws IOException {
 
         assertToXContentEquivalent(expectedSource, actualSource, XContentType.JSON);
     }
+
+
+    public void testMultiSearchTemplate() throws Exception {
+        MultiSearchTemplateRequest multiSearchTemplateRequest = new MultiSearchTemplateRequest();
+
+        SearchTemplateRequest goodRequest = new SearchTemplateRequest();
+        goodRequest.setRequest(new SearchRequest("index"));
+        goodRequest.setScriptType(ScriptType.INLINE);
+        goodRequest.setScript(
+            "{" +
+            "  \"query\": {" +
+            "    \"match\": {" +
+            "      \"num\": {{number}}" +
+            "    }" +
+            "  }" +
+            "}");
+        Map<String, Object> scriptParams = new HashMap<>();
+        scriptParams.put("number", 10);
+        goodRequest.setScriptParams(scriptParams);
+        goodRequest.setExplain(true);
+        goodRequest.setProfile(true);
+        multiSearchTemplateRequest.add(goodRequest);
+
+
+        SearchTemplateRequest badRequest = new SearchTemplateRequest();
+        badRequest.setRequest(new SearchRequest("index"));
+        badRequest.setScriptType(ScriptType.INLINE);
+        badRequest.setScript("{ NOT VALID JSON {{number}} }");
+        scriptParams = new HashMap<>();
+        scriptParams.put("number", 10);
+        badRequest.setScriptParams(scriptParams);
+
+        multiSearchTemplateRequest.add(badRequest);        
+
+        MultiSearchTemplateResponse multiSearchTemplateResponse =
+                execute(multiSearchTemplateRequest, highLevelClient()::multiSearchTemplate, 
+                        highLevelClient()::multiSearchTemplateAsync);
+
+        Item[] responses = multiSearchTemplateResponse.getResponses();
+
+        assertEquals(2, responses.length);
+
+
+        assertNull(responses[0].getResponse().getSource());
+        SearchResponse goodResponse =responses[0].getResponse().getResponse();
+        assertNotNull(goodResponse);
+        assertThat(responses[0].isFailure(), Matchers.is(false));
+        assertEquals(1, goodResponse.getHits().totalHits);
+        assertEquals(1, goodResponse.getHits().getHits().length);
+        assertThat(goodResponse.getHits().getMaxScore(), greaterThan(0f));
+        SearchHit hit = goodResponse.getHits().getHits()[0];
+        assertNotNull(hit.getExplanation());
+        assertFalse(goodResponse.getProfileResults().isEmpty());        
+
+
+        assertNull(responses[0].getResponse().getSource());
+        assertThat(responses[1].isFailure(), Matchers.is(true));
+        assertNotNull(responses[1].getFailureMessage());        
+        assertThat(responses[1].getFailureMessage(), containsString("json_parse_exception"));
+    }
+
+    public void testMultiSearchTemplateAllBad() throws Exception {
+        MultiSearchTemplateRequest multiSearchTemplateRequest = new MultiSearchTemplateRequest();
+
+        SearchTemplateRequest badRequest1 = new SearchTemplateRequest();
+        badRequest1.setRequest(new SearchRequest("index"));
+        badRequest1.setScriptType(ScriptType.INLINE);
+        badRequest1.setScript(
+                "{" +
+                        "  \"query\": {" +
+                        "    \"match\": {" +
+                        "      \"num\": {{number}}" +
+                        "    }" +
+                        "  }" +
+                        "}");
+        Map<String, Object> scriptParams = new HashMap<>();
+        scriptParams.put("number", "BAD NUMBER");
+        badRequest1.setScriptParams(scriptParams);
+        multiSearchTemplateRequest.add(badRequest1);
+
+
+        SearchTemplateRequest badRequest2 = new SearchTemplateRequest();
+        badRequest2.setRequest(new SearchRequest("index"));
+        badRequest2.setScriptType(ScriptType.INLINE);
+        badRequest2.setScript("BAD QUERY TEMPLATE");
+        scriptParams = new HashMap<>();
+        scriptParams.put("number", "BAD NUMBER");
+        badRequest2.setScriptParams(scriptParams);
+
+        multiSearchTemplateRequest.add(badRequest2);        
+
+        // The whole HTTP request should fail if no nested search requests are valid 
+        ElasticsearchStatusException exception = expectThrows(ElasticsearchStatusException.class,
+                () -> execute(multiSearchTemplateRequest, highLevelClient()::multiSearchTemplate, 
+                        highLevelClient()::multiSearchTemplateAsync));
+
+        assertEquals(RestStatus.BAD_REQUEST, exception.status());
+        assertThat(exception.getMessage(), containsString("no requests added"));
+    }
 
     public void testExplain() throws IOException {
         {