Add SearchStrategyRegistry and defaultSearchStrategy to support existing search behavior, and integrate it with CallClient.

src/core_plugins/kibana/public/kibana.js

@@ -41,6 +41,7 @@ import 'uiExports/devTools';
 import 'uiExports/docViews';
 import 'uiExports/embeddableFactories';
 import 'uiExports/inspectorViews';
+import 'uiExports/search';
 
 import 'ui/autoload/all';
 import './home';

src/ui/public/courier/courier.js

@@ -74,12 +74,12 @@ uiModules.get('kibana/courier').service('courier', ($rootScope, Private) => {
     /**
      * Fetch the pending requests.
      */
-    fetch = () => {
+    fetch() {
       fetchSoon.fetchQueued().then(() => {
         // Reset the timer using the time that we get this response as the starting point.
         searchPoll.resetTimer();
       });
-    };
+    }
   }
 
   return new Courier();

src/ui/public/courier/fetch/call_client.js

@@ -20,6 +20,7 @@
 import _ from 'lodash';
 
 import { ErrorAllowExplicitIndexProvider } from '../../error_allow_explicit_index';
+import { assignSearchRequestsToSearchStrategies } from '../search_strategy';
 import { IsRequestProvider } from './is_request';
 import { MergeDuplicatesRequestProvider } from './merge_duplicate_requests';
 import { RequestStatus } from './req_status';
@@ -39,10 +40,14 @@ export function CallClientProvider(Private, Promise, es) {
     const statuses = mergeDuplicateRequests(requests);
 
     // get the actual list of requests that we will be fetching
-    let requestsToFetch = statuses.filter(isRequest);
+    const requestsToFetch = statuses.filter(isRequest);
     let execCount = requestsToFetch.length;
 
-    if (!execCount) return Promise.resolve([]);
+    if (!execCount) {
+      return Promise.resolve([]);
+    }
+
+    const searchStrategiesWithRequests = assignSearchRequestsToSearchStrategies(requestsToFetch);
 
     // resolved by respond()
     let esPromise = undefined;
@@ -52,14 +57,25 @@ export function CallClientProvider(Private, Promise, es) {
     // for each respond with either the response or ABORTED
     const respond = function (responses) {
       responses = responses || [];
-      return Promise.map(requests, function (request, i) {
+      const activeSearchRequests = searchStrategiesWithRequests.reduce((allSearchRequests, { searchRequests }) => {
+        return allSearchRequests.concat(searchRequests);
+      }, [])
+        .filter(request => {
+          // We'll use the index of the request to map it to its response. If a request has already
+          // failed then it won't generate a response. In this case we need to remove the request
+          // to maintain cardinality between the list of requests and the list of corresponding
+          // responses.
+          return request !== undefined;
+        });
+
+      return Promise.map(activeSearchRequests, function (request, i) {
         switch (statuses[i]) {
           case ABORTED:
             return ABORTED;
           case DUPLICATE:
             return request._uniq.resp;
           default:
-            const index = _.findIndex(requestsToFetch, request);
+            const index = _.findIndex(activeSearchRequests, request);
             if (index < 0) {
               // This means the request failed.
               return ABORTED;
@@ -106,28 +122,27 @@ export function CallClientProvider(Private, Promise, es) {
     // We're going to create a new async context here, so that the logic within it can execute
     // asynchronously after we've returned a reference to defer.promise.
     Promise.resolve().then(async () => {
-      // Flatten the searchSource within each searchRequest to get the fetch params,
-      // e.g. body, filters, index pattern, query.
-      const allFetchParams = await getAllFetchParams(requestsToFetch);
-
-      // Serialize the fetch params into a format suitable for the body of an ES query.
-      const serializedFetchParams = await serializeAllFetchParams(allFetchParams, requestsToFetch);
-
-      // The index of the request inside requestsToFetch determines which response is mapped to it.
-      // If a request won't generate a response, since it already failed, we need to remove the
-      // request from the requestsToFetch array so the indexes will continue to match up to the
-      // responses correctly.
-      requestsToFetch = requestsToFetch.filter(request => request !== undefined);
+      // Execute each request using its search strategy.
+      const esPromises = searchStrategiesWithRequests.map(searchStrategyWithSearchRequests => {
+        const { searchStrategy, searchRequests } = searchStrategyWithSearchRequests;
+        return searchStrategy.search({ searchRequests, es, Promise, serializeFetchParams });
+      });
 
       try {
         // The request was aborted while we were doing the above logic.
         if (isRequestAborted) {
           throw ABORTED;
         }
 
-        esPromise = es.msearch({ body: serializedFetchParams });
-        const clientResponse = await esPromise;
-        await respond(clientResponse.responses);
+        esPromise = Promise.all(esPromises);
+        const segregatedResponses = await esPromise;
+
+        // Aggregate the responses returned by all of the search strategies.
+        const aggregatedResponses = segregatedResponses.reduce((aggregation, responses) => {
+          return aggregation.concat(responses.responses);
+        }, []);
+
+        await respond(aggregatedResponses);
       } catch(error) {
         if (error === ABORTED) {
           return await respond();
@@ -153,32 +168,5 @@ export function CallClientProvider(Private, Promise, es) {
       });
   }
 
-  function getAllFetchParams(requests) {
-    return Promise.map(requests, (request) => {
-      return Promise.try(request.getFetchParams, void 0, request)
-        .then((fetchParams) => {
-          return (request.fetchParams = fetchParams);
-        })
-        .then(value => ({ resolved: value }))
-        .catch(error => ({ rejected: error }));
-    });
-  }
-
-  function serializeAllFetchParams(fetchParams, requestsToFetch) {
-    const requestsWithFetchParams = [];
-
-    // Gather the fetch param responses from all the successful requests.
-    fetchParams.forEach((result, index) => {
-      if (result.resolved) {
-        requestsWithFetchParams.push(result.resolved);
-      } else {
-        const request = requestsToFetch[index];
-        request.handleFailure(result.rejected);
-        requestsToFetch[index] = undefined;
-      }
-    });
-    return serializeFetchParams(requestsWithFetchParams);
-  }
-
   return callClient;
 }

src/ui/public/courier/search_strategy/default_search_strategy.js

@@ -0,0 +1,71 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { addSearchStrategy } from './search_strategy_registry';
+
+function getAllFetchParams(searchRequests, Promise) {
+  return Promise.map(searchRequests, (searchRequest) => {
+    return Promise.try(searchRequest.getFetchParams, void 0, searchRequest)
+      .then((fetchParams) => {
+        return (searchRequest.fetchParams = fetchParams);
+      })
+      .then(value => ({ resolved: value }))
+      .catch(error => ({ rejected: error }));
+  });
+}
+
+function serializeAllFetchParams(fetchParams, searchRequests, serializeFetchParams) {
+  const requestsWithFetchParams = [];
+
+  // Gather the fetch param responses from all the successful requests.
+  fetchParams.forEach((result, index) => {
+    if (result.resolved) {
+      requestsWithFetchParams.push(result.resolved);
+    } else {
+      const request = searchRequests[index];
+      request.handleFailure(result.rejected);
+      searchRequests[index] = undefined;
+    }
+  });
+
+  return serializeFetchParams(requestsWithFetchParams);
+}
+
+export const defaultSearchStrategy = {
+  id: 'default',
+
+  search: async ({ searchRequests, es, Promise, serializeFetchParams }) => {
+    // Flatten the searchSource within each searchRequest to get the fetch params,
+    // e.g. body, filters, index pattern, query.
+    const allFetchParams = await getAllFetchParams(searchRequests, Promise);
+
+    // Serialize the fetch params into a format suitable for the body of an ES query.
+    const serializedFetchParams = await serializeAllFetchParams(allFetchParams, searchRequests, serializeFetchParams);
+
+    return es.msearch({ body: serializedFetchParams });
+  },
+
+  isValidForSearchRequest: searchRequest => {
+    // Basic index patterns don't have `type` defined.
+    const indexPattern = searchRequest.source.getField('index');
+    return indexPattern.type == null;
+  },
+};
+
+addSearchStrategy(defaultSearchStrategy);

src/ui/public/courier/search_strategy/index.js

@@ -0,0 +1,23 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export {
+  assignSearchRequestsToSearchStrategies,
+  addSearchStrategy,
+} from './search_strategy_registry';

src/ui/public/courier/search_strategy/search_strategy_registry.js

@@ -0,0 +1,69 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const searchStrategies = [];
+
+const addSearchStrategy = searchStrategy => {
+  searchStrategies.push(searchStrategy);
+};
+
+/**
+ * Build a structure like this:
+ *
+ *   [{
+ *     searchStrategy: <rollupSearchStrategy>,
+ *     searchRequests: []<SearchRequest>,
+ *   }, {
+ *     searchStrategy: <defaultSearchStrategy>,
+ *     searchRequests: []<SearchRequest>,
+ *   }]
+ *
+ * We use an array of objects to preserve the order of the search requests, which we use to
+ * deterministically associate each response with the originating request.
+ */
+const assignSearchRequestsToSearchStrategies = searchRequests => {
+  const searchStrategiesWithRequests = [];
+  const searchStrategyById = {};
+
+  searchRequests.forEach(searchRequest => {
+    const matchingSearchStrategy = searchStrategies.find(searchStrategy => searchStrategy.isValidForSearchRequest(searchRequest));
+    const { id } = matchingSearchStrategy;
+    let searchStrategyWithRequest = searchStrategyById[id];
+
+    // Create the data structure if we don't already have it.
+    if (!searchStrategyWithRequest) {
+      searchStrategyWithRequest = {
+        searchStrategy: matchingSearchStrategy,
+        searchRequests: [],
+      };
+
+      searchStrategyById[id] = searchStrategyWithRequest;
+      searchStrategiesWithRequests.push(searchStrategyWithRequest);
+    }
+
+    searchStrategyWithRequest.searchRequests.push(searchRequest);
+  });
+
+  return searchStrategiesWithRequests;
+};
+
+export {
+  assignSearchRequestsToSearchStrategies,
+  addSearchStrategy,
+};