From 05bbe62abb84e3ce1b68bf36b4a00be062a3508b Mon Sep 17 00:00:00 2001 From: CJ Cenizal Date: Tue, 17 Jul 2018 20:12:13 -0700 Subject: [PATCH] Add SearchStrategyRegistry and defaultSearchStrategy to support existing search behavior, and integrate it with CallClient. (#20497) (#20912) * Add SearchStrategyRegistry and defaultSearchStrategy to support existing search behavior, and integrate it with CallClient. * Move fetch param logic from CallClient into defaultSearchStrategy. * Move defaultSearchStrategy configuration into kibana plugin via search uiExport to avoid race conditions with other plugins. * Add call-out react directive. * Show error in Discover if user tries to access a rollup index pattern without the right search strategy. Sentence-case copy in field chooser. * Add tests with multiple searchStrategies and fix errors in logic. --- .../field_chooser/field_chooser.html | 14 +- .../public/discover/controllers/discover.js | 16 +- .../public/discover/directives/index.js | 9 + .../directives/unsupported_index_pattern.js | 50 +++++ .../kibana/public/discover/index.html | 5 + src/core_plugins/kibana/public/kibana.js | 1 + src/ui/public/courier/courier.js | 4 +- .../courier/fetch/__tests__/call_client.js | 99 ++++++++- src/ui/public/courier/fetch/call_client.js | 209 +++++++++--------- src/ui/public/courier/index.js | 7 + .../default_search_strategy.js | 91 ++++++++ .../public/courier/search_strategy/index.js | 26 +++ .../is_default_type_index_pattern.js | 23 ++ .../search_strategy_registry.js | 87 ++++++++ .../search_strategy_registry.test.js | 79 +++++++ src/ui/public/react_components.js | 3 + src/ui/ui_exports/ui_export_defaults.js | 5 +- src/ui/ui_exports/ui_export_types/index.js | 3 +- .../ui_export_types/ui_app_extensions.js | 1 + .../dashboard_mode/public/dashboard_viewer.js | 1 + 20 files changed, 618 insertions(+), 115 deletions(-) create mode 100644 src/core_plugins/kibana/public/discover/directives/unsupported_index_pattern.js create mode 100644 src/ui/public/courier/search_strategy/default_search_strategy.js create mode 100644 src/ui/public/courier/search_strategy/index.js create mode 100644 src/ui/public/courier/search_strategy/is_default_type_index_pattern.js create mode 100644 src/ui/public/courier/search_strategy/search_strategy_registry.js create mode 100644 src/ui/public/courier/search_strategy/search_strategy_registry.test.js diff --git a/src/core_plugins/kibana/public/discover/components/field_chooser/field_chooser.html b/src/core_plugins/kibana/public/discover/components/field_chooser/field_chooser.html index 010cad19d1a96..3820555d7b700 100644 --- a/src/core_plugins/kibana/public/discover/components/field_chooser/field_chooser.html +++ b/src/core_plugins/kibana/public/discover/components/field_chooser/field_chooser.html @@ -31,8 +31,10 @@ -
- +
+
-
+
@@ -128,7 +130,7 @@
diff --git a/src/core_plugins/kibana/public/discover/controllers/discover.js b/src/core_plugins/kibana/public/discover/controllers/discover.js index fe85c8ade65c9..068ed4e4ce8fb 100644 --- a/src/core_plugins/kibana/public/discover/controllers/discover.js +++ b/src/core_plugins/kibana/public/discover/controllers/discover.js @@ -28,12 +28,12 @@ import 'ui/visualize'; import 'ui/fixed_scroll'; import 'ui/directives/validate_json'; import 'ui/filters/moment'; -import 'ui/courier'; import 'ui/index_patterns'; import 'ui/state_management/app_state'; import { timefilter } from 'ui/timefilter'; import 'ui/share'; import 'ui/query_bar'; +import { hasSearchStategyForIndexPattern, isDefaultTypeIndexPattern } from 'ui/courier'; import { toastNotifications, getPainlessError } from 'ui/notify'; import { VisProvider } from 'ui/vis'; import { BasicResponseHandlerProvider } from 'ui/vis/response_handlers/basic'; @@ -195,6 +195,7 @@ function discoverController( // the actual courier.SearchSource $scope.searchSource = savedSearch.searchSource; $scope.indexPattern = resolveIndexPatternLoading(); + $scope.searchSource .setField('index', $scope.indexPattern) .setField('highlightAll', true) @@ -237,7 +238,6 @@ function discoverController( }); }; - const getSharingDataFields = async () => { const selectedFields = $state.columns; if (selectedFields.length === 1 && selectedFields[0] === '_source') { @@ -777,5 +777,17 @@ function discoverController( return loadedIndexPattern; } + // Block the UI from loading if the user has loaded a rollup index pattern but it isn't + // supported. + $scope.isUnsupportedIndexPattern = ( + !isDefaultTypeIndexPattern($route.current.locals.ip.loaded) + && !hasSearchStategyForIndexPattern($route.current.locals.ip.loaded) + ); + + if ($scope.isUnsupportedIndexPattern) { + $scope.unsupportedIndexPatternType = $route.current.locals.ip.loaded.type; + return; + } + init(); } diff --git a/src/core_plugins/kibana/public/discover/directives/index.js b/src/core_plugins/kibana/public/discover/directives/index.js index 6f1447fa672d3..a6fc851329340 100644 --- a/src/core_plugins/kibana/public/discover/directives/index.js +++ b/src/core_plugins/kibana/public/discover/directives/index.js @@ -25,8 +25,17 @@ import { DiscoverNoResults, } from './no_results'; +import { + DiscoverUnsupportedIndexPattern, +} from './unsupported_index_pattern'; + import './timechart'; const app = uiModules.get('apps/discover', ['react']); app.directive('discoverNoResults', reactDirective => reactDirective(DiscoverNoResults)); + +app.directive( + 'discoverUnsupportedIndexPattern', + reactDirective => reactDirective(DiscoverUnsupportedIndexPattern, ['unsupportedType']) +); diff --git a/src/core_plugins/kibana/public/discover/directives/unsupported_index_pattern.js b/src/core_plugins/kibana/public/discover/directives/unsupported_index_pattern.js new file mode 100644 index 0000000000000..d5e143fc3bcd9 --- /dev/null +++ b/src/core_plugins/kibana/public/discover/directives/unsupported_index_pattern.js @@ -0,0 +1,50 @@ +/* + * 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 React, { Fragment } from 'react'; + +import { + EuiCallOut, + EuiFlexGroup, + EuiFlexItem, + EuiSpacer, +} from '@elastic/eui'; + +export const DiscoverUnsupportedIndexPattern = ({ unsupportedType }) => { + // This message makes the assumption that X-Pack will support this type, as is the case with + // rollup index patterns. + const message = `Index patterns based on ${unsupportedType} indices require the` + + ` ${unsupportedType} plugin from X-Pack, which is not installed or disabled`; + + return ( + + + + + + + + + + ); +}; diff --git a/src/core_plugins/kibana/public/discover/index.html b/src/core_plugins/kibana/public/discover/index.html index a8fde71b987fb..ee88da2c1b3b3 100644 --- a/src/core_plugins/kibana/public/discover/index.html +++ b/src/core_plugins/kibana/public/discover/index.html @@ -60,6 +60,11 @@

+ + { /** * 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(); diff --git a/src/ui/public/courier/fetch/__tests__/call_client.js b/src/ui/public/courier/fetch/__tests__/call_client.js index 7b0439b43f392..565af41f23ebf 100644 --- a/src/ui/public/courier/fetch/__tests__/call_client.js +++ b/src/ui/public/courier/fetch/__tests__/call_client.js @@ -27,6 +27,7 @@ import { CallClientProvider } from '../call_client'; import { RequestStatus } from '../req_status'; import { SearchRequestProvider } from '../request'; import { MergeDuplicatesRequestProvider } from '../merge_duplicate_requests'; +import { addSearchStrategy } from '../../search_strategy'; describe('callClient', () => { NoDigestPromises.activateForSuite(); @@ -42,14 +43,18 @@ describe('callClient', () => { let esPromiseAbortSpy; const createSearchRequest = (id, overrides = {}) => { + const { source: overrideSource, ...rest } = overrides; + const source = { _flatten: () => ({}), requestIsStopped: () => {}, + getField: () => 'indexPattern', + ...overrideSource }; const errorHandler = () => {}; - const searchRequest = new SearchRequest({ source, errorHandler, ...overrides }); + const searchRequest = new SearchRequest({ source, errorHandler, ...rest }); searchRequest.__testId__ = id; return searchRequest; }; @@ -145,8 +150,11 @@ describe('callClient', () => { searchRequest.handleFailure = handleFailureSpy; searchRequests = [ searchRequest ]; - await callClient(searchRequests); - sinon.assert.calledWith(handleFailureSpy, 'fake es error'); + try { + await callClient(searchRequests); + } catch(e) { + sinon.assert.calledWith(handleFailureSpy, 'fake es error'); + } }); }); @@ -227,7 +235,7 @@ describe('callClient', () => { }); }); - it(`aborting all searchRequests calls abort() on the promise returned by es.msearch()`, () => { + it(`aborting all searchRequests calls abort() on the promise returned by searchStrategy.search()`, () => { esRequestDelay = 100; const searchRequest1 = createSearchRequest(); @@ -261,4 +269,87 @@ describe('callClient', () => { }); }); }); + + describe('searchRequests with multiple searchStrategies map correctly to their responses', () => { + const search = ({ searchRequests }) => { + return { + searching: Promise.resolve(searchRequests.map(searchRequest => searchRequest.__testId__)), + failedSearchRequests: [], + abort: () => {}, + }; + }; + + const searchStrategyA = { + id: 'a', + isViable: indexPattern => { + return indexPattern.type === 'a'; + }, + search, + }; + + const searchStrategyB = { + id: 'b', + isViable: indexPattern => { + return indexPattern.type === 'b'; + }, + search, + }; + + let searchRequestA; + let searchRequestB; + let searchRequestA2; + + beforeEach(() => { + addSearchStrategy(searchStrategyA); + addSearchStrategy(searchStrategyB); + + searchRequestA = createSearchRequest('a', { + source: { + getField: () => ({ type: 'a' }), + }, + }); + + searchRequestB = createSearchRequest('b', { + source: { + getField: () => ({ type: 'b' }), + }, + }); + + searchRequestA2 = createSearchRequest('a2', { + source: { + getField: () => ({ type: 'a' }), + }, + }); + }); + + it('if the searchRequests are reordered by the searchStrategies', () => { + // Add requests in an order which will be reordered by the strategies. + searchRequests = [ searchRequestA, searchRequestB, searchRequestA2 ]; + const callingClient = callClient(searchRequests); + + return callingClient.then(results => { + expect(results).to.eql(['a', 'b', 'a2']); + }); + }); + + it('if one is aborted after being provided', () => { + // Add requests in an order which will be reordered by the strategies. + searchRequests = [ searchRequestA, searchRequestB, searchRequestA2 ]; + const callingClient = callClient(searchRequests); + searchRequestA2.abort(); + + return callingClient.then(results => { + expect(results).to.eql(['a', 'b', ABORTED]); + }); + }); + + it(`if one is already aborted when it's provided`, () => { + searchRequests = [ searchRequestA, searchRequestB, ABORTED, searchRequestA2 ]; + const callingClient = callClient(searchRequests); + + return callingClient.then(results => { + expect(results).to.eql(['a', 'b', ABORTED, 'a2']); + }); + }); + }); }); diff --git a/src/ui/public/courier/fetch/call_client.js b/src/ui/public/courier/fetch/call_client.js index fbbd8d8572100..fd8266eb6e122 100644 --- a/src/ui/public/courier/fetch/call_client.js +++ b/src/ui/public/courier/fetch/call_client.js @@ -17,9 +17,8 @@ * under the License. */ -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'; @@ -34,43 +33,56 @@ export function CallClientProvider(Private, Promise, es) { const ABORTED = RequestStatus.ABORTED; const DUPLICATE = RequestStatus.DUPLICATE; - function callClient(requests) { + function callClient(searchRequests) { // merging docs can change status to DUPLICATE, capture new statuses - const statuses = mergeDuplicateRequests(requests); + const searchRequestsAndStatuses = mergeDuplicateRequests(searchRequests); // get the actual list of requests that we will be fetching - let requestsToFetch = statuses.filter(isRequest); - let execCount = requestsToFetch.length; + const requestsToFetch = searchRequestsAndStatuses.filter(isRequest); + let requestsToFetchCount = requestsToFetch.length; - if (!execCount) return Promise.resolve([]); + if (requestsToFetchCount === 0) { + return Promise.resolve([]); + } - // resolved by respond() - let esPromise = undefined; - let isRequestAborted = false; + // This is how we'll provide the consumer with search responses. Resolved by + // respondToSearchRequests. const defer = Promise.defer(); - // for each respond with either the response or ABORTED - const respond = function (responses) { - responses = responses || []; - return Promise.map(requests, function (request, i) { - switch (statuses[i]) { - case ABORTED: - return ABORTED; - case DUPLICATE: - return request._uniq.resp; - default: - if (request.aborted) { - return ABORTED; - } - - const index = _.findIndex(requestsToFetch, request); - if (index < 0) { - // This means the request failed. - return ABORTED; - } - - return responses[index]; + const abortableSearches = []; + let areAllSearchRequestsAborted = false; + + // When we traverse our search requests and send out searches, some of them may fail. We'll + // store those that don't fail here. + const activeSearchRequests = []; + + // Respond to each searchRequest with the response or ABORTED. + const respondToSearchRequests = (responsesInOriginalRequestOrder = []) => { + // We map over searchRequestsAndStatuses because if we were originally provided an ABORTED + // request then we'll return that value. + return Promise.map(searchRequestsAndStatuses, function (searchRequest, searchRequestIndex) { + if (searchRequest.aborted) { + return ABORTED; + } + + const status = searchRequestsAndStatuses[searchRequestIndex]; + + if (status === ABORTED) { + return ABORTED; + } + + if (status === DUPLICATE) { + return searchRequest._uniq.resp; + } + + const activeSearchRequestIndex = activeSearchRequests.indexOf(searchRequest); + const isFailedSearchRequest = activeSearchRequestIndex === -1; + + if (isFailedSearchRequest) { + return ABORTED; } + + return responsesInOriginalRequestOrder[searchRequestIndex]; }) .then( (res) => defer.resolve(res), @@ -79,65 +91,90 @@ export function CallClientProvider(Private, Promise, es) { }; // handle a request being aborted while being fetched - const requestWasAborted = Promise.method(function (req, i) { - if (statuses[i] === ABORTED) { + const requestWasAborted = Promise.method(function (searchRequest, index) { + if (searchRequestsAndStatuses[index] === ABORTED) { defer.reject(new Error('Request was aborted twice?')); } - execCount -= 1; - if (execCount > 0) { - // the multi-request still contains other requests + requestsToFetchCount--; + + if (requestsToFetchCount !== 0) { + // We can't resolve early unless all searchRequests have been aborted. return; } - if (esPromise && _.isFunction(esPromise.abort)) { - esPromise.abort(); - } + abortableSearches.forEach(({ abort }) => { + abort(); + }); - esPromise = undefined; - isRequestAborted = true; + areAllSearchRequestsAborted = true; - return respond(); + return respondToSearchRequests(); }); // attach abort handlers, close over request index - statuses.forEach(function (req, i) { - if (!isRequest(req)) return; - req.whenAborted(function () { - requestWasAborted(req, i).catch(defer.reject); + searchRequestsAndStatuses.forEach(function (searchRequest, index) { + if (!isRequest(searchRequest)) { + return; + } + + searchRequest.whenAborted(function () { + requestWasAborted(searchRequest, index).catch(defer.reject); }); }); + const searchStrategiesWithRequests = assignSearchRequestsToSearchStrategies(requestsToFetch); + // 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); + // Execute each request using its search strategy. + for (let i = 0; i < searchStrategiesWithRequests.length; i++) { + const searchStrategyWithSearchRequests = searchStrategiesWithRequests[i]; + const { searchStrategy, searchRequests } = searchStrategyWithSearchRequests; + const { + searching, + abort, + failedSearchRequests, + } = await searchStrategy.search({ searchRequests, es, Promise, serializeFetchParams }); + + // Collect searchRequests which have successfully been sent. + searchRequests.forEach(searchRequest => { + if (failedSearchRequests.includes(searchRequest)) { + return; + } - // Serialize the fetch params into a format suitable for the body of an ES query. - const serializedFetchParams = await serializeAllFetchParams(allFetchParams, requestsToFetch); + activeSearchRequests.push(searchRequest); + }); - // 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); + abortableSearches.push({ + searching, + abort, + }); + } try { // The request was aborted while we were doing the above logic. - if (isRequestAborted) { - throw ABORTED; + if (areAllSearchRequestsAborted) { + return; } - esPromise = es.msearch({ body: serializedFetchParams }); - const clientResponse = await esPromise; - await respond(clientResponse.responses); - } catch(error) { - if (error === ABORTED) { - return await respond(); - } + const segregatedResponses = await Promise.all(abortableSearches.map(({ searching }) => searching)); + + // Assigning searchRequests to strategies means that the responses come back in a different + // order than the original searchRequests. So we'll put them back in order so that we can + // use the order to associate each response with the original request. + const responsesInOriginalRequestOrder = new Array(searchRequestsAndStatuses.length); + segregatedResponses.forEach((responses, strategyIndex) => { + responses.forEach((response, responseIndex) => { + const searchRequest = searchStrategiesWithRequests[strategyIndex].searchRequests[responseIndex]; + const requestIndex = searchRequestsAndStatuses.indexOf(searchRequest); + responsesInOriginalRequestOrder[requestIndex] = response; + }); + }); + await respondToSearchRequests(responsesInOriginalRequestOrder); + } catch(error) { if (errorAllowExplicitIndex.test(error)) { return errorAllowExplicitIndex.takeover(); } @@ -146,43 +183,17 @@ export function CallClientProvider(Private, Promise, es) { } }); - // return our promise, but catch any errors we create and - // send them to the requests - return defer.promise - .catch((err) => { - requests.forEach((req, index) => { - if (statuses[index] !== ABORTED) { - req.handleFailure(err); - } - }); + // If there are any errors, notify the searchRequests of them. + defer.promise.catch((err) => { + searchRequests.forEach((searchRequest, index) => { + if (searchRequestsAndStatuses[index] !== ABORTED) { + searchRequest.handleFailure(err); + } }); - } - - 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 the promise which acts as our vehicle for providing search responses to the consumer. + return defer.promise; } return callClient; diff --git a/src/ui/public/courier/index.js b/src/ui/public/courier/index.js index e984dfbde9fc4..d466b2e080e3f 100644 --- a/src/ui/public/courier/index.js +++ b/src/ui/public/courier/index.js @@ -18,7 +18,9 @@ */ import './courier'; + export { SavedObjectProvider } from './saved_object'; + export { SearchSourceProvider, migrateFilter, @@ -26,3 +28,8 @@ export { buildQueryFromFilters, luceneStringToDsl, } from './search_source'; + +export { + hasSearchStategyForIndexPattern, + isDefaultTypeIndexPattern, +} from './search_strategy'; diff --git a/src/ui/public/courier/search_strategy/default_search_strategy.js b/src/ui/public/courier/search_strategy/default_search_strategy.js new file mode 100644 index 0000000000000..05fc45c5c67d1 --- /dev/null +++ b/src/ui/public/courier/search_strategy/default_search_strategy.js @@ -0,0 +1,91 @@ +/* + * 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'; +import { isDefaultTypeIndexPattern } from './is_default_type_index_pattern'; + +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 })); + }); +} + +async function serializeAllFetchParams(fetchParams, searchRequests, serializeFetchParams) { + const searcRequestsWithFetchParams = []; + const failedSearchRequests = []; + + // Gather the fetch param responses from all the successful requests. + fetchParams.forEach((result, index) => { + if (result.resolved) { + searcRequestsWithFetchParams.push(result.resolved); + } else { + const searchRequest = searchRequests[index]; + + // TODO: All strategies will need to implement this. + searchRequest.handleFailure(result.rejected); + failedSearchRequests.push(searchRequest); + } + }); + + return { + serializedFetchParams: await serializeFetchParams(searcRequestsWithFetchParams), + failedSearchRequests, + }; +} + +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, + failedSearchRequests, + } = await serializeAllFetchParams(allFetchParams, searchRequests, serializeFetchParams); + + const searching = es.msearch({ body: serializedFetchParams }); + + return { + // Unwrap the responses object returned by the es client. + searching: searching.then(({ responses }) => responses), + abort: searching.abort, + failedSearchRequests, + }; + }, + + // Accept multiple criteria for determining viability to be as flexible as possible. + isViable: (indexPattern) => { + if (!indexPattern) { + return false; + } + + return isDefaultTypeIndexPattern(indexPattern); + }, +}; + +addSearchStrategy(defaultSearchStrategy); diff --git a/src/ui/public/courier/search_strategy/index.js b/src/ui/public/courier/search_strategy/index.js new file mode 100644 index 0000000000000..41991b63f950d --- /dev/null +++ b/src/ui/public/courier/search_strategy/index.js @@ -0,0 +1,26 @@ +/* + * 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, + hasSearchStategyForIndexPattern, +} from './search_strategy_registry'; + +export { isDefaultTypeIndexPattern } from './is_default_type_index_pattern'; diff --git a/src/ui/public/courier/search_strategy/is_default_type_index_pattern.js b/src/ui/public/courier/search_strategy/is_default_type_index_pattern.js new file mode 100644 index 0000000000000..ec2a54239a880 --- /dev/null +++ b/src/ui/public/courier/search_strategy/is_default_type_index_pattern.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 const isDefaultTypeIndexPattern = indexPattern => { + // Default index patterns don't have `type` defined. + return indexPattern.type == null; +}; diff --git a/src/ui/public/courier/search_strategy/search_strategy_registry.js b/src/ui/public/courier/search_strategy/search_strategy_registry.js new file mode 100644 index 0000000000000..a0341932565da --- /dev/null +++ b/src/ui/public/courier/search_strategy/search_strategy_registry.js @@ -0,0 +1,87 @@ +/* + * 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 => { + if (searchStrategies.includes(searchStrategy)) { + return; + } + + searchStrategies.push(searchStrategy); +}; + +const getSearchStrategy = indexPattern => { + return searchStrategies.find(searchStrategy => { + return searchStrategy.isViable(indexPattern); + }); +}; + +/** + * Build a structure like this: + * + * [{ + * searchStrategy: rollupSearchStrategy, + * searchRequests: [], + * }, { + * searchStrategy: defaultSearchStrategy, + * searchRequests: [], + * }] + * + * 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 indexPattern = searchRequest.source.getField('index'); + const matchingSearchStrategy = getSearchStrategy(indexPattern); + + 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; +}; + +const hasSearchStategyForIndexPattern = indexPattern => { + return Boolean(getSearchStrategy(indexPattern)); +}; + +export { + assignSearchRequestsToSearchStrategies, + addSearchStrategy, + hasSearchStategyForIndexPattern, +}; diff --git a/src/ui/public/courier/search_strategy/search_strategy_registry.test.js b/src/ui/public/courier/search_strategy/search_strategy_registry.test.js new file mode 100644 index 0000000000000..69eca6c271b43 --- /dev/null +++ b/src/ui/public/courier/search_strategy/search_strategy_registry.test.js @@ -0,0 +1,79 @@ +/* + * 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 { + assignSearchRequestsToSearchStrategies, + addSearchStrategy, +} from './search_strategy_registry'; + +describe('SearchStrategyRegistry', () => { + describe('assignSearchRequestsToSearchStrategies', () => { + test('associates search requests with valid search strategies', () => { + const searchStrategyA = { + id: 'a', + isViable: indexPattern => { + return indexPattern === 'a'; + }, + }; + + addSearchStrategy(searchStrategyA); + + const searchStrategyB = { + id: 'b', + isViable: indexPattern => { + return indexPattern === 'b'; + }, + }; + + addSearchStrategy(searchStrategyB); + + const searchRequest0 = { + id: 0, + source: { getField: () => 'b' }, + }; + + const searchRequest1 = { + id: 1, + source: { getField: () => 'a' }, + }; + + const searchRequest2 = { + id: 2, + source: { getField: () => 'a' }, + }; + + const searchRequest3 = { + id: 3, + source: { getField: () => 'b' }, + }; + + const searchRequests = [ searchRequest0, searchRequest1, searchRequest2, searchRequest3]; + + const searchStrategiesWithSearchRequests = assignSearchRequestsToSearchStrategies(searchRequests); + + expect(searchStrategiesWithSearchRequests).toEqual([{ + searchStrategy: searchStrategyB, + searchRequests: [ searchRequest0, searchRequest3 ], + }, { + searchStrategy: searchStrategyA, + searchRequests: [ searchRequest1, searchRequest2 ], + }]); + }); + }); +}); diff --git a/src/ui/public/react_components.js b/src/ui/public/react_components.js index 9bbfb2c366a2c..521ecd52920e7 100644 --- a/src/ui/public/react_components.js +++ b/src/ui/public/react_components.js @@ -28,6 +28,7 @@ import { EuiIcon, EuiColorPicker, EuiIconTip, + EuiCallOut, } from '@elastic/eui'; import { uiModules } from './modules'; @@ -43,3 +44,5 @@ app.directive('icon', reactDirective => reactDirective(EuiIcon)); app.directive('colorPicker', reactDirective => reactDirective(EuiColorPicker)); app.directive('iconTip', reactDirective => reactDirective(EuiIconTip, ['content', 'type', 'position', 'title'])); + +app.directive('callOut', reactDirective => reactDirective(EuiCallOut, ['title', 'color', 'size', 'iconType', 'children'])); diff --git a/src/ui/ui_exports/ui_export_defaults.js b/src/ui/ui_exports/ui_export_defaults.js index d33a6661d8b5c..9b505c49dbc4b 100644 --- a/src/ui/ui_exports/ui_export_defaults.js +++ b/src/ui/ui_exports/ui_export_defaults.js @@ -58,6 +58,9 @@ export const UI_EXPORT_DEFAULTS = { embeddableFactories: [ 'plugins/kibana/visualize/embeddable/visualize_embeddable_factory_provider', 'plugins/kibana/discover/embeddable/search_embeddable_factory_provider', - ] + ], + search: [ + 'ui/courier/search_strategy/default_search_strategy', + ], }, }; diff --git a/src/ui/ui_exports/ui_export_types/index.js b/src/ui/ui_exports/ui_export_types/index.js index b584cdbc27ec2..08d03bc04b14b 100644 --- a/src/ui/ui_exports/ui_export_types/index.js +++ b/src/ui/ui_exports/ui_export_types/index.js @@ -51,7 +51,8 @@ export { home, visTypeEnhancers, aliases, - visualize + visualize, + search, } from './ui_app_extensions'; export { diff --git a/src/ui/ui_exports/ui_export_types/ui_app_extensions.js b/src/ui/ui_exports/ui_export_types/ui_app_extensions.js index a01e7059d7945..738b794cb3107 100644 --- a/src/ui/ui_exports/ui_export_types/ui_app_extensions.js +++ b/src/ui/ui_exports/ui_export_types/ui_app_extensions.js @@ -50,6 +50,7 @@ export const docViews = appExtension; export const hacks = appExtension; export const home = appExtension; export const inspectorViews = appExtension; +export const search = appExtension; // Add a visualize app extension that should be used for visualize specific stuff export const visualize = appExtension; diff --git a/x-pack/plugins/dashboard_mode/public/dashboard_viewer.js b/x-pack/plugins/dashboard_mode/public/dashboard_viewer.js index dcd8eb41e52ef..3da539144771e 100644 --- a/x-pack/plugins/dashboard_mode/public/dashboard_viewer.js +++ b/x-pack/plugins/dashboard_mode/public/dashboard_viewer.js @@ -24,6 +24,7 @@ import 'uiExports/embeddableFactories'; import 'uiExports/navbarExtensions'; import 'uiExports/docViews'; import 'uiExports/fieldFormats'; +import 'uiExports/search'; import _ from 'lodash'; import 'ui/autoload/all';