From 6376379db96f320a7f9a228252f3a4462abeeb0e Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Sat, 23 Dec 2023 08:49:07 +0000 Subject: [PATCH 01/59] support dynamic csp rules to mitigate clickjacking Signed-off-by: Tianle Huang --- src/core/server/csp/config.ts | 1 + .../csp_configuration_provider/.eslintrc.js | 7 ++ .../csp_configuration_provider/.i18nrc.json | 7 ++ .../csp_configuration_provider/README.md | 11 ++ .../common/index.ts | 2 + .../opensearch_dashboards.json | 9 ++ .../server/index.ts | 11 ++ .../server/plugin.ts | 100 ++++++++++++++++++ .../server/provider.ts | 39 +++++++ .../server/routes/index.ts | 17 +++ .../server/types.ts | 10 ++ 11 files changed, 214 insertions(+) create mode 100644 src/plugins/csp_configuration_provider/.eslintrc.js create mode 100644 src/plugins/csp_configuration_provider/.i18nrc.json create mode 100755 src/plugins/csp_configuration_provider/README.md create mode 100644 src/plugins/csp_configuration_provider/common/index.ts create mode 100644 src/plugins/csp_configuration_provider/opensearch_dashboards.json create mode 100644 src/plugins/csp_configuration_provider/server/index.ts create mode 100644 src/plugins/csp_configuration_provider/server/plugin.ts create mode 100644 src/plugins/csp_configuration_provider/server/provider.ts create mode 100644 src/plugins/csp_configuration_provider/server/routes/index.ts create mode 100644 src/plugins/csp_configuration_provider/server/types.ts diff --git a/src/core/server/csp/config.ts b/src/core/server/csp/config.ts index 3cb120b47730..6e0d2e8aac91 100644 --- a/src/core/server/csp/config.ts +++ b/src/core/server/csp/config.ts @@ -45,6 +45,7 @@ export const config = { `script-src 'unsafe-eval' 'self'`, `worker-src blob: 'self'`, `style-src 'unsafe-inline' 'self'`, + `frame-ancestors 'self'`, ], }), strict: schema.boolean({ defaultValue: false }), diff --git a/src/plugins/csp_configuration_provider/.eslintrc.js b/src/plugins/csp_configuration_provider/.eslintrc.js new file mode 100644 index 000000000000..b16a8b23a08e --- /dev/null +++ b/src/plugins/csp_configuration_provider/.eslintrc.js @@ -0,0 +1,7 @@ +module.exports = { + root: true, + extends: ['@elastic/eslint-config-kibana', 'plugin:@elastic/eui/recommended'], + rules: { + '@osd/eslint/require-license-header': 'off', + }, +}; diff --git a/src/plugins/csp_configuration_provider/.i18nrc.json b/src/plugins/csp_configuration_provider/.i18nrc.json new file mode 100644 index 000000000000..5c8575b9d4fe --- /dev/null +++ b/src/plugins/csp_configuration_provider/.i18nrc.json @@ -0,0 +1,7 @@ +{ + "prefix": "cspConfigurationProvider", + "paths": { + "cspConfigurationProvider": "." + }, + "translations": ["translations/ja-JP.json"] +} diff --git a/src/plugins/csp_configuration_provider/README.md b/src/plugins/csp_configuration_provider/README.md new file mode 100755 index 000000000000..3850ae79b05e --- /dev/null +++ b/src/plugins/csp_configuration_provider/README.md @@ -0,0 +1,11 @@ +# CspConfigurationProvider + +A OpenSearch Dashboards plugin + +--- + +## Development + +See the [OpenSearch Dashboards contributing +guide](https://github.com/opensearch-project/OpenSearch-Dashboards/blob/main/CONTRIBUTING.md) for instructions +setting up your development environment. diff --git a/src/plugins/csp_configuration_provider/common/index.ts b/src/plugins/csp_configuration_provider/common/index.ts new file mode 100644 index 000000000000..a4db30412db3 --- /dev/null +++ b/src/plugins/csp_configuration_provider/common/index.ts @@ -0,0 +1,2 @@ +export const PLUGIN_ID = 'cspConfigurationProvider'; +export const PLUGIN_NAME = 'CspConfigurationProvider'; diff --git a/src/plugins/csp_configuration_provider/opensearch_dashboards.json b/src/plugins/csp_configuration_provider/opensearch_dashboards.json new file mode 100644 index 000000000000..52cbfdcf0bd3 --- /dev/null +++ b/src/plugins/csp_configuration_provider/opensearch_dashboards.json @@ -0,0 +1,9 @@ +{ + "id": "cspConfigurationProvider", + "version": "1.0.0", + "opensearchDashboardsVersion": "opensearchDashboards", + "server": true, + "ui": false, + "requiredPlugins": ["navigation"], + "optionalPlugins": [] +} diff --git a/src/plugins/csp_configuration_provider/server/index.ts b/src/plugins/csp_configuration_provider/server/index.ts new file mode 100644 index 000000000000..a7254794135f --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/index.ts @@ -0,0 +1,11 @@ +import { PluginInitializerContext } from '../../../core/server'; +import { CspConfigurationProviderPlugin } from './plugin'; + +// This exports static code and TypeScript types, +// as well as, OpenSearch Dashboards Platform `plugin()` initializer. + +export function plugin(initializerContext: PluginInitializerContext) { + return new CspConfigurationProviderPlugin(initializerContext); +} + +export { CspConfigurationProviderPluginSetup, CspConfigurationProviderPluginStart } from './types'; diff --git a/src/plugins/csp_configuration_provider/server/plugin.ts b/src/plugins/csp_configuration_provider/server/plugin.ts new file mode 100644 index 000000000000..5ddf879c36ae --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/plugin.ts @@ -0,0 +1,100 @@ +import { + PluginInitializerContext, + CoreSetup, + CoreStart, + Plugin, + Logger, + OnPreResponseHandler, + OpenSearchClient, +} from '../../../core/server'; + +import { + CspClient, + CspConfigurationProviderPluginSetup, + CspConfigurationProviderPluginStart, +} from './types'; +import { defineRoutes } from './routes'; +import { OpenSearchCspClient } from './provider'; + +const OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME = '.opensearch_dashboards_config'; +const OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME = 'csp.rules'; + +export class CspConfigurationProviderPlugin + implements Plugin { + private readonly logger: Logger; + private cspClient: CspClient | undefined; + + constructor(initializerContext: PluginInitializerContext) { + this.logger = initializerContext.logger.get(); + } + + private setCspClient(inputCspClient: CspClient) { + this.cspClient = inputCspClient; + } + + private getCspClient(inputOpenSearchClient: OpenSearchClient) { + if (this.cspClient) { + return this.cspClient; + } + + return new OpenSearchCspClient(inputOpenSearchClient); + } + + public setup(core: CoreSetup) { + this.logger.debug('CspConfigurationProvider: Setup'); + const router = core.http.createRouter(); + + // Register server side APIs + defineRoutes(router); + + core.http.registerOnPreResponse(this.createCspRulesPreResponseHandler(core)); + + return { + setCspClient: this.setCspClient.bind(this), + }; + } + + public start(core: CoreStart) { + this.logger.debug('CspConfigurationProvider: Started'); + return {}; + } + + public stop() {} + + private createCspRulesPreResponseHandler(core: CoreSetup): OnPreResponseHandler { + return async (request, response, toolkit) => { + const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; + + const currentDest = request.headers['sec-fetch-dest']; + + if (!shouldCheckDest.includes(currentDest)) { + return toolkit.next({}); + } + + const [coreStart] = await core.getStartServices(); + + const myClient = this.getCspClient(coreStart.opensearch.client.asInternalUser); + + const existsData = await myClient.exists(OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME); + + let header; + const defaultHeader = core.http.csp.header; + + if (!existsData) { + header = defaultHeader; + } else { + const data = await myClient.get( + OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME, + OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME + ); + header = data || defaultHeader; + } + + const additionalHeaders = { + ['content-security-policy']: header, + }; + + return toolkit.next({ headers: additionalHeaders }); + }; + } +} diff --git a/src/plugins/csp_configuration_provider/server/provider.ts b/src/plugins/csp_configuration_provider/server/provider.ts new file mode 100644 index 000000000000..621565529f4c --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/provider.ts @@ -0,0 +1,39 @@ +import { OpenSearchClient } from '../../../../src/core/server'; + +import { CspClient } from './types'; + +export class OpenSearchCspClient implements CspClient { + client: OpenSearchClient; + + constructor(inputOpenSearchClient: OpenSearchClient) { + this.client = inputOpenSearchClient; + } + + async exists(configurationName: string): Promise { + const exists = await this.client.indices.exists({ + index: configurationName, + }); + + return exists.body; + } + + async get(configurationName: string, cspRulesName: string): Promise { + const query = { + query: { + match: { + _id: { + query: cspRulesName, + }, + }, + }, + }; + + const data = await this.client.search({ + index: configurationName, + _source: true, + body: query, + }); + + return data.body.hits.hits[0]?._source.value; + } +} diff --git a/src/plugins/csp_configuration_provider/server/routes/index.ts b/src/plugins/csp_configuration_provider/server/routes/index.ts new file mode 100644 index 000000000000..604e1aa4bf7a --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/routes/index.ts @@ -0,0 +1,17 @@ +import { IRouter } from '../../../../core/server'; + +export function defineRoutes(router: IRouter) { + router.get( + { + path: '/api/csp_configuration_provider/example', + validate: false, + }, + async (context, request, response) => { + return response.ok({ + body: { + time: new Date().toISOString(), + }, + }); + } + ); +} diff --git a/src/plugins/csp_configuration_provider/server/types.ts b/src/plugins/csp_configuration_provider/server/types.ts new file mode 100644 index 000000000000..97a76780e3dc --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/types.ts @@ -0,0 +1,10 @@ +// eslint-disable-next-line @typescript-eslint/no-empty-interface +export interface CspConfigurationProviderPluginSetup {} +// eslint-disable-next-line @typescript-eslint/no-empty-interface +export interface CspConfigurationProviderPluginStart {} + +export interface CspClient { + exists(configurationName: string): Promise; + + get(configurationName: string, cspRulesName: string): Promise; +} From a6c0f6e4bd109a55679f0c00a81f739169adb4b2 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 27 Dec 2023 01:58:29 +0000 Subject: [PATCH 02/59] add unit tests for the provider class Signed-off-by: Tianle Huang --- .../server/provider.test.ts | 134 ++++++++++++++++++ .../server/provider.ts | 45 ++++-- 2 files changed, 167 insertions(+), 12 deletions(-) create mode 100644 src/plugins/csp_configuration_provider/server/provider.test.ts diff --git a/src/plugins/csp_configuration_provider/server/provider.test.ts b/src/plugins/csp_configuration_provider/server/provider.test.ts new file mode 100644 index 000000000000..ca95443ee5ff --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/provider.test.ts @@ -0,0 +1,134 @@ +import { SearchResponse } from '@opensearch-project/opensearch/api/types'; +import { + OpenSearchClientMock, + opensearchClientMock, +} from '../../../core/server/opensearch/client/mocks'; +import { OpenSearchCspClient } from './provider'; + +const INDEX_NAME = 'test_index'; +const INDEX_DOCUMENT_NAME = 'csp_doc'; +const ERROR_MESSAGE = 'Service unavailable'; + +describe('Provider', () => { + let opensearchClient: OpenSearchClientMock; + + beforeEach(() => { + jest.resetAllMocks(); + opensearchClient = opensearchClientMock.createOpenSearchClient(); + }); + + afterEach(() => {}); + + describe('exists', () => { + it('returns true if the target index does exists', async () => { + const indexExists = true; + opensearchClient.indices.exists.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const value = await client.exists(INDEX_NAME); + + expect(value).toBeTruthy(); + expect(opensearchClient.indices.exists).toBeCalledWith({ index: INDEX_NAME }); + }); + + it('returns false if the target index does not exists', async () => { + const indexExists = false; + opensearchClient.indices.exists.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const existsValue = await client.exists(INDEX_NAME); + + expect(existsValue).toBeFalsy(); + expect(opensearchClient.indices.exists).toBeCalledWith({ index: INDEX_NAME }); + }); + + it('returns false if opensearch errors happen', async () => { + opensearchClient.indices.exists.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(new Error(ERROR_MESSAGE)); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const existsValue = await client.exists(INDEX_NAME); + + expect(existsValue).toBeFalsy(); + expect(opensearchClient.indices.exists).toBeCalledWith({ index: INDEX_NAME }); + }); + }); + + describe('get', () => { + it('returns the csp rules from the index', async () => { + const cspRules = "frame-ancestors 'self'"; + + opensearchClient.search.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({ + hits: { + hits: [ + { + _source: { + value: cspRules, + }, + }, + ], + }, + } as SearchResponse); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const getValue = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); + + expect(getValue).toBe(cspRules); + expect(opensearchClient.search).toBeCalledWith( + getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) + ); + }); + + it('returns empty when opensearch response is malformed', async () => { + opensearchClient.search.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({ + hits: {}, + } as SearchResponse); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const getValue = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); + + expect(getValue).toBe(''); + expect(opensearchClient.search).toBeCalledWith( + getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) + ); + }); + + it('returns empty string when opensearch errors happen', async () => { + opensearchClient.search.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(new Error(ERROR_MESSAGE)); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const cspRules = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); + + expect(cspRules).toBe(''); + expect(opensearchClient.search).toBeCalledWith( + getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) + ); + }); + }); +}); + +function getSearchInput(indexName: string, documentName: string) { + return { + index: indexName, + body: { + query: { + match: { + _id: { + query: documentName, + }, + }, + }, + }, + }; +} diff --git a/src/plugins/csp_configuration_provider/server/provider.ts b/src/plugins/csp_configuration_provider/server/provider.ts index 621565529f4c..b0e8e507d90b 100644 --- a/src/plugins/csp_configuration_provider/server/provider.ts +++ b/src/plugins/csp_configuration_provider/server/provider.ts @@ -3,18 +3,29 @@ import { OpenSearchClient } from '../../../../src/core/server'; import { CspClient } from './types'; export class OpenSearchCspClient implements CspClient { - client: OpenSearchClient; + private client: OpenSearchClient; constructor(inputOpenSearchClient: OpenSearchClient) { this.client = inputOpenSearchClient; } async exists(configurationName: string): Promise { - const exists = await this.client.indices.exists({ - index: configurationName, - }); - - return exists.body; + let value = false; + + try { + const exists = await this.client.indices.exists({ + index: configurationName, + }); + + value = exists.body; + } catch (e) { + // eslint-disable-next-line no-console + console.error( + `Failed to call exists with configurationName ${configurationName} due to error ${e}` + ); + } + + return value; } async get(configurationName: string, cspRulesName: string): Promise { @@ -28,12 +39,22 @@ export class OpenSearchCspClient implements CspClient { }, }; - const data = await this.client.search({ - index: configurationName, - _source: true, - body: query, - }); + let value = ''; + + try { + const data = await this.client.search({ + index: configurationName, + body: query, + }); + + value = data?.body?.hits?.hits[0]?._source?.value; + } catch (e) { + // eslint-disable-next-line no-console + console.error( + `Failed to call get with configurationName ${configurationName} and cspRulesName ${cspRulesName} due to error ${e}` + ); + } - return data.body.hits.hits[0]?._source.value; + return value; } } From c4481c1c4dbd527635d823dd02efc6cb86a52702 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 27 Dec 2023 02:55:32 +0000 Subject: [PATCH 03/59] move request handler to its own class Signed-off-by: Tianle Huang --- .../server/csp_handlers.ts | 50 +++++++++++++++++ .../server/plugin.ts | 54 +++---------------- 2 files changed, 58 insertions(+), 46 deletions(-) create mode 100644 src/plugins/csp_configuration_provider/server/csp_handlers.ts diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.ts new file mode 100644 index 000000000000..0625f9d24502 --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/csp_handlers.ts @@ -0,0 +1,50 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { CoreSetup, OnPreResponseHandler, OpenSearchClient } from '../../../core/server'; +import { CspClient } from './types'; + +const OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME = '.opensearch_dashboards_config'; +const OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME = 'csp.rules'; + +export function createCspRulesPreResponseHandler( + core: CoreSetup, + getCspClient: (inputOpenSearchClient: OpenSearchClient) => CspClient +): OnPreResponseHandler { + return async (request, response, toolkit) => { + const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; + + const currentDest = request.headers['sec-fetch-dest']; + + if (!shouldCheckDest.includes(currentDest)) { + return toolkit.next({}); + } + + const [coreStart] = await core.getStartServices(); + + const myClient = getCspClient(coreStart.opensearch.client.asInternalUser); + + const existsData = await myClient.exists(OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME); + + let header; + const defaultHeader = core.http.csp.header; + + if (!existsData) { + header = defaultHeader; + } else { + const data = await myClient.get( + OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME, + OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME + ); + header = data || defaultHeader; + } + + const additionalHeaders = { + ['content-security-policy']: header, + }; + + return toolkit.next({ headers: additionalHeaders }); + }; +} diff --git a/src/plugins/csp_configuration_provider/server/plugin.ts b/src/plugins/csp_configuration_provider/server/plugin.ts index 5ddf879c36ae..f20352e042b7 100644 --- a/src/plugins/csp_configuration_provider/server/plugin.ts +++ b/src/plugins/csp_configuration_provider/server/plugin.ts @@ -1,23 +1,20 @@ import { - PluginInitializerContext, CoreSetup, CoreStart, - Plugin, Logger, - OnPreResponseHandler, OpenSearchClient, + Plugin, + PluginInitializerContext, } from '../../../core/server'; +import { createCspRulesPreResponseHandler } from './csp_handlers'; +import { OpenSearchCspClient } from './provider'; +import { defineRoutes } from './routes'; import { CspClient, CspConfigurationProviderPluginSetup, CspConfigurationProviderPluginStart, } from './types'; -import { defineRoutes } from './routes'; -import { OpenSearchCspClient } from './provider'; - -const OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME = '.opensearch_dashboards_config'; -const OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME = 'csp.rules'; export class CspConfigurationProviderPlugin implements Plugin { @@ -47,7 +44,9 @@ export class CspConfigurationProviderPlugin // Register server side APIs defineRoutes(router); - core.http.registerOnPreResponse(this.createCspRulesPreResponseHandler(core)); + core.http.registerOnPreResponse( + createCspRulesPreResponseHandler(core, this.getCspClient.bind(this)) + ); return { setCspClient: this.setCspClient.bind(this), @@ -60,41 +59,4 @@ export class CspConfigurationProviderPlugin } public stop() {} - - private createCspRulesPreResponseHandler(core: CoreSetup): OnPreResponseHandler { - return async (request, response, toolkit) => { - const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; - - const currentDest = request.headers['sec-fetch-dest']; - - if (!shouldCheckDest.includes(currentDest)) { - return toolkit.next({}); - } - - const [coreStart] = await core.getStartServices(); - - const myClient = this.getCspClient(coreStart.opensearch.client.asInternalUser); - - const existsData = await myClient.exists(OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME); - - let header; - const defaultHeader = core.http.csp.header; - - if (!existsData) { - header = defaultHeader; - } else { - const data = await myClient.get( - OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME, - OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME - ); - header = data || defaultHeader; - } - - const additionalHeaders = { - ['content-security-policy']: header, - }; - - return toolkit.next({ headers: additionalHeaders }); - }; - } } From e97bef88c2f6c11dd78afe485d058a5d552e16fc Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 27 Dec 2023 02:59:59 +0000 Subject: [PATCH 04/59] add license headers Signed-off-by: Tianle Huang --- src/plugins/csp_configuration_provider/common/index.ts | 5 +++++ src/plugins/csp_configuration_provider/server/index.ts | 5 +++++ src/plugins/csp_configuration_provider/server/plugin.ts | 5 +++++ .../csp_configuration_provider/server/provider.test.ts | 5 +++++ src/plugins/csp_configuration_provider/server/provider.ts | 5 +++++ .../csp_configuration_provider/server/routes/index.ts | 5 +++++ src/plugins/csp_configuration_provider/server/types.ts | 5 +++++ 7 files changed, 35 insertions(+) diff --git a/src/plugins/csp_configuration_provider/common/index.ts b/src/plugins/csp_configuration_provider/common/index.ts index a4db30412db3..9baae8401294 100644 --- a/src/plugins/csp_configuration_provider/common/index.ts +++ b/src/plugins/csp_configuration_provider/common/index.ts @@ -1,2 +1,7 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + export const PLUGIN_ID = 'cspConfigurationProvider'; export const PLUGIN_NAME = 'CspConfigurationProvider'; diff --git a/src/plugins/csp_configuration_provider/server/index.ts b/src/plugins/csp_configuration_provider/server/index.ts index a7254794135f..0302e51e9fea 100644 --- a/src/plugins/csp_configuration_provider/server/index.ts +++ b/src/plugins/csp_configuration_provider/server/index.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + import { PluginInitializerContext } from '../../../core/server'; import { CspConfigurationProviderPlugin } from './plugin'; diff --git a/src/plugins/csp_configuration_provider/server/plugin.ts b/src/plugins/csp_configuration_provider/server/plugin.ts index f20352e042b7..55913662ea4d 100644 --- a/src/plugins/csp_configuration_provider/server/plugin.ts +++ b/src/plugins/csp_configuration_provider/server/plugin.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + import { CoreSetup, CoreStart, diff --git a/src/plugins/csp_configuration_provider/server/provider.test.ts b/src/plugins/csp_configuration_provider/server/provider.test.ts index ca95443ee5ff..b5077202622f 100644 --- a/src/plugins/csp_configuration_provider/server/provider.test.ts +++ b/src/plugins/csp_configuration_provider/server/provider.test.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + import { SearchResponse } from '@opensearch-project/opensearch/api/types'; import { OpenSearchClientMock, diff --git a/src/plugins/csp_configuration_provider/server/provider.ts b/src/plugins/csp_configuration_provider/server/provider.ts index b0e8e507d90b..17001aaa5624 100644 --- a/src/plugins/csp_configuration_provider/server/provider.ts +++ b/src/plugins/csp_configuration_provider/server/provider.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + import { OpenSearchClient } from '../../../../src/core/server'; import { CspClient } from './types'; diff --git a/src/plugins/csp_configuration_provider/server/routes/index.ts b/src/plugins/csp_configuration_provider/server/routes/index.ts index 604e1aa4bf7a..81e830f135a2 100644 --- a/src/plugins/csp_configuration_provider/server/routes/index.ts +++ b/src/plugins/csp_configuration_provider/server/routes/index.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + import { IRouter } from '../../../../core/server'; export function defineRoutes(router: IRouter) { diff --git a/src/plugins/csp_configuration_provider/server/types.ts b/src/plugins/csp_configuration_provider/server/types.ts index 97a76780e3dc..9881652c389f 100644 --- a/src/plugins/csp_configuration_provider/server/types.ts +++ b/src/plugins/csp_configuration_provider/server/types.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + // eslint-disable-next-line @typescript-eslint/no-empty-interface export interface CspConfigurationProviderPluginSetup {} // eslint-disable-next-line @typescript-eslint/no-empty-interface From 3343fe4e86488a213d524e77587b27cc456d6e14 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 27 Dec 2023 03:26:24 +0000 Subject: [PATCH 05/59] fix failed unit tests Signed-off-by: Tianle Huang --- src/core/server/csp/csp_config.test.ts | 9 ++++++--- .../http_resources/http_resources_service.test.ts | 12 ++++++------ 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/src/core/server/csp/csp_config.test.ts b/src/core/server/csp/csp_config.test.ts index cd452a7d8c42..61c6f0a73c8b 100644 --- a/src/core/server/csp/csp_config.test.ts +++ b/src/core/server/csp/csp_config.test.ts @@ -47,11 +47,12 @@ describe('CspConfig', () => { test('DEFAULT', () => { expect(CspConfig.DEFAULT).toMatchInlineSnapshot(` CspConfig { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", "rules": Array [ "script-src 'unsafe-eval' 'self'", "worker-src blob: 'self'", "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", ], "strict": false, "warnLegacyBrowsers": true, @@ -62,11 +63,12 @@ describe('CspConfig', () => { test('defaults from config', () => { expect(new CspConfig()).toMatchInlineSnapshot(` CspConfig { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", "rules": Array [ "script-src 'unsafe-eval' 'self'", "worker-src blob: 'self'", "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", ], "strict": false, "warnLegacyBrowsers": true, @@ -77,11 +79,12 @@ describe('CspConfig', () => { test('creates from partial config', () => { expect(new CspConfig({ strict: true, warnLegacyBrowsers: false })).toMatchInlineSnapshot(` CspConfig { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", "rules": Array [ "script-src 'unsafe-eval' 'self'", "worker-src blob: 'self'", "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", ], "strict": true, "warnLegacyBrowsers": false, diff --git a/src/core/server/http_resources/http_resources_service.test.ts b/src/core/server/http_resources/http_resources_service.test.ts index 4a61c977e7ff..1f5948823232 100644 --- a/src/core/server/http_resources/http_resources_service.test.ts +++ b/src/core/server/http_resources/http_resources_service.test.ts @@ -101,7 +101,7 @@ describe('HttpResources service', () => { headers: { 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", }, }); }); @@ -150,7 +150,7 @@ describe('HttpResources service', () => { headers: { 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", }, }); }); @@ -173,7 +173,7 @@ describe('HttpResources service', () => { headers: { 'content-type': 'text/html', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", }, }); }); @@ -205,7 +205,7 @@ describe('HttpResources service', () => { 'content-type': 'text/html', 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", }, }); }); @@ -228,7 +228,7 @@ describe('HttpResources service', () => { headers: { 'content-type': 'text/javascript', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", }, }); }); @@ -260,7 +260,7 @@ describe('HttpResources service', () => { 'content-type': 'text/javascript', 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", }, }); }); From f634d39ae35458e65fe85d8ca2dd38119c3f9b96 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 01:32:57 +0000 Subject: [PATCH 06/59] add unit tests for the handler Signed-off-by: Tianle Huang --- src/core/public/http/http_service.mock.ts | 6 + src/core/public/mocks.ts | 2 + .../server/csp_handlers.test.ts | 181 ++++++++++++++++++ .../server/csp_handlers.ts | 28 +-- 4 files changed, 203 insertions(+), 14 deletions(-) create mode 100644 src/plugins/csp_configuration_provider/server/csp_handlers.test.ts diff --git a/src/core/public/http/http_service.mock.ts b/src/core/public/http/http_service.mock.ts index 8c10d10017e5..0461e43ec1d4 100644 --- a/src/core/public/http/http_service.mock.ts +++ b/src/core/public/http/http_service.mock.ts @@ -33,9 +33,11 @@ import { HttpService } from './http_service'; import { HttpSetup } from './types'; import { BehaviorSubject } from 'rxjs'; import { BasePath } from './base_path'; +import { ICspConfig } from 'opensearch-dashboards/server'; export type HttpSetupMock = jest.Mocked & { basePath: BasePath; + csp: ICspConfig; anonymousPaths: jest.Mocked; }; @@ -56,6 +58,10 @@ const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({ addLoadingCountSource: jest.fn(), getLoadingCount$: jest.fn().mockReturnValue(new BehaviorSubject(0)), intercept: jest.fn(), + csp: { + header: + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + }, }); const createMock = ({ basePath = '' } = {}) => { diff --git a/src/core/public/mocks.ts b/src/core/public/mocks.ts index 3acc71424b91..b8f07d5b7546 100644 --- a/src/core/public/mocks.ts +++ b/src/core/public/mocks.ts @@ -48,6 +48,7 @@ import { savedObjectsServiceMock } from './saved_objects/saved_objects_service.m import { contextServiceMock } from './context/context_service.mock'; import { injectedMetadataServiceMock } from './injected_metadata/injected_metadata_service.mock'; import { workspacesServiceMock } from './workspace/workspaces_service.mock'; +import { opensearchServiceMock } from '../server/mocks'; export { chromeServiceMock } from './chrome/chrome_service.mock'; export { docLinksServiceMock } from './doc_links/doc_links_service.mock'; @@ -110,6 +111,7 @@ function createCoreStartMock({ basePath = '' } = {}) { }, fatalErrors: fatalErrorsServiceMock.createStartContract(), workspaces: workspacesServiceMock.createStartContract(), + opensearch: opensearchServiceMock.createStart(), }; return mock; diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts new file mode 100644 index 000000000000..33e3ac3491c0 --- /dev/null +++ b/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts @@ -0,0 +1,181 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { coreMock } from '../../../core/public/mocks'; +import { RouteMethod } from '../../../core/server'; +import { + OpenSearchDashboardsRequest, + OpenSearchDashboardsRouteOptions, +} from '../../../core/server/http/router/request'; +import { httpServerMock } from '../../../core/server/mocks'; +import { createCspRulesPreResponseHandler } from './csp_handlers'; + +const forgeRequest = ({ + headers = {}, + path = '/', + method = 'get', + opensearchDashboardsRouteOptions, +}: Partial<{ + headers: Record; + path: string; + method: RouteMethod; + opensearchDashboardsRouteOptions: OpenSearchDashboardsRouteOptions; +}>): OpenSearchDashboardsRequest => { + return httpServerMock.createOpenSearchDashboardsRequest({ + headers, + path, + method, + opensearchDashboardsRouteOptions, + }); +}; + +describe('CSP handlers', () => { + let toolkit: ReturnType; + + beforeEach(() => { + jest.resetAllMocks(); + toolkit = httpServerMock.createToolkit(); + }); + + it('adds the CSP headers provided by the client', async () => { + const coreSetup = coreMock.createSetup(); + const cspRules = "frame-ancestors 'self'"; + + const cspClient = { + exists: jest.fn().mockReturnValue(true), + get: jest.fn().mockReturnValue(cspRules), + }; + + const getCspClient = jest.fn().mockReturnValue(cspClient); + + const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toHaveBeenCalledTimes(1); + + expect(toolkit.next).toHaveBeenCalledWith({ + headers: { + 'content-security-policy': cspRules, + }, + }); + + expect(cspClient.exists).toBeCalledTimes(1); + expect(cspClient.get).toBeCalledTimes(1); + }); + + it('do not add CSP headers when the client returns empty', async () => { + const coreSetup = coreMock.createSetup(); + const emptyCspRules = ''; + + const cspClient = { + exists: jest.fn().mockReturnValue(true), + get: jest.fn().mockReturnValue(emptyCspRules), + }; + + const getCspClient = jest.fn().mockReturnValue(cspClient); + + const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toHaveBeenCalledTimes(1); + expect(toolkit.next).toHaveBeenCalledWith({}); + + expect(cspClient.exists).toBeCalledTimes(1); + expect(cspClient.get).toBeCalledTimes(1); + }); + + it('do not add CSP headers when the configuration does not exist', async () => { + const coreSetup = coreMock.createSetup(); + + const cspClient = { + exists: jest.fn().mockReturnValue(false), + get: jest.fn(), + }; + + const getCspClient = jest.fn().mockReturnValue(cspClient); + + const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toBeCalledTimes(1); + expect(toolkit.next).toBeCalledWith({}); + + expect(cspClient.exists).toBeCalledTimes(1); + expect(cspClient.get).toBeCalledTimes(0); + }); + + it('do not add CSP headers when request dest exists and shall skip', async () => { + const coreSetup = coreMock.createSetup(); + + const cspClient = { + exists: jest.fn(), + get: jest.fn(), + }; + + const getCspClient = jest.fn().mockReturnValue(cspClient); + + const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + + const cssSecFetchDest = 'css'; + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': cssSecFetchDest } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toBeCalledTimes(1); + expect(toolkit.next).toBeCalledWith({}); + + expect(cspClient.exists).toBeCalledTimes(0); + expect(cspClient.get).toBeCalledTimes(0); + }); + + it('do not add CSP headers when request dest does not exist', async () => { + const coreSetup = coreMock.createSetup(); + + const cspClient = { + exists: jest.fn(), + get: jest.fn(), + }; + + const getCspClient = jest.fn().mockReturnValue(cspClient); + + const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + + const request = forgeRequest({ method: 'get', headers: {} }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toBeCalledTimes(1); + expect(toolkit.next).toBeCalledWith({}); + + expect(cspClient.exists).toBeCalledTimes(0); + expect(cspClient.get).toBeCalledTimes(0); + }); +}); diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.ts index 0625f9d24502..5a2ff8158e47 100644 --- a/src/plugins/csp_configuration_provider/server/csp_handlers.ts +++ b/src/plugins/csp_configuration_provider/server/csp_handlers.ts @@ -26,23 +26,23 @@ export function createCspRulesPreResponseHandler( const myClient = getCspClient(coreStart.opensearch.client.asInternalUser); - const existsData = await myClient.exists(OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME); - - let header; - const defaultHeader = core.http.csp.header; - - if (!existsData) { - header = defaultHeader; - } else { - const data = await myClient.get( - OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME, - OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME - ); - header = data || defaultHeader; + const existsValue = await myClient.exists(OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME); + + if (!existsValue) { + return toolkit.next({}); + } + + const cspRules = await myClient.get( + OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME, + OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME + ); + + if (!cspRules) { + return toolkit.next({}); } const additionalHeaders = { - ['content-security-policy']: header, + 'content-security-policy': cspRules, }; return toolkit.next({ headers: additionalHeaders }); From 4e03159b900513b926ef650fe0985a1a7442588a Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 04:01:14 +0000 Subject: [PATCH 07/59] add content to read me Signed-off-by: Tianle Huang --- .../csp_configuration_provider/README.md | 53 +++++++++++++++++++ .../server/routes/index.ts | 16 +----- 2 files changed, 54 insertions(+), 15 deletions(-) diff --git a/src/plugins/csp_configuration_provider/README.md b/src/plugins/csp_configuration_provider/README.md index 3850ae79b05e..e22072fa015a 100755 --- a/src/plugins/csp_configuration_provider/README.md +++ b/src/plugins/csp_configuration_provider/README.md @@ -2,8 +2,61 @@ A OpenSearch Dashboards plugin +This plugin introduces the support of self service dynamic configuration of Content Security Policy (CSP) rules without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get Content Security Policy (CSP) rules from a new index `.opensearch_dashboards_config` and then rewrite to CSP header. OSD users could update the content of the index with new CSP rules and will take effect immediately. + +It also provides an interface `CspClient` for future extensions of external CSP providers. By default, an implementation based on OpenSearch as database is used. + --- +## Configuration + +By default, the new index does not exist. For OSD users who do not need customized CSP rules, there is no need to create this index. The system will then use whatever CSP rules aggregated by the values of `csp.rules` from `opensearch_dashboards.yml` and default values. + +Below is the current default value. + +``` +"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'" +``` +(Note that `frame-ancestors 'self'` is used to only allow self embedding and prevent clickjacking by default.) + +For OSD users who want to make changes, e.g allow this site `https://example-site.org` to embed OSD pages, they can update the index from DevTools Console. + +``` +PUT .opensearch_dashboards_config/_doc/csp.rules +{ + "value": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' https://example-site.org" +} + +``` + +## External CSP Clients +While a default OpenSearch based client is implemented, OSD users can use external CSP clients by using an OSD plugin (outside OSD). + +Let's call this plugin `MyCspClientPlugin`. + +First, this plugin will need to implement a class `MyCspClient` based on interface `CspClient` defined in the `types.ts`. + +Second, this plugin needs to declare `cspConfigurationProvider` as its dependency by adding it to `requiredPlugins` in its own `opensearch_dashboards.json`. + +Third, the plugin will import the type `CspConfigurationProviderPluginSetup` from the corresponding `types.ts` and add to its own setup input. Below is the skeleton of the class `MyCspClientPlugin`. + +``` +// MyCspClientPlugin + public setup(core: CoreSetup, { cspConfigurationProviderPluginSetup }: CspConfigurationProviderPluginSetup) { + + ... + // The function createClient provides an instance of MyCspClient which + // could have a underlying DynamoDB or Postgres implementation. + const myCspClient: CspClient = this.createClient(); + + cspConfigurationProviderPluginSetup.setCspClient(myCspClient); + ... + return {}; + } + +``` + +--- ## Development See the [OpenSearch Dashboards contributing diff --git a/src/plugins/csp_configuration_provider/server/routes/index.ts b/src/plugins/csp_configuration_provider/server/routes/index.ts index 81e830f135a2..06f88042a95c 100644 --- a/src/plugins/csp_configuration_provider/server/routes/index.ts +++ b/src/plugins/csp_configuration_provider/server/routes/index.ts @@ -5,18 +5,4 @@ import { IRouter } from '../../../../core/server'; -export function defineRoutes(router: IRouter) { - router.get( - { - path: '/api/csp_configuration_provider/example', - validate: false, - }, - async (context, request, response) => { - return response.ok({ - body: { - time: new Date().toISOString(), - }, - }); - } - ); -} +export function defineRoutes(router: IRouter) {} From d9f9bacf63cf5cf043b15a08ea6cc370dfb38824 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 04:28:27 +0000 Subject: [PATCH 08/59] fix test error Signed-off-by: Tianle Huang --- src/core/public/http/http_service.mock.ts | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/core/public/http/http_service.mock.ts b/src/core/public/http/http_service.mock.ts index 0461e43ec1d4..7b98347b4dfb 100644 --- a/src/core/public/http/http_service.mock.ts +++ b/src/core/public/http/http_service.mock.ts @@ -59,8 +59,16 @@ const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({ getLoadingCount$: jest.fn().mockReturnValue(new BehaviorSubject(0)), intercept: jest.fn(), csp: { + rules: [ + `script-src 'unsafe-eval' 'self'`, + `worker-src blob: 'self'`, + `style-src 'unsafe-inline' 'self'`, + `frame-ancestors 'self'`, + ], header: "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + warnLegacyBrowsers: true, + strict: false, }, }); From 7a4a93fb4f15e87e846b97f2a0aaf6748b30c62a Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 04:48:08 +0000 Subject: [PATCH 09/59] update readme Signed-off-by: Tianle Huang --- src/plugins/csp_configuration_provider/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/csp_configuration_provider/README.md b/src/plugins/csp_configuration_provider/README.md index e22072fa015a..f9e5c0bc3700 100755 --- a/src/plugins/csp_configuration_provider/README.md +++ b/src/plugins/csp_configuration_provider/README.md @@ -2,7 +2,7 @@ A OpenSearch Dashboards plugin -This plugin introduces the support of self service dynamic configuration of Content Security Policy (CSP) rules without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get Content Security Policy (CSP) rules from a new index `.opensearch_dashboards_config` and then rewrite to CSP header. OSD users could update the content of the index with new CSP rules and will take effect immediately. +This plugin introduces the support of self service dynamic configuration of Content Security Policy (CSP) rules without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from a new index `.opensearch_dashboards_config` and then rewrite to CSP header. OSD users could update the content of the index with new CSP rules and will take effect immediately. It also provides an interface `CspClient` for future extensions of external CSP providers. By default, an implementation based on OpenSearch as database is used. From 5515cad190380e8ea86001b27aa2bffde86072fa Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 05:00:11 +0000 Subject: [PATCH 10/59] update CHANGELOG.md Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ca45463f3f38..5490e9bba72c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -75,6 +75,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [CVE-2023-26159] Bump `follow-redirects` from `1.15.2` to `1.15.4` ([#5669](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5669)) - [CVE-2023-52079] Bump `msgpackr` from `1.9.7` to `1.10.1` ([#5803](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5803)) - [CVE-2020-8203] Bump `cheerio` from `0.22.0` to `1.0.0-rc.1` to fix vulnerable `lodash` dependency ([#5797](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5797)) +- Support dynamic csp rules to mitigate clickjacking ([#5641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641)) ### 📈 Features/Enhancements From f0a7bf010ecd6418f5918b3fd0f1c887a022448d Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 05:16:55 +0000 Subject: [PATCH 11/59] update snap tests Signed-off-by: Tianle Huang --- .../dashboard_listing.test.tsx.snap | 9537 ++++++++++++- .../dashboard_top_nav.test.tsx.snap | 11010 ++++++++++++++++ .../dashboard_empty_screen.test.tsx.snap | 33 + .../__snapshots__/flyout.test.tsx.snap | 11 + ...telemetry_management_section.test.tsx.snap | 11 + 5 files changed, 20421 insertions(+), 181 deletions(-) diff --git a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap index c9ffe147e5f8..753ab4e870d7 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap @@ -861,6 +861,17 @@ exports[`dashboard listing hideWriteControls 1`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -891,6 +902,1830 @@ exports[`dashboard listing hideWriteControls 1`] = ` "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "osdUrlStateStorage": Object { "flush": [MockFunction], @@ -1993,6 +3828,17 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -2023,96 +3869,1920 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "remove": [MockFunction], }, }, - "opensearchDashboardsVersion": "3.0.0", - "osdUrlStateStorage": Object { - "flush": [MockFunction], - "get": [MockFunction] { - "calls": Array [ - Array [ - "_g", - ], - ], - "results": Array [ - Object { - "type": "return", - "value": Object { - "linked": false, - }, - }, - ], - }, - "set": [MockFunction], - }, - "overlays": Object { - "banners": Object { - "add": [MockFunction], - "get$": [MockFunction], - "getComponent": [MockFunction], - "remove": [MockFunction], - "replace": [MockFunction], - }, - "openConfirm": [MockFunction], - "openFlyout": [MockFunction], - "openModal": [MockFunction], - }, - "savedObjects": Object { + "opensearch": Object { "client": Object { - "bulkCreate": [MockFunction], - "bulkGet": [MockFunction], - "bulkUpdate": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "find": [MockFunction], - "get": [MockFunction], - "update": [MockFunction], - }, - }, - "savedObjectsClient": Object { - "find": [Function], - }, - "savedObjectsPublic": Object { - "settings": Object { - "getListingLimit": [Function], - "getPerPage": [Function], - }, - }, - "toastNotifications": Object { - "add": [MockFunction], - "addDanger": [MockFunction], - "addError": [MockFunction], - "addInfo": [MockFunction], - "addSuccess": [MockFunction], - "addWarning": [MockFunction], - "get$": [MockFunction], - "remove": [MockFunction], - }, - "uiSettings": Object { - "get": [MockFunction] { - "calls": Array [ - Array [ - "dateFormat", - ], - ], - "results": Array [ - Object { - "type": "return", - "value": undefined, + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, }, - ], - }, - "get$": [MockFunction], - "getAll": [MockFunction], - "getSaved$": [MockFunction], - "getUpdate$": [MockFunction], - "getUpdateErrors$": [MockFunction], - "isCustom": [MockFunction], - "isDeclared": [MockFunction], - "isDefault": [MockFunction], - "isOverridden": [MockFunction], - "overrideLocalDefault": [MockFunction], - "remove": [MockFunction], - "set": [MockFunction], - }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, + "opensearchDashboardsVersion": "3.0.0", + "osdUrlStateStorage": Object { + "flush": [MockFunction], + "get": [MockFunction] { + "calls": Array [ + Array [ + "_g", + ], + ], + "results": Array [ + Object { + "type": "return", + "value": Object { + "linked": false, + }, + }, + ], + }, + "set": [MockFunction], + }, + "overlays": Object { + "banners": Object { + "add": [MockFunction], + "get$": [MockFunction], + "getComponent": [MockFunction], + "remove": [MockFunction], + "replace": [MockFunction], + }, + "openConfirm": [MockFunction], + "openFlyout": [MockFunction], + "openModal": [MockFunction], + }, + "savedObjects": Object { + "client": Object { + "bulkCreate": [MockFunction], + "bulkGet": [MockFunction], + "bulkUpdate": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "find": [MockFunction], + "get": [MockFunction], + "update": [MockFunction], + }, + }, + "savedObjectsClient": Object { + "find": [Function], + }, + "savedObjectsPublic": Object { + "settings": Object { + "getListingLimit": [Function], + "getPerPage": [Function], + }, + }, + "toastNotifications": Object { + "add": [MockFunction], + "addDanger": [MockFunction], + "addError": [MockFunction], + "addInfo": [MockFunction], + "addSuccess": [MockFunction], + "addWarning": [MockFunction], + "get$": [MockFunction], + "remove": [MockFunction], + }, + "uiSettings": Object { + "get": [MockFunction] { + "calls": Array [ + Array [ + "dateFormat", + ], + ], + "results": Array [ + Object { + "type": "return", + "value": undefined, + }, + ], + }, + "get$": [MockFunction], + "getAll": [MockFunction], + "getSaved$": [MockFunction], + "getUpdate$": [MockFunction], + "getUpdateErrors$": [MockFunction], + "isCustom": [MockFunction], + "isDeclared": [MockFunction], + "isDefault": [MockFunction], + "isOverridden": [MockFunction], + "overrideLocalDefault": [MockFunction], + "remove": [MockFunction], + "set": [MockFunction], + }, "usageCollection": Object { "METRIC_TYPE": Object { "APPLICATION_USAGE": "application_usage", @@ -3186,34 +6856,1869 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "remove": [Function], "serverBasePath": "", }, - "delete": [MockFunction], - "fetch": [MockFunction], - "get": [MockFunction], - "getLoadingCount$": [MockFunction], - "head": [MockFunction], - "intercept": [MockFunction], - "options": [MockFunction], - "patch": [MockFunction], - "post": [MockFunction], - "put": [MockFunction], - }, - "i18n": Object { - "Context": [MockFunction], - }, - "injectedMetadata": Object { - "getBranding": [MockFunction], - "getInjectedVar": [MockFunction], - }, - "notifications": Object { - "toasts": Object { - "add": [MockFunction], - "addDanger": [MockFunction], - "addError": [MockFunction], - "addInfo": [MockFunction], - "addSuccess": [MockFunction], - "addWarning": [MockFunction], - "get$": [MockFunction], - "remove": [MockFunction], + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, + "delete": [MockFunction], + "fetch": [MockFunction], + "get": [MockFunction], + "getLoadingCount$": [MockFunction], + "head": [MockFunction], + "intercept": [MockFunction], + "options": [MockFunction], + "patch": [MockFunction], + "post": [MockFunction], + "put": [MockFunction], + }, + "i18n": Object { + "Context": [MockFunction], + }, + "injectedMetadata": Object { + "getBranding": [MockFunction], + "getInjectedVar": [MockFunction], + }, + "notifications": Object { + "toasts": Object { + "add": [MockFunction], + "addDanger": [MockFunction], + "addError": [MockFunction], + "addInfo": [MockFunction], + "addSuccess": [MockFunction], + "addWarning": [MockFunction], + "get$": [MockFunction], + "remove": [MockFunction], + }, + }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], }, }, "opensearchDashboardsVersion": "3.0.0", @@ -4339,74 +9844,1909 @@ exports[`dashboard listing renders table rows 1`] = ` "paragraph_tutorial": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#paragraph-actions", "sample_notebook": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#sample-notebooks", }, - "reporting": "https://opensearch.org/docs/mocked-test-branch/dashboards/reporting", - "visualize": Object { - "guide": "https://opensearch.org/docs/mocked-test-branchvisualize/viz-index/", + "reporting": "https://opensearch.org/docs/mocked-test-branch/dashboards/reporting", + "visualize": Object { + "guide": "https://opensearch.org/docs/mocked-test-branchvisualize/viz-index/", + }, + }, + }, + }, + "embeddable": Object { + "EmbeddablePanel": [MockFunction], + "extract": [MockFunction], + "getEmbeddableFactories": [MockFunction], + "getEmbeddableFactory": [MockFunction], + "getEmbeddablePanel": [MockFunction], + "getStateTransfer": [MockFunction], + "inject": [MockFunction], + "telemetry": [MockFunction], + }, + "fatalErrors": Object { + "add": [MockFunction], + "get$": [MockFunction], + }, + "history": Object { + "location": Object { + "pathname": "", + }, + "replace": [MockFunction], + }, + "http": Object { + "addLoadingCountSource": [MockFunction], + "anonymousPaths": Object { + "isAnonymous": [MockFunction], + "register": [MockFunction], + }, + "basePath": BasePath { + "basePath": "", + "get": [Function], + "prepend": [Function], + "remove": [Function], + "serverBasePath": "", + }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, + "delete": [MockFunction], + "fetch": [MockFunction], + "get": [MockFunction], + "getLoadingCount$": [MockFunction], + "head": [MockFunction], + "intercept": [MockFunction], + "options": [MockFunction], + "patch": [MockFunction], + "post": [MockFunction], + "put": [MockFunction], + }, + "i18n": Object { + "Context": [MockFunction], + }, + "injectedMetadata": Object { + "getBranding": [MockFunction], + "getInjectedVar": [MockFunction], + }, + "notifications": Object { + "toasts": Object { + "add": [MockFunction], + "addDanger": [MockFunction], + "addError": [MockFunction], + "addInfo": [MockFunction], + "addSuccess": [MockFunction], + "addWarning": [MockFunction], + "get$": [MockFunction], + "remove": [MockFunction], + }, + }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, }, }, + "asScoped": [MockFunction], }, - }, - "embeddable": Object { - "EmbeddablePanel": [MockFunction], - "extract": [MockFunction], - "getEmbeddableFactories": [MockFunction], - "getEmbeddableFactory": [MockFunction], - "getEmbeddablePanel": [MockFunction], - "getStateTransfer": [MockFunction], - "inject": [MockFunction], - "telemetry": [MockFunction], - }, - "fatalErrors": Object { - "add": [MockFunction], - "get$": [MockFunction], - }, - "history": Object { - "location": Object { - "pathname": "", - }, - "replace": [MockFunction], - }, - "http": Object { - "addLoadingCountSource": [MockFunction], - "anonymousPaths": Object { - "isAnonymous": [MockFunction], - "register": [MockFunction], - }, - "basePath": BasePath { - "basePath": "", - "get": [Function], - "prepend": [Function], - "remove": [Function], - "serverBasePath": "", - }, - "delete": [MockFunction], - "fetch": [MockFunction], - "get": [MockFunction], - "getLoadingCount$": [MockFunction], - "head": [MockFunction], - "intercept": [MockFunction], - "options": [MockFunction], - "patch": [MockFunction], - "post": [MockFunction], - "put": [MockFunction], - }, - "i18n": Object { - "Context": [MockFunction], - }, - "injectedMetadata": Object { - "getBranding": [MockFunction], - "getInjectedVar": [MockFunction], - }, - "notifications": Object { - "toasts": Object { - "add": [MockFunction], - "addDanger": [MockFunction], - "addError": [MockFunction], - "addInfo": [MockFunction], - "addSuccess": [MockFunction], - "addWarning": [MockFunction], - "get$": [MockFunction], - "remove": [MockFunction], + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], }, }, "opensearchDashboardsVersion": "3.0.0", @@ -5572,6 +12912,17 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -5602,6 +12953,1830 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "osdUrlStateStorage": Object { "flush": [MockFunction], diff --git a/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap index 1954051c9474..46d03a9483ea 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap @@ -753,6 +753,17 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -788,6 +799,1830 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -1710,6 +3545,17 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -1745,6 +3591,1830 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -2667,6 +6337,17 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -2702,6 +6383,1830 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -3624,6 +9129,17 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -3659,6 +9175,1830 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -4581,6 +11921,17 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -4616,6 +11967,1830 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -5538,6 +14713,17 @@ exports[`Dashboard top nav render with all components 1`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -5573,6 +14759,1830 @@ exports[`Dashboard top nav render with all components 1`] = ` "remove": [MockFunction], }, }, + "opensearch": Object { + "client": Object { + "asInternalUser": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": false, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": false, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asInternalUserWithLongNumeralsSupport": Client { + "bulk": [MockFunction], + "child": [MockFunction], + "clearScroll": [MockFunction], + "close": [MockFunction], + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "count": [MockFunction], + "create": [MockFunction], + "createPit": [MockFunction], + "delete": [MockFunction], + "deleteAllPits": [MockFunction], + "deleteByQuery": [MockFunction], + "deleteByQueryRethrottle": [MockFunction], + "deletePit": [MockFunction], + "deleteScript": [MockFunction], + "exists": [MockFunction], + "existsSource": [MockFunction], + "explain": [MockFunction], + "extend": [MockFunction], + "fieldCaps": [MockFunction], + "get": [MockFunction], + "getAllPits": [MockFunction], + "getScript": [MockFunction], + "getScriptContext": [MockFunction], + "getScriptLanguages": [MockFunction], + "getSource": [MockFunction], + "helpers": Helpers { + "maxRetries": 3, + Symbol(opensearch-client): [Circular], + Symbol(meta header): undefined, + }, + "index": [MockFunction], + "info": [MockFunction], + "mget": [MockFunction], + "msearch": [MockFunction], + "msearchTemplate": [MockFunction], + "mtermvectors": [MockFunction], + "name": "opensearch-js", + "ping": [MockFunction], + "putScript": [MockFunction], + "rankEval": [MockFunction], + "reindex": [MockFunction], + "reindexRethrottle": [MockFunction], + "renderSearchTemplate": [MockFunction], + "scriptsPainlessExecute": [MockFunction], + "scroll": [MockFunction], + "search": [MockFunction], + "searchShards": [MockFunction], + "searchTemplate": [MockFunction], + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "termsEnum": [MockFunction], + "termvectors": [MockFunction], + "transport": Object { + "request": [MockFunction], + }, + "update": [MockFunction], + "updateByQuery": [MockFunction], + "updateByQueryRethrottle": [MockFunction], + Symbol(configuration error): [Function], + Symbol(Cat): CatApi { + "aliases": [MockFunction], + "allocation": [MockFunction], + "cluster_manager": [MockFunction], + "count": [MockFunction], + "fielddata": [MockFunction], + "health": [MockFunction], + "help": [MockFunction], + "indices": [MockFunction], + "master": [MockFunction], + "nodeattrs": [MockFunction], + "nodes": [MockFunction], + "pendingTasks": [MockFunction], + "plugins": [MockFunction], + "recovery": [MockFunction], + "repositories": [MockFunction], + "segments": [MockFunction], + "shards": [MockFunction], + "snapshots": [MockFunction], + "tasks": [MockFunction], + "templates": [MockFunction], + "threadPool": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Cluster): ClusterApi { + "allocationExplain": [MockFunction], + "deleteComponentTemplate": [MockFunction], + "deleteVotingConfigExclusions": [MockFunction], + "existsComponentTemplate": [MockFunction], + "getComponentTemplate": [MockFunction], + "getSettings": [MockFunction], + "health": [MockFunction], + "pendingTasks": [MockFunction], + "postVotingConfigExclusions": [MockFunction], + "putComponentTemplate": [MockFunction], + "putSettings": [MockFunction], + "remoteInfo": [MockFunction], + "reroute": [MockFunction], + "state": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(DanglingIndices): DanglingIndicesApi { + "deleteDanglingIndex": [MockFunction], + "importDanglingIndex": [MockFunction], + "listDanglingIndices": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Features): FeaturesApi { + "getFeatures": [MockFunction], + "resetFeatures": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Indices): IndicesApi { + "addBlock": [MockFunction], + "analyze": [MockFunction], + "clearCache": [MockFunction], + "clone": [MockFunction], + "close": [MockFunction], + "create": [MockFunction], + "delete": [MockFunction], + "deleteAlias": [MockFunction], + "deleteIndexTemplate": [MockFunction], + "deleteTemplate": [MockFunction], + "diskUsage": [MockFunction], + "exists": [MockFunction], + "existsAlias": [MockFunction], + "existsIndexTemplate": [MockFunction], + "existsTemplate": [MockFunction], + "fieldUsageStats": [MockFunction], + "flush": [MockFunction], + "forcemerge": [MockFunction], + "get": [MockFunction], + "getAlias": [MockFunction], + "getFieldMapping": [MockFunction], + "getIndexTemplate": [MockFunction], + "getMapping": [MockFunction], + "getSettings": [MockFunction], + "getTemplate": [MockFunction], + "getUpgrade": [MockFunction], + "open": [MockFunction], + "putAlias": [MockFunction], + "putIndexTemplate": [MockFunction], + "putMapping": [MockFunction], + "putSettings": [MockFunction], + "putTemplate": [MockFunction], + "recovery": [MockFunction], + "refresh": [MockFunction], + "resolveIndex": [MockFunction], + "rollover": [MockFunction], + "segments": [MockFunction], + "shardStores": [MockFunction], + "shrink": [MockFunction], + "simulateIndexTemplate": [MockFunction], + "simulateTemplate": [MockFunction], + "split": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "updateAliases": [MockFunction], + "upgrade": [MockFunction], + "validateQuery": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Ingest): IngestApi { + "deletePipeline": [MockFunction], + "geoIpStats": [MockFunction], + "getPipeline": [MockFunction], + "processorGrok": [MockFunction], + "putPipeline": [MockFunction], + "simulate": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Nodes): NodesApi { + "clearMeteringArchive": [MockFunction], + "getMeteringInfo": [MockFunction], + "hotThreads": [MockFunction], + "info": [MockFunction], + "reloadSecureSettings": [MockFunction], + "stats": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "usage": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Shutdown): ShutdownApi { + "deleteNode": [MockFunction], + "getNode": [MockFunction], + "putNode": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(Snapshot): SnapshotApi { + "cleanupRepository": [MockFunction], + "clone": [MockFunction], + "create": [MockFunction], + "createRepository": [MockFunction], + "delete": [MockFunction], + "deleteRepository": [MockFunction], + "get": [MockFunction], + "getRepository": [MockFunction], + "repositoryAnalyze": [MockFunction], + "restore": [MockFunction], + "status": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + "verifyRepository": [MockFunction], + Symbol(configuration error): [Function], + }, + Symbol(Tasks): TasksApi { + "cancel": [MockFunction], + "get": [MockFunction], + "list": [MockFunction], + "transport": Transport { + "_isSniffing": false, + "_nextSniff": 0, + "_sniffEnabled": false, + "compression": false, + "connectionPool": ConnectionPool { + "Connection": [Function], + "_agent": null, + "_proxy": null, + "_sniffEnabled": false, + "_ssl": null, + "auth": null, + "connections": Array [ + Object { + "_openRequests": 0, + "deadCount": 0, + "headers": Object {}, + "id": "http://localhost/", + "resurrectTimeout": 0, + "roles": Object { + "data": true, + "ingest": true, + }, + "status": "alive", + "url": "http://localhost/", + }, + ], + "dead": Array [], + "emit": [Function], + "pingTimeout": 3000, + "resurrectStrategy": 1, + "resurrectTimeout": 60000, + "resurrectTimeoutCutoff": 5, + "size": 1, + }, + "context": null, + "emit": [Function], + "generateRequestId": [Function], + "headers": Object { + "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + }, + "maxRetries": 3, + "memoryCircuitBreaker": undefined, + "name": "opensearch-js", + "nodeFilter": [Function], + "nodeSelector": [Function], + "opaqueIdPrefix": null, + "requestTimeout": 30000, + "serializer": Serializer { + Symbol(secure json parse options): Object { + "constructorAction": "error", + "enableLongNumeralSupport": true, + "protoAction": "error", + }, + }, + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "suggestCompression": false, + Symbol(compatible check): 0, + Symbol(api versioning): false, + }, + Symbol(configuration error): [Function], + }, + Symbol(opensearchjs-initial-options): Object { + "Connection": [Function], + "ConnectionPool": [Function], + "Serializer": [Function], + "Transport": [Function], + "agent": null, + "auth": null, + "compression": false, + "context": null, + "disablePrototypePoisoningProtection": false, + "enableLongNumeralSupport": true, + "enableMetaHeader": true, + "generateRequestId": null, + "headers": Object {}, + "maxRetries": 3, + "name": "opensearch-js", + "node": "http://localhost", + "nodeFilter": null, + "nodeSelector": "round-robin", + "opaqueIdPrefix": null, + "pingTimeout": 3000, + "proxy": null, + "requestTimeout": 30000, + "resurrectStrategy": "ping", + "sniffEndpoint": "_nodes/_all/http", + "sniffInterval": false, + "sniffOnConnectionFault": false, + "sniffOnStart": false, + "ssl": null, + "suggestCompression": false, + }, + Symbol(opensearchjs-extensions): Array [], + Symbol(opensearchjs-event-emitter): EventEmitter { + "_events": Object {}, + "_eventsCount": 0, + "_maxListeners": undefined, + Symbol(kCapture): false, + }, + }, + "asScoped": [MockFunction], + }, + "createClient": [MockFunction], + "legacy": Object { + "client": Object { + "asScoped": [MockFunction], + "callAsInternalUser": [MockFunction], + }, + "config$": BehaviorSubject { + "_isScalar": false, + "_value": Object {}, + "closed": false, + "hasError": false, + "isStopped": false, + "observers": Array [], + "thrownError": null, + }, + "createClient": [MockFunction], + }, + }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { diff --git a/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap b/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap index 04120e429393..e7f12b24b964 100644 --- a/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap +++ b/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap @@ -16,6 +16,17 @@ exports[`DashboardEmptyScreen renders correctly with readonly mode 1`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -383,6 +394,17 @@ exports[`DashboardEmptyScreen renders correctly with visualize paragraph 1`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -760,6 +782,17 @@ exports[`DashboardEmptyScreen renders correctly without visualize paragraph 1`] "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], diff --git a/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap b/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap index 14fe1fbabd88..0adbd1ec9e19 100644 --- a/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap +++ b/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap @@ -173,6 +173,17 @@ exports[`Flyout conflicts should allow conflict resolution 2`] = ` "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], diff --git a/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap b/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap index 5d71bc774cff..dbfd7a418ba3 100644 --- a/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap +++ b/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap @@ -318,6 +318,17 @@ exports[`TelemetryManagementSectionComponent renders null because allowChangingO "remove": [Function], "serverBasePath": "", }, + "csp": Object { + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "rules": Array [ + "script-src 'unsafe-eval' 'self'", + "worker-src blob: 'self'", + "style-src 'unsafe-inline' 'self'", + "frame-ancestors 'self'", + ], + "strict": false, + "warnLegacyBrowsers": true, + }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], From 352431ae37684837d4770dbb67e1b63c5c8787fd Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 28 Dec 2023 23:09:20 +0000 Subject: [PATCH 12/59] update snapshots Signed-off-by: Tianle Huang --- src/core/public/http/http_service.mock.ts | 14 - .../dashboard_listing.test.tsx.snap | 255 ++++++--------- .../dashboard_top_nav.test.tsx.snap | 306 +++++++----------- .../dashboard_empty_screen.test.tsx.snap | 33 -- .../__snapshots__/flyout.test.tsx.snap | 11 - ...telemetry_management_section.test.tsx.snap | 11 - 6 files changed, 220 insertions(+), 410 deletions(-) diff --git a/src/core/public/http/http_service.mock.ts b/src/core/public/http/http_service.mock.ts index 7b98347b4dfb..8c10d10017e5 100644 --- a/src/core/public/http/http_service.mock.ts +++ b/src/core/public/http/http_service.mock.ts @@ -33,11 +33,9 @@ import { HttpService } from './http_service'; import { HttpSetup } from './types'; import { BehaviorSubject } from 'rxjs'; import { BasePath } from './base_path'; -import { ICspConfig } from 'opensearch-dashboards/server'; export type HttpSetupMock = jest.Mocked & { basePath: BasePath; - csp: ICspConfig; anonymousPaths: jest.Mocked; }; @@ -58,18 +56,6 @@ const createServiceMock = ({ basePath = '' } = {}): HttpSetupMock => ({ addLoadingCountSource: jest.fn(), getLoadingCount$: jest.fn().mockReturnValue(new BehaviorSubject(0)), intercept: jest.fn(), - csp: { - rules: [ - `script-src 'unsafe-eval' 'self'`, - `worker-src blob: 'self'`, - `style-src 'unsafe-inline' 'self'`, - `frame-ancestors 'self'`, - ], - header: - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - warnLegacyBrowsers: true, - strict: false, - }, }); const createMock = ({ basePath = '' } = {}) => { diff --git a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap index 753ab4e870d7..4e31c4b815a1 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap @@ -861,17 +861,6 @@ exports[`dashboard listing hideWriteControls 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -1059,7 +1048,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1139,7 +1128,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1207,7 +1196,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1274,7 +1263,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1382,7 +1371,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1456,7 +1445,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1527,7 +1516,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1596,7 +1585,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1672,7 +1661,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1741,7 +1730,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1960,7 +1949,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2040,7 +2029,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2108,7 +2097,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2175,7 +2164,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2283,7 +2272,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2357,7 +2346,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2428,7 +2417,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2497,7 +2486,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2573,7 +2562,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2642,7 +2631,7 @@ exports[`dashboard listing hideWriteControls 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -3828,17 +3817,6 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -4026,7 +4004,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4106,7 +4084,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4174,7 +4152,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4241,7 +4219,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4349,7 +4327,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4423,7 +4401,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4494,7 +4472,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4563,7 +4541,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4639,7 +4617,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4708,7 +4686,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4927,7 +4905,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5007,7 +4985,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5075,7 +5053,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5142,7 +5120,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5250,7 +5228,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5324,7 +5302,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5395,7 +5373,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5464,7 +5442,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5540,7 +5518,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5609,7 +5587,7 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6856,17 +6834,6 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -7054,7 +7021,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7134,7 +7101,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7202,7 +7169,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7269,7 +7236,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7377,7 +7344,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7451,7 +7418,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7522,7 +7489,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7591,7 +7558,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7667,7 +7634,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7736,7 +7703,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7955,7 +7922,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8035,7 +8002,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8103,7 +8070,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8170,7 +8137,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8278,7 +8245,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8352,7 +8319,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8423,7 +8390,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8492,7 +8459,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8568,7 +8535,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8637,7 +8604,7 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9884,17 +9851,6 @@ exports[`dashboard listing renders table rows 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -10082,7 +10038,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10162,7 +10118,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10230,7 +10186,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10297,7 +10253,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10405,7 +10361,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10479,7 +10435,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10550,7 +10506,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10619,7 +10575,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10695,7 +10651,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10764,7 +10720,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10983,7 +10939,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11063,7 +11019,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11131,7 +11087,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11198,7 +11154,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11306,7 +11262,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11380,7 +11336,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11451,7 +11407,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11520,7 +11476,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11596,7 +11552,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11665,7 +11621,7 @@ exports[`dashboard listing renders table rows 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12912,17 +12868,6 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -13110,7 +13055,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13190,7 +13135,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13258,7 +13203,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13325,7 +13270,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13433,7 +13378,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13507,7 +13452,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13578,7 +13523,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13647,7 +13592,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13723,7 +13668,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13792,7 +13737,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14011,7 +13956,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14091,7 +14036,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14159,7 +14104,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14226,7 +14171,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14334,7 +14279,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14408,7 +14353,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14479,7 +14424,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14548,7 +14493,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14624,7 +14569,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14693,7 +14638,7 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, diff --git a/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap index 46d03a9483ea..571e7ce2ad59 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap @@ -753,17 +753,6 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -956,7 +945,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1036,7 +1025,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1104,7 +1093,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1171,7 +1160,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1279,7 +1268,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1353,7 +1342,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1424,7 +1413,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1493,7 +1482,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1569,7 +1558,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1638,7 +1627,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1857,7 +1846,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -1937,7 +1926,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2005,7 +1994,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2072,7 +2061,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2180,7 +2169,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2254,7 +2243,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2325,7 +2314,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2394,7 +2383,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2470,7 +2459,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -2539,7 +2528,7 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -3545,17 +3534,6 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -3748,7 +3726,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -3828,7 +3806,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -3896,7 +3874,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -3963,7 +3941,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4071,7 +4049,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4145,7 +4123,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4216,7 +4194,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4285,7 +4263,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4361,7 +4339,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4430,7 +4408,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4649,7 +4627,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4729,7 +4707,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4797,7 +4775,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4864,7 +4842,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -4972,7 +4950,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5046,7 +5024,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5117,7 +5095,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5186,7 +5164,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5262,7 +5240,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -5331,7 +5309,7 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6337,17 +6315,6 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -6540,7 +6507,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6620,7 +6587,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6688,7 +6655,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6755,7 +6722,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6863,7 +6830,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -6937,7 +6904,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7008,7 +6975,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7077,7 +7044,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7153,7 +7120,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7222,7 +7189,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7441,7 +7408,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7521,7 +7488,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7589,7 +7556,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7656,7 +7623,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7764,7 +7731,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7838,7 +7805,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7909,7 +7876,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -7978,7 +7945,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8054,7 +8021,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -8123,7 +8090,7 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9129,17 +9096,6 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -9332,7 +9288,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9412,7 +9368,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9480,7 +9436,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9547,7 +9503,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9655,7 +9611,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9729,7 +9685,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9800,7 +9756,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9869,7 +9825,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -9945,7 +9901,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10014,7 +9970,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10233,7 +10189,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10313,7 +10269,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10381,7 +10337,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10448,7 +10404,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10556,7 +10512,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10630,7 +10586,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10701,7 +10657,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10770,7 +10726,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10846,7 +10802,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -10915,7 +10871,7 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -11921,17 +11877,6 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -12124,7 +12069,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12204,7 +12149,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12272,7 +12217,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12339,7 +12284,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12447,7 +12392,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12521,7 +12466,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12592,7 +12537,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12661,7 +12606,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12737,7 +12682,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -12806,7 +12751,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13025,7 +12970,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13105,7 +13050,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13173,7 +13118,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13240,7 +13185,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13348,7 +13293,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13422,7 +13367,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13493,7 +13438,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13562,7 +13507,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13638,7 +13583,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -13707,7 +13652,7 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14713,17 +14658,6 @@ exports[`Dashboard top nav render with all components 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -14916,7 +14850,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -14996,7 +14930,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15064,7 +14998,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15131,7 +15065,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15239,7 +15173,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15313,7 +15247,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15384,7 +15318,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15453,7 +15387,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15529,7 +15463,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15598,7 +15532,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15817,7 +15751,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15897,7 +15831,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -15965,7 +15899,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16032,7 +15966,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16140,7 +16074,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16214,7 +16148,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16285,7 +16219,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16354,7 +16288,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16430,7 +16364,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, @@ -16499,7 +16433,7 @@ exports[`Dashboard top nav render with all components 1`] = ` "emit": [Function], "generateRequestId": [Function], "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 5.4.0-1037-aws-x64; Node.js v18.16.0)", + "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", }, "maxRetries": 3, "memoryCircuitBreaker": undefined, diff --git a/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap b/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap index e7f12b24b964..04120e429393 100644 --- a/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap +++ b/src/plugins/dashboard/public/application/embeddable/empty/__snapshots__/dashboard_empty_screen.test.tsx.snap @@ -16,17 +16,6 @@ exports[`DashboardEmptyScreen renders correctly with readonly mode 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -394,17 +383,6 @@ exports[`DashboardEmptyScreen renders correctly with visualize paragraph 1`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], @@ -782,17 +760,6 @@ exports[`DashboardEmptyScreen renders correctly without visualize paragraph 1`] "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], diff --git a/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap b/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap index 0adbd1ec9e19..14fe1fbabd88 100644 --- a/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap +++ b/src/plugins/saved_objects_management/public/management_section/objects_table/components/__snapshots__/flyout.test.tsx.snap @@ -173,17 +173,6 @@ exports[`Flyout conflicts should allow conflict resolution 2`] = ` "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], diff --git a/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap b/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap index dbfd7a418ba3..5d71bc774cff 100644 --- a/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap +++ b/src/plugins/telemetry_management_section/public/components/__snapshots__/telemetry_management_section.test.tsx.snap @@ -318,17 +318,6 @@ exports[`TelemetryManagementSectionComponent renders null because allowChangingO "remove": [Function], "serverBasePath": "", }, - "csp": Object { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", - "rules": Array [ - "script-src 'unsafe-eval' 'self'", - "worker-src blob: 'self'", - "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", - ], - "strict": false, - "warnLegacyBrowsers": true, - }, "delete": [MockFunction], "fetch": [MockFunction], "get": [MockFunction], From 8ac1824f44128d4c40d535dde76b605b22269eef Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 29 Dec 2023 02:26:01 +0000 Subject: [PATCH 13/59] fix a wrong import Signed-off-by: Tianle Huang --- src/core/public/mocks.ts | 2 - .../server/csp_handlers.test.ts | 3 +- .../dashboard_listing.test.tsx.snap | 17491 ++++++++-------- .../dashboard_top_nav.test.tsx.snap | 10944 ---------- 4 files changed, 8283 insertions(+), 20157 deletions(-) diff --git a/src/core/public/mocks.ts b/src/core/public/mocks.ts index b8f07d5b7546..3acc71424b91 100644 --- a/src/core/public/mocks.ts +++ b/src/core/public/mocks.ts @@ -48,7 +48,6 @@ import { savedObjectsServiceMock } from './saved_objects/saved_objects_service.m import { contextServiceMock } from './context/context_service.mock'; import { injectedMetadataServiceMock } from './injected_metadata/injected_metadata_service.mock'; import { workspacesServiceMock } from './workspace/workspaces_service.mock'; -import { opensearchServiceMock } from '../server/mocks'; export { chromeServiceMock } from './chrome/chrome_service.mock'; export { docLinksServiceMock } from './doc_links/doc_links_service.mock'; @@ -111,7 +110,6 @@ function createCoreStartMock({ basePath = '' } = {}) { }, fatalErrors: fatalErrorsServiceMock.createStartContract(), workspaces: workspacesServiceMock.createStartContract(), - opensearch: opensearchServiceMock.createStart(), }; return mock; diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts index 33e3ac3491c0..7dcaa0abda3c 100644 --- a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts +++ b/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts @@ -3,13 +3,12 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { coreMock } from '../../../core/public/mocks'; import { RouteMethod } from '../../../core/server'; import { OpenSearchDashboardsRequest, OpenSearchDashboardsRouteOptions, } from '../../../core/server/http/router/request'; -import { httpServerMock } from '../../../core/server/mocks'; +import { coreMock, httpServerMock } from '../../../core/server/mocks'; import { createCspRulesPreResponseHandler } from './csp_handlers'; const forgeRequest = ({ diff --git a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap index 4e31c4b815a1..7d428570d6c8 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap @@ -891,1830 +891,6 @@ exports[`dashboard listing hideWriteControls 1`] = ` "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "osdUrlStateStorage": Object { "flush": [MockFunction], @@ -2940,11 +1116,1481 @@ exports[`dashboard listing hideWriteControls 1`] = ` data-test-subj="dashboardLandingPage" >
+ > + + +
+
+ +
+ +
+ +

+ Dashboards +

+ +
+ +
+ + +
+ + + } + pagination={ + Object { + "initialPageIndex": 0, + "initialPageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + } + } + responsive={true} + search={ + Object { + "box": Object { + "incremental": true, + }, + "defaultQuery": "", + "onChange": [Function], + "toolsLeft": undefined, + } + } + sorting={true} + tableLayout="fixed" + > +
+ + +
+ +
+ + + +
+
+ + + + +
+ + + + + +
+ +
+
+ + + +
+ +
+ + + +
+ + + } + onChange={[Function]} + pagination={ + Object { + "hidePerPageOptions": undefined, + "pageIndex": 0, + "pageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + "totalItemCount": 2, + } + } + responsive={true} + sorting={ + Object { + "allowNeutralSort": true, + "sort": undefined, + } + } + tableLayout="fixed" + > +
+
+ +
+ +
+ +
+ + +
+ +
+ + + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ +
+ +
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + + + +
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard0 desc + +
+ 		+
+ Last updated +
+
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard1 desc + +
+ 		+
+ Last updated +
+
+
+ +
+ +
+ +
+ + + +
+ +
+ + + : + 10 + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ + +
+ + + +
+ +
+ + +
+ +
+ +
+ +
+
+ + +
@@ -3847,1844 +3493,20 @@ exports[`dashboard listing render table listing with initial filters from URL 1` "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, - "opensearchDashboardsVersion": "3.0.0", - "osdUrlStateStorage": Object { - "flush": [MockFunction], - "get": [MockFunction] { - "calls": Array [ - Array [ - "_g", - ], - ], - "results": Array [ - Object { - "type": "return", - "value": Object { - "linked": false, + "opensearchDashboardsVersion": "3.0.0", + "osdUrlStateStorage": Object { + "flush": [MockFunction], + "get": [MockFunction] { + "calls": Array [ + Array [ + "_g", + ], + ], + "results": Array [ + Object { + "type": "return", + "value": Object { + "linked": false, }, }, ], @@ -5957,11 +3779,2151 @@ exports[`dashboard listing render table listing with initial filters from URL 1` data-test-subj="dashboardLandingPage" >
+ > + + +
+
+ +
+ +
+ +

+ Dashboards +

+ +
+ + + +
+ + + + + +
+ + +
+ + +
+ + + } + pagination={ + Object { + "initialPageIndex": 0, + "initialPageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + } + } + responsive={true} + search={ + Object { + "box": Object { + "incremental": true, + }, + "defaultQuery": "dashboard", + "onChange": [Function], + "toolsLeft": undefined, + } + } + selection={ + Object { + "onSelectionChange": [Function], + } + } + sorting={true} + tableLayout="fixed" + > +
+ + +
+ +
+ + + +
+
+ + + + +
+ + + + + +
+
+ + + + + +
+ +
+
+ + + +
+ +
+ + + +
+ + + } + onChange={[Function]} + pagination={ + Object { + "hidePerPageOptions": undefined, + "pageIndex": 0, + "pageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + "totalItemCount": 2, + } + } + responsive={true} + selection={ + Object { + "onSelectionChange": [Function], + } + } + sorting={ + Object { + "allowNeutralSort": true, + "sort": undefined, + } + } + tableLayout="fixed" + > +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + +
+ + +
+ +
+ + + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ +
+ +
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+ + +
+ +
+
+ + +
+
+ + + + + + + + + + + + + + Actions + + + + + +
+
+ + +
+ +
+
+ + +
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard0 desc + +
+ 		+
+ Last updated +
+
+
+
+ + + + + + + + + + Edit + + + + + + +
+
+
+ + +
+ +
+
+ + +
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard1 desc + +
+ 		+
+ Last updated +
+
+
+
+ + + + + + + + + + Edit + + + + + + +
+
+ +
+ +
+ +
+ + + +
+ +
+ + + : + 10 + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ + +
+ + + +
+ +
+ + +
+ +
+ +
+ +
+
+ + +
@@ -6864,1830 +6826,6 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "osdUrlStateStorage": Object { "flush": [MockFunction], @@ -8974,11 +7112,274 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = data-test-subj="dashboardLandingPage" >
+ > + + +
+ + + + } + body={ + +

+ +

+

+ + + , + } + } + /> +

+ + } + iconType="dashboardApp" + title={ +

+ +

+ } + > +
+ + + + +
+ + +

+ + Create your first dashboard + +

+ + + + +
+ + +
+

+ + You can combine data views from any OpenSearch Dashboards app into one dashboard and see everything in one place. + +

+

+ + + , + } + } + > + New to OpenSearch Dashboards? + + + + to take a test drive. + +

+
+ + + + +
+ + + + + + +
+ +
+ + +
@@ -9805,1904 +8206,80 @@ exports[`dashboard listing renders table rows 1`] = ` "introduction": "https://opensearch.org/docs/mocked-test-branch/dashboards/index/", "mapTiles": "https://opensearch.org/docs/mocked-test-branch/dashboards/maptiles", "notebooks": Object { - "base": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks", - "create_report": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#create-a-report", - "notebook_tutorial": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#get-started-with-notebooks", - "paragraph_tutorial": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#paragraph-actions", - "sample_notebook": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#sample-notebooks", - }, - "reporting": "https://opensearch.org/docs/mocked-test-branch/dashboards/reporting", - "visualize": Object { - "guide": "https://opensearch.org/docs/mocked-test-branchvisualize/viz-index/", - }, - }, - }, - }, - "embeddable": Object { - "EmbeddablePanel": [MockFunction], - "extract": [MockFunction], - "getEmbeddableFactories": [MockFunction], - "getEmbeddableFactory": [MockFunction], - "getEmbeddablePanel": [MockFunction], - "getStateTransfer": [MockFunction], - "inject": [MockFunction], - "telemetry": [MockFunction], - }, - "fatalErrors": Object { - "add": [MockFunction], - "get$": [MockFunction], - }, - "history": Object { - "location": Object { - "pathname": "", - }, - "replace": [MockFunction], - }, - "http": Object { - "addLoadingCountSource": [MockFunction], - "anonymousPaths": Object { - "isAnonymous": [MockFunction], - "register": [MockFunction], - }, - "basePath": BasePath { - "basePath": "", - "get": [Function], - "prepend": [Function], - "remove": [Function], - "serverBasePath": "", - }, - "delete": [MockFunction], - "fetch": [MockFunction], - "get": [MockFunction], - "getLoadingCount$": [MockFunction], - "head": [MockFunction], - "intercept": [MockFunction], - "options": [MockFunction], - "patch": [MockFunction], - "post": [MockFunction], - "put": [MockFunction], - }, - "i18n": Object { - "Context": [MockFunction], - }, - "injectedMetadata": Object { - "getBranding": [MockFunction], - "getInjectedVar": [MockFunction], - }, - "notifications": Object { - "toasts": Object { - "add": [MockFunction], - "addDanger": [MockFunction], - "addError": [MockFunction], - "addInfo": [MockFunction], - "addSuccess": [MockFunction], - "addWarning": [MockFunction], - "get$": [MockFunction], - "remove": [MockFunction], - }, - }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], + "base": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks", + "create_report": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#create-a-report", + "notebook_tutorial": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#get-started-with-notebooks", + "paragraph_tutorial": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#paragraph-actions", + "sample_notebook": "https://opensearch.org/docs/mocked-test-branch/dashboards/notebooks/#sample-notebooks", }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, + "reporting": "https://opensearch.org/docs/mocked-test-branch/dashboards/reporting", + "visualize": Object { + "guide": "https://opensearch.org/docs/mocked-test-branchvisualize/viz-index/", }, }, - "asScoped": [MockFunction], }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], + }, + "embeddable": Object { + "EmbeddablePanel": [MockFunction], + "extract": [MockFunction], + "getEmbeddableFactories": [MockFunction], + "getEmbeddableFactory": [MockFunction], + "getEmbeddablePanel": [MockFunction], + "getStateTransfer": [MockFunction], + "inject": [MockFunction], + "telemetry": [MockFunction], + }, + "fatalErrors": Object { + "add": [MockFunction], + "get$": [MockFunction], + }, + "history": Object { + "location": Object { + "pathname": "", + }, + "replace": [MockFunction], + }, + "http": Object { + "addLoadingCountSource": [MockFunction], + "anonymousPaths": Object { + "isAnonymous": [MockFunction], + "register": [MockFunction], + }, + "basePath": BasePath { + "basePath": "", + "get": [Function], + "prepend": [Function], + "remove": [Function], + "serverBasePath": "", + }, + "delete": [MockFunction], + "fetch": [MockFunction], + "get": [MockFunction], + "getLoadingCount$": [MockFunction], + "head": [MockFunction], + "intercept": [MockFunction], + "options": [MockFunction], + "patch": [MockFunction], + "post": [MockFunction], + "put": [MockFunction], + }, + "i18n": Object { + "Context": [MockFunction], + }, + "injectedMetadata": Object { + "getBranding": [MockFunction], + "getInjectedVar": [MockFunction], + }, + "notifications": Object { + "toasts": Object { + "add": [MockFunction], + "addDanger": [MockFunction], + "addError": [MockFunction], + "addInfo": [MockFunction], + "addSuccess": [MockFunction], + "addWarning": [MockFunction], + "get$": [MockFunction], + "remove": [MockFunction], }, }, "opensearchDashboardsVersion": "3.0.0", @@ -11991,11 +8568,2111 @@ exports[`dashboard listing renders table rows 1`] = ` data-test-subj="dashboardLandingPage" >
+ > + + +
+
+ +
+ +
+ +

+ Dashboards +

+ +
+ + + +
+ + + + + +
+ + +
+ + +
+ + + } + pagination={ + Object { + "initialPageIndex": 0, + "initialPageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + } + } + responsive={true} + search={ + Object { + "box": Object { + "incremental": true, + }, + "defaultQuery": "", + "onChange": [Function], + "toolsLeft": undefined, + } + } + selection={ + Object { + "onSelectionChange": [Function], + } + } + sorting={true} + tableLayout="fixed" + > +
+ + +
+ +
+ + + +
+
+ + + + +
+ + + + + +
+ +
+
+ + + +
+ +
+ + + +
+ + + } + onChange={[Function]} + pagination={ + Object { + "hidePerPageOptions": undefined, + "pageIndex": 0, + "pageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + "totalItemCount": 2, + } + } + responsive={true} + selection={ + Object { + "onSelectionChange": [Function], + } + } + sorting={ + Object { + "allowNeutralSort": true, + "sort": undefined, + } + } + tableLayout="fixed" + > +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + +
+ + +
+ +
+ + + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ +
+ +
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+ + +
+ +
+
+ + +
+
+ + + + + + + + + + + + + + Actions + + + + + +
+
+ + +
+ +
+
+ + +
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard0 desc + +
+ 		+
+ Last updated +
+
+
+
+ + + + + + + + + + Edit + + + + + + +
+
+
+ + +
+ +
+
+ + +
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard1 desc + +
+ 		+
+ Last updated +
+
+
+
+ + + + + + + + + + Edit + + + + + + +
+
+ +
+ +
+ +
+ + + +
+ +
+ + + : + 10 + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ + +
+ + + +
+ +
+ + +
+ +
+ +
+ +
+
+ + +
@@ -12898,1830 +11575,6 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "osdUrlStateStorage": Object { "flush": [MockFunction], @@ -15008,11 +11861,2231 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` data-test-subj="dashboardLandingPage" >
+ > + + +
+
+ +
+ +
+ +

+ Dashboards +

+ +
+ + + +
+ + + + + +
+ + +
+ + +
+ + + } + > +
+
+ + + + Listing limit exceeded + + +
+ +
+ +
+

+ + + , + "entityNamePlural": "dashboards", + "listingLimitText": + listingLimit + , + "listingLimitValue": 1, + "totalItems": 2, + } + } + > + You have 2 dashboards, but your + + listingLimit + + setting prevents the table below from displaying more than 1. You can change this setting under + + + + Advanced Settings + + + + . + +

+
+ +
+ +
+ + +
+ + + } + pagination={ + Object { + "initialPageIndex": 0, + "initialPageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + } + } + responsive={true} + search={ + Object { + "box": Object { + "incremental": true, + }, + "defaultQuery": "", + "onChange": [Function], + "toolsLeft": undefined, + } + } + selection={ + Object { + "onSelectionChange": [Function], + } + } + sorting={true} + tableLayout="fixed" + > +
+ + +
+ +
+ + + +
+
+ + + + +
+ + + + + +
+ +
+
+ + + +
+ +
+ + + +
+ + + } + onChange={[Function]} + pagination={ + Object { + "hidePerPageOptions": undefined, + "pageIndex": 0, + "pageSize": 10, + "pageSizeOptions": Array [ + 10, + 20, + 50, + ], + "totalItemCount": 2, + } + } + responsive={true} + selection={ + Object { + "onSelectionChange": [Function], + } + } + sorting={ + Object { + "allowNeutralSort": true, + "sort": undefined, + } + } + tableLayout="fixed" + > +
+
+ +
+ +
+ +
+ + +
+ +
+ +
+ + +
+ + +
+ +
+ + + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ +
+ +
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+
+ + +
+ +
+
+ + +
+
+ + + + + + + + + + + + + + Actions + + + + + +
+
+ + +
+ +
+
+ + +
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard0 desc + +
+ 		+
+ Last updated +
+
+
+
+ + + + + + + + + + Edit + + + + + + +
+
+
+ + +
+ +
+
+ + +
+
+
+ Title +
+
+ + + +
+ 		+
+ Type +
+
+ + dashboardSavedObjects + +
+ 		+
+ Description +
+
+ + dashboard1 desc + +
+ 		+
+ Last updated +
+
+
+
+ + + + + + + + + + Edit + + + + + + +
+
+ +
+ +
+ +
+ + + +
+ +
+ + + : + 10 + + } + closePopover={[Function]} + display="inlineBlock" + hasArrow={true} + isOpen={false} + ownFocus={true} + panelPaddingSize="none" + > +
+
+ + + +
+
+ +
+ + +
+ + + +
+ +
+ + +
+ +
+ +
+ +
+
+ + +
diff --git a/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap index 571e7ce2ad59..1954051c9474 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_top_nav/__snapshots__/dashboard_top_nav.test.tsx.snap @@ -788,1830 +788,6 @@ exports[`Dashboard top nav render in embed mode 1`] = ` "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -3569,1830 +1745,6 @@ exports[`Dashboard top nav render in embed mode, and force hide filter bar 1`] = "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -6350,1830 +2702,6 @@ exports[`Dashboard top nav render in embed mode, components can be forced show b "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -9131,1830 +3659,6 @@ exports[`Dashboard top nav render in full screen mode with appended URL param bu "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -11912,1830 +4616,6 @@ exports[`Dashboard top nav render in full screen mode, no componenets should be "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { @@ -14693,1830 +5573,6 @@ exports[`Dashboard top nav render with all components 1`] = ` "remove": [MockFunction], }, }, - "opensearch": Object { - "client": Object { - "asInternalUser": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": false, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": false, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asInternalUserWithLongNumeralsSupport": Client { - "bulk": [MockFunction], - "child": [MockFunction], - "clearScroll": [MockFunction], - "close": [MockFunction], - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "count": [MockFunction], - "create": [MockFunction], - "createPit": [MockFunction], - "delete": [MockFunction], - "deleteAllPits": [MockFunction], - "deleteByQuery": [MockFunction], - "deleteByQueryRethrottle": [MockFunction], - "deletePit": [MockFunction], - "deleteScript": [MockFunction], - "exists": [MockFunction], - "existsSource": [MockFunction], - "explain": [MockFunction], - "extend": [MockFunction], - "fieldCaps": [MockFunction], - "get": [MockFunction], - "getAllPits": [MockFunction], - "getScript": [MockFunction], - "getScriptContext": [MockFunction], - "getScriptLanguages": [MockFunction], - "getSource": [MockFunction], - "helpers": Helpers { - "maxRetries": 3, - Symbol(opensearch-client): [Circular], - Symbol(meta header): undefined, - }, - "index": [MockFunction], - "info": [MockFunction], - "mget": [MockFunction], - "msearch": [MockFunction], - "msearchTemplate": [MockFunction], - "mtermvectors": [MockFunction], - "name": "opensearch-js", - "ping": [MockFunction], - "putScript": [MockFunction], - "rankEval": [MockFunction], - "reindex": [MockFunction], - "reindexRethrottle": [MockFunction], - "renderSearchTemplate": [MockFunction], - "scriptsPainlessExecute": [MockFunction], - "scroll": [MockFunction], - "search": [MockFunction], - "searchShards": [MockFunction], - "searchTemplate": [MockFunction], - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "termsEnum": [MockFunction], - "termvectors": [MockFunction], - "transport": Object { - "request": [MockFunction], - }, - "update": [MockFunction], - "updateByQuery": [MockFunction], - "updateByQueryRethrottle": [MockFunction], - Symbol(configuration error): [Function], - Symbol(Cat): CatApi { - "aliases": [MockFunction], - "allocation": [MockFunction], - "cluster_manager": [MockFunction], - "count": [MockFunction], - "fielddata": [MockFunction], - "health": [MockFunction], - "help": [MockFunction], - "indices": [MockFunction], - "master": [MockFunction], - "nodeattrs": [MockFunction], - "nodes": [MockFunction], - "pendingTasks": [MockFunction], - "plugins": [MockFunction], - "recovery": [MockFunction], - "repositories": [MockFunction], - "segments": [MockFunction], - "shards": [MockFunction], - "snapshots": [MockFunction], - "tasks": [MockFunction], - "templates": [MockFunction], - "threadPool": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Cluster): ClusterApi { - "allocationExplain": [MockFunction], - "deleteComponentTemplate": [MockFunction], - "deleteVotingConfigExclusions": [MockFunction], - "existsComponentTemplate": [MockFunction], - "getComponentTemplate": [MockFunction], - "getSettings": [MockFunction], - "health": [MockFunction], - "pendingTasks": [MockFunction], - "postVotingConfigExclusions": [MockFunction], - "putComponentTemplate": [MockFunction], - "putSettings": [MockFunction], - "remoteInfo": [MockFunction], - "reroute": [MockFunction], - "state": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(DanglingIndices): DanglingIndicesApi { - "deleteDanglingIndex": [MockFunction], - "importDanglingIndex": [MockFunction], - "listDanglingIndices": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Features): FeaturesApi { - "getFeatures": [MockFunction], - "resetFeatures": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Indices): IndicesApi { - "addBlock": [MockFunction], - "analyze": [MockFunction], - "clearCache": [MockFunction], - "clone": [MockFunction], - "close": [MockFunction], - "create": [MockFunction], - "delete": [MockFunction], - "deleteAlias": [MockFunction], - "deleteIndexTemplate": [MockFunction], - "deleteTemplate": [MockFunction], - "diskUsage": [MockFunction], - "exists": [MockFunction], - "existsAlias": [MockFunction], - "existsIndexTemplate": [MockFunction], - "existsTemplate": [MockFunction], - "fieldUsageStats": [MockFunction], - "flush": [MockFunction], - "forcemerge": [MockFunction], - "get": [MockFunction], - "getAlias": [MockFunction], - "getFieldMapping": [MockFunction], - "getIndexTemplate": [MockFunction], - "getMapping": [MockFunction], - "getSettings": [MockFunction], - "getTemplate": [MockFunction], - "getUpgrade": [MockFunction], - "open": [MockFunction], - "putAlias": [MockFunction], - "putIndexTemplate": [MockFunction], - "putMapping": [MockFunction], - "putSettings": [MockFunction], - "putTemplate": [MockFunction], - "recovery": [MockFunction], - "refresh": [MockFunction], - "resolveIndex": [MockFunction], - "rollover": [MockFunction], - "segments": [MockFunction], - "shardStores": [MockFunction], - "shrink": [MockFunction], - "simulateIndexTemplate": [MockFunction], - "simulateTemplate": [MockFunction], - "split": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "updateAliases": [MockFunction], - "upgrade": [MockFunction], - "validateQuery": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Ingest): IngestApi { - "deletePipeline": [MockFunction], - "geoIpStats": [MockFunction], - "getPipeline": [MockFunction], - "processorGrok": [MockFunction], - "putPipeline": [MockFunction], - "simulate": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Nodes): NodesApi { - "clearMeteringArchive": [MockFunction], - "getMeteringInfo": [MockFunction], - "hotThreads": [MockFunction], - "info": [MockFunction], - "reloadSecureSettings": [MockFunction], - "stats": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "usage": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Shutdown): ShutdownApi { - "deleteNode": [MockFunction], - "getNode": [MockFunction], - "putNode": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(Snapshot): SnapshotApi { - "cleanupRepository": [MockFunction], - "clone": [MockFunction], - "create": [MockFunction], - "createRepository": [MockFunction], - "delete": [MockFunction], - "deleteRepository": [MockFunction], - "get": [MockFunction], - "getRepository": [MockFunction], - "repositoryAnalyze": [MockFunction], - "restore": [MockFunction], - "status": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - "verifyRepository": [MockFunction], - Symbol(configuration error): [Function], - }, - Symbol(Tasks): TasksApi { - "cancel": [MockFunction], - "get": [MockFunction], - "list": [MockFunction], - "transport": Transport { - "_isSniffing": false, - "_nextSniff": 0, - "_sniffEnabled": false, - "compression": false, - "connectionPool": ConnectionPool { - "Connection": [Function], - "_agent": null, - "_proxy": null, - "_sniffEnabled": false, - "_ssl": null, - "auth": null, - "connections": Array [ - Object { - "_openRequests": 0, - "deadCount": 0, - "headers": Object {}, - "id": "http://localhost/", - "resurrectTimeout": 0, - "roles": Object { - "data": true, - "ingest": true, - }, - "status": "alive", - "url": "http://localhost/", - }, - ], - "dead": Array [], - "emit": [Function], - "pingTimeout": 3000, - "resurrectStrategy": 1, - "resurrectTimeout": 60000, - "resurrectTimeoutCutoff": 5, - "size": 1, - }, - "context": null, - "emit": [Function], - "generateRequestId": [Function], - "headers": Object { - "user-agent": "opensearch-js/2.3.1 (linux 6.2.0-1018-azure-x64; Node.js v18.16.0)", - }, - "maxRetries": 3, - "memoryCircuitBreaker": undefined, - "name": "opensearch-js", - "nodeFilter": [Function], - "nodeSelector": [Function], - "opaqueIdPrefix": null, - "requestTimeout": 30000, - "serializer": Serializer { - Symbol(secure json parse options): Object { - "constructorAction": "error", - "enableLongNumeralSupport": true, - "protoAction": "error", - }, - }, - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "suggestCompression": false, - Symbol(compatible check): 0, - Symbol(api versioning): false, - }, - Symbol(configuration error): [Function], - }, - Symbol(opensearchjs-initial-options): Object { - "Connection": [Function], - "ConnectionPool": [Function], - "Serializer": [Function], - "Transport": [Function], - "agent": null, - "auth": null, - "compression": false, - "context": null, - "disablePrototypePoisoningProtection": false, - "enableLongNumeralSupport": true, - "enableMetaHeader": true, - "generateRequestId": null, - "headers": Object {}, - "maxRetries": 3, - "name": "opensearch-js", - "node": "http://localhost", - "nodeFilter": null, - "nodeSelector": "round-robin", - "opaqueIdPrefix": null, - "pingTimeout": 3000, - "proxy": null, - "requestTimeout": 30000, - "resurrectStrategy": "ping", - "sniffEndpoint": "_nodes/_all/http", - "sniffInterval": false, - "sniffOnConnectionFault": false, - "sniffOnStart": false, - "ssl": null, - "suggestCompression": false, - }, - Symbol(opensearchjs-extensions): Array [], - Symbol(opensearchjs-event-emitter): EventEmitter { - "_events": Object {}, - "_eventsCount": 0, - "_maxListeners": undefined, - Symbol(kCapture): false, - }, - }, - "asScoped": [MockFunction], - }, - "createClient": [MockFunction], - "legacy": Object { - "client": Object { - "asScoped": [MockFunction], - "callAsInternalUser": [MockFunction], - }, - "config$": BehaviorSubject { - "_isScalar": false, - "_value": Object {}, - "closed": false, - "hasError": false, - "isStopped": false, - "observers": Array [], - "thrownError": null, - }, - "createClient": [MockFunction], - }, - }, "opensearchDashboardsVersion": "3.0.0", "overlays": Object { "banners": Object { From 868815647d2a5ee9d5110f3325a2a8c8469fe7e5 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 29 Dec 2023 02:46:23 +0000 Subject: [PATCH 14/59] undo changes in listing snap Signed-off-by: Tianle Huang --- .../dashboard_listing.test.tsx.snap | 8203 +---------------- 1 file changed, 5 insertions(+), 8198 deletions(-) diff --git a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap index 7d428570d6c8..c9ffe147e5f8 100644 --- a/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap +++ b/src/plugins/dashboard/public/application/components/dashboard_listing/__snapshots__/dashboard_listing.test.tsx.snap @@ -1116,1481 +1116,11 @@ exports[`dashboard listing hideWriteControls 1`] = ` data-test-subj="dashboardLandingPage" >
- - -
-
- -
- -
- -

- Dashboards -

- -
- -
- - -
- - - } - pagination={ - Object { - "initialPageIndex": 0, - "initialPageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - } - } - responsive={true} - search={ - Object { - "box": Object { - "incremental": true, - }, - "defaultQuery": "", - "onChange": [Function], - "toolsLeft": undefined, - } - } - sorting={true} - tableLayout="fixed" - > -
- - -
- -
- - - -
-
- - - - -
- - - - - -
- -
-
- - - -
- -
- - - -
- - - } - onChange={[Function]} - pagination={ - Object { - "hidePerPageOptions": undefined, - "pageIndex": 0, - "pageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - "totalItemCount": 2, - } - } - responsive={true} - sorting={ - Object { - "allowNeutralSort": true, - "sort": undefined, - } - } - tableLayout="fixed" - > -
-
- -
- -
- -
- - -
- -
- - - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- -
- -
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- -
- - - - - - - -
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard0 desc - -
- 		-
- Last updated -
-
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard1 desc - -
- 		-
- Last updated -
-
-
- -
- -
- -
- - - -
- -
- - - : - 10 - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- - -
- - - -
- -
- - -
- -
- -
- -
-
- - -
+ /> @@ -3779,2151 +2309,11 @@ exports[`dashboard listing render table listing with initial filters from URL 1` data-test-subj="dashboardLandingPage" >
- - -
-
- -
- -
- -

- Dashboards -

- -
- - - -
- - - - - -
- - -
- - -
- - - } - pagination={ - Object { - "initialPageIndex": 0, - "initialPageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - } - } - responsive={true} - search={ - Object { - "box": Object { - "incremental": true, - }, - "defaultQuery": "dashboard", - "onChange": [Function], - "toolsLeft": undefined, - } - } - selection={ - Object { - "onSelectionChange": [Function], - } - } - sorting={true} - tableLayout="fixed" - > -
- - -
- -
- - - -
-
- - - - -
- - - - - -
-
- - - - - -
- -
-
- - - -
- -
- - - -
- - - } - onChange={[Function]} - pagination={ - Object { - "hidePerPageOptions": undefined, - "pageIndex": 0, - "pageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - "totalItemCount": 2, - } - } - responsive={true} - selection={ - Object { - "onSelectionChange": [Function], - } - } - sorting={ - Object { - "allowNeutralSort": true, - "sort": undefined, - } - } - tableLayout="fixed" - > -
-
- -
- -
- -
- - -
- -
- -
- - -
- - -
- -
- - - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- -
- -
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- -
-
- - -
- -
-
- - -
-
- - - - - - - - - - - - - - Actions - - - - - -
-
- - -
- -
-
- - -
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard0 desc - -
- 		-
- Last updated -
-
-
-
- - - - - - - - - - Edit - - - - - - -
-
-
- - -
- -
-
- - -
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard1 desc - -
- 		-
- Last updated -
-
-
-
- - - - - - - - - - Edit - - - - - - -
-
- -
- -
- -
- - - -
- -
- - - : - 10 - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- - -
- - - -
- -
- - -
- -
- -
- -
-
- - -
+ /> @@ -7112,274 +3502,11 @@ exports[`dashboard listing renders call to action when no dashboards exist 1`] = data-test-subj="dashboardLandingPage" >
- - -
- - - - } - body={ - -

- -

-

- - - , - } - } - /> -

- - } - iconType="dashboardApp" - title={ -

- -

- } - > -
- - - - -
- - -

- - Create your first dashboard - -

- - - - -
- - -
-

- - You can combine data views from any OpenSearch Dashboards app into one dashboard and see everything in one place. - -

-

- - - , - } - } - > - New to OpenSearch Dashboards? - - - - to take a test drive. - -

-
- - - - -
- - - - - - -
- -
- - -
+ /> @@ -8568,2111 +4695,11 @@ exports[`dashboard listing renders table rows 1`] = ` data-test-subj="dashboardLandingPage" >
- - -
-
- -
- -
- -

- Dashboards -

- -
- - - -
- - - - - -
- - -
- - -
- - - } - pagination={ - Object { - "initialPageIndex": 0, - "initialPageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - } - } - responsive={true} - search={ - Object { - "box": Object { - "incremental": true, - }, - "defaultQuery": "", - "onChange": [Function], - "toolsLeft": undefined, - } - } - selection={ - Object { - "onSelectionChange": [Function], - } - } - sorting={true} - tableLayout="fixed" - > -
- - -
- -
- - - -
-
- - - - -
- - - - - -
- -
-
- - - -
- -
- - - -
- - - } - onChange={[Function]} - pagination={ - Object { - "hidePerPageOptions": undefined, - "pageIndex": 0, - "pageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - "totalItemCount": 2, - } - } - responsive={true} - selection={ - Object { - "onSelectionChange": [Function], - } - } - sorting={ - Object { - "allowNeutralSort": true, - "sort": undefined, - } - } - tableLayout="fixed" - > -
-
- -
- -
- -
- - -
- -
- -
- - -
- - -
- -
- - - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- -
- -
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- -
-
- - -
- -
-
- - -
-
- - - - - - - - - - - - - - Actions - - - - - -
-
- - -
- -
-
- - -
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard0 desc - -
- 		-
- Last updated -
-
-
-
- - - - - - - - - - Edit - - - - - - -
-
-
- - -
- -
-
- - -
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard1 desc - -
- 		-
- Last updated -
-
-
-
- - - - - - - - - - Edit - - - - - - -
-
- -
- -
- -
- - - -
- -
- - - : - 10 - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- - -
- - - -
- -
- - -
- -
- -
- -
-
- - -
+ /> @@ -11861,2231 +5888,11 @@ exports[`dashboard listing renders warning when listingLimit is exceeded 1`] = ` data-test-subj="dashboardLandingPage" >
- - -
-
- -
- -
- -

- Dashboards -

- -
- - - -
- - - - - -
- - -
- - -
- - - } - > -
-
- - - - Listing limit exceeded - - -
- -
- -
-

- - - , - "entityNamePlural": "dashboards", - "listingLimitText": - listingLimit - , - "listingLimitValue": 1, - "totalItems": 2, - } - } - > - You have 2 dashboards, but your - - listingLimit - - setting prevents the table below from displaying more than 1. You can change this setting under - - - - Advanced Settings - - - - . - -

-
- -
- -
- - -
- - - } - pagination={ - Object { - "initialPageIndex": 0, - "initialPageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - } - } - responsive={true} - search={ - Object { - "box": Object { - "incremental": true, - }, - "defaultQuery": "", - "onChange": [Function], - "toolsLeft": undefined, - } - } - selection={ - Object { - "onSelectionChange": [Function], - } - } - sorting={true} - tableLayout="fixed" - > -
- - -
- -
- - - -
-
- - - - -
- - - - - -
- -
-
- - - -
- -
- - - -
- - - } - onChange={[Function]} - pagination={ - Object { - "hidePerPageOptions": undefined, - "pageIndex": 0, - "pageSize": 10, - "pageSizeOptions": Array [ - 10, - 20, - 50, - ], - "totalItemCount": 2, - } - } - responsive={true} - selection={ - Object { - "onSelectionChange": [Function], - } - } - sorting={ - Object { - "allowNeutralSort": true, - "sort": undefined, - } - } - tableLayout="fixed" - > -
-
- -
- -
- -
- - -
- -
- -
- - -
- - -
- -
- - - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- -
- -
- -
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- -
-
- - -
- -
-
- - -
-
- - - - - - - - - - - - - - Actions - - - - - -
-
- - -
- -
-
- - -
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard0 desc - -
- 		-
- Last updated -
-
-
-
- - - - - - - - - - Edit - - - - - - -
-
-
- - -
- -
-
- - -
-
-
- Title -
-
- - - -
- 		-
- Type -
-
- - dashboardSavedObjects - -
- 		-
- Description -
-
- - dashboard1 desc - -
- 		-
- Last updated -
-
-
-
- - - - - - - - - - Edit - - - - - - -
-
- -
- -
- -
- - - -
- -
- - - : - 10 - - } - closePopover={[Function]} - display="inlineBlock" - hasArrow={true} - isOpen={false} - ownFocus={true} - panelPaddingSize="none" - > -
-
- - - -
-
- -
- - -
- - - -
- -
- - -
- -
- -
- -
-
- - -
+ /> From d54f8e4086e7f8cc63240981ba424bd9fa53acd1 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 29 Dec 2023 03:53:07 +0000 Subject: [PATCH 15/59] improve wording Signed-off-by: Tianle Huang --- CHANGELOG.md | 2 +- src/plugins/csp_configuration_provider/README.md | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5490e9bba72c..83b3827ba731 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -75,7 +75,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [CVE-2023-26159] Bump `follow-redirects` from `1.15.2` to `1.15.4` ([#5669](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5669)) - [CVE-2023-52079] Bump `msgpackr` from `1.9.7` to `1.10.1` ([#5803](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5803)) - [CVE-2020-8203] Bump `cheerio` from `0.22.0` to `1.0.0-rc.1` to fix vulnerable `lodash` dependency ([#5797](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5797)) -- Support dynamic csp rules to mitigate clickjacking ([#5641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641)) +- Support dynamic CSP rules to mitigate clickjacking ([#5641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641)) ### 📈 Features/Enhancements diff --git a/src/plugins/csp_configuration_provider/README.md b/src/plugins/csp_configuration_provider/README.md index f9e5c0bc3700..0d9d9c35ba44 100755 --- a/src/plugins/csp_configuration_provider/README.md +++ b/src/plugins/csp_configuration_provider/README.md @@ -2,7 +2,7 @@ A OpenSearch Dashboards plugin -This plugin introduces the support of self service dynamic configuration of Content Security Policy (CSP) rules without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from a new index `.opensearch_dashboards_config` and then rewrite to CSP header. OSD users could update the content of the index with new CSP rules and will take effect immediately. +This plugin introduces the support of self service dynamic configuration of Content Security Policy (CSP) rules without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from a new index `.opensearch_dashboards_config` and then rewrite to CSP header. OSD users could update the content of the index with new CSP rules and the change will take effect immediately. It also provides an interface `CspClient` for future extensions of external CSP providers. By default, an implementation based on OpenSearch as database is used. @@ -30,11 +30,11 @@ PUT .opensearch_dashboards_config/_doc/csp.rules ``` ## External CSP Clients -While a default OpenSearch based client is implemented, OSD users can use external CSP clients by using an OSD plugin (outside OSD). +While a default OpenSearch based client is implemented, OSD users can use external CSP clients through an OSD plugin (outside OSD). Let's call this plugin `MyCspClientPlugin`. -First, this plugin will need to implement a class `MyCspClient` based on interface `CspClient` defined in the `types.ts`. +First, this plugin will need to implement a class `MyCspClient` based on interface `CspClient` defined in the `types.ts` under directory `src/plugins/csp_configuration_provider/server/types.ts`. Second, this plugin needs to declare `cspConfigurationProvider` as its dependency by adding it to `requiredPlugins` in its own `opensearch_dashboards.json`. From 9c6a8e957f1b5b5c3fb17cbfefa108af1cdc6871 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 2 Jan 2024 22:42:29 +0000 Subject: [PATCH 16/59] set client after default client is created Signed-off-by: Tianle Huang --- src/plugins/csp_configuration_provider/server/plugin.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/plugins/csp_configuration_provider/server/plugin.ts b/src/plugins/csp_configuration_provider/server/plugin.ts index 55913662ea4d..3e5b390bece6 100644 --- a/src/plugins/csp_configuration_provider/server/plugin.ts +++ b/src/plugins/csp_configuration_provider/server/plugin.ts @@ -39,7 +39,9 @@ export class CspConfigurationProviderPlugin return this.cspClient; } - return new OpenSearchCspClient(inputOpenSearchClient); + const openSearchCspClient = new OpenSearchCspClient(inputOpenSearchClient); + this.setCspClient(openSearchCspClient); + return this.cspClient; } public setup(core: CoreSetup) { From f570ecc23371f6474690d510a1b95c814f2b3ae3 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 3 Jan 2024 00:29:02 +0000 Subject: [PATCH 17/59] update return value and add a unit test Signed-off-by: Tianle Huang --- .../server/provider.test.ts | 26 +++++++++++++++++++ .../server/provider.ts | 2 +- 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/src/plugins/csp_configuration_provider/server/provider.test.ts b/src/plugins/csp_configuration_provider/server/provider.test.ts index b5077202622f..09c68115dc09 100644 --- a/src/plugins/csp_configuration_provider/server/provider.test.ts +++ b/src/plugins/csp_configuration_provider/server/provider.test.ts @@ -107,6 +107,32 @@ describe('Provider', () => { ); }); + it('returns empty when value field is missing in opensearch response', async () => { + const cspRules = "frame-ancestors 'self'"; + + opensearchClient.search.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({ + hits: { + hits: [ + { + _source: { + value_typo: cspRules, + }, + }, + ], + }, + } as SearchResponse); + }); + + const client = new OpenSearchCspClient(opensearchClient); + const getValue = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); + + expect(getValue).toBe(''); + expect(opensearchClient.search).toBeCalledWith( + getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) + ); + }); + it('returns empty string when opensearch errors happen', async () => { opensearchClient.search.mockImplementation(() => { return opensearchClientMock.createErrorTransportRequestPromise(new Error(ERROR_MESSAGE)); diff --git a/src/plugins/csp_configuration_provider/server/provider.ts b/src/plugins/csp_configuration_provider/server/provider.ts index 17001aaa5624..1a59ea80209b 100644 --- a/src/plugins/csp_configuration_provider/server/provider.ts +++ b/src/plugins/csp_configuration_provider/server/provider.ts @@ -52,7 +52,7 @@ export class OpenSearchCspClient implements CspClient { body: query, }); - value = data?.body?.hits?.hits[0]?._source?.value; + value = data?.body?.hits?.hits[0]?._source?.value || ''; } catch (e) { // eslint-disable-next-line no-console console.error( From 9e0d78d82a97ed905bb9b28d80aa2e148a842350 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Sat, 6 Jan 2024 01:11:41 +0000 Subject: [PATCH 18/59] remove unnecessary dependency Signed-off-by: Tianle Huang --- .../csp_configuration_provider/opensearch_dashboards.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plugins/csp_configuration_provider/opensearch_dashboards.json b/src/plugins/csp_configuration_provider/opensearch_dashboards.json index 52cbfdcf0bd3..0549de36132a 100644 --- a/src/plugins/csp_configuration_provider/opensearch_dashboards.json +++ b/src/plugins/csp_configuration_provider/opensearch_dashboards.json @@ -4,6 +4,6 @@ "opensearchDashboardsVersion": "opensearchDashboards", "server": true, "ui": false, - "requiredPlugins": ["navigation"], + "requiredPlugins": [], "optionalPlugins": [] -} +} \ No newline at end of file From d42ff1eee155683ed0a4b0b52ab9e43693389395 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Mon, 8 Jan 2024 22:11:51 +0000 Subject: [PATCH 19/59] make the name of the index configurable Signed-off-by: Tianle Huang --- .../server/csp_handlers.test.ts | 32 ++++++++++++++++--- .../server/csp_handlers.ts | 6 ++-- .../server/plugin.ts | 15 +++++++-- 3 files changed, 43 insertions(+), 10 deletions(-) diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts index 7dcaa0abda3c..6feb35574842 100644 --- a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts +++ b/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts @@ -30,6 +30,8 @@ const forgeRequest = ({ }); }; +const DEFAULT_DYNAMIC_CONFIG_INDEX = '.opensearch_dashboards_config'; + describe('CSP handlers', () => { let toolkit: ReturnType; @@ -49,7 +51,11 @@ describe('CSP handlers', () => { const getCspClient = jest.fn().mockReturnValue(cspClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const handler = createCspRulesPreResponseHandler( + coreSetup, + DEFAULT_DYNAMIC_CONFIG_INDEX, + getCspClient + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -81,7 +87,11 @@ describe('CSP handlers', () => { const getCspClient = jest.fn().mockReturnValue(cspClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const handler = createCspRulesPreResponseHandler( + coreSetup, + DEFAULT_DYNAMIC_CONFIG_INDEX, + getCspClient + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -107,7 +117,11 @@ describe('CSP handlers', () => { const getCspClient = jest.fn().mockReturnValue(cspClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const handler = createCspRulesPreResponseHandler( + coreSetup, + DEFAULT_DYNAMIC_CONFIG_INDEX, + getCspClient + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -133,7 +147,11 @@ describe('CSP handlers', () => { const getCspClient = jest.fn().mockReturnValue(cspClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const handler = createCspRulesPreResponseHandler( + coreSetup, + DEFAULT_DYNAMIC_CONFIG_INDEX, + getCspClient + ); const cssSecFetchDest = 'css'; const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': cssSecFetchDest } }); @@ -161,7 +179,11 @@ describe('CSP handlers', () => { const getCspClient = jest.fn().mockReturnValue(cspClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getCspClient); + const handler = createCspRulesPreResponseHandler( + coreSetup, + DEFAULT_DYNAMIC_CONFIG_INDEX, + getCspClient + ); const request = forgeRequest({ method: 'get', headers: {} }); diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.ts index 5a2ff8158e47..378a38523ec8 100644 --- a/src/plugins/csp_configuration_provider/server/csp_handlers.ts +++ b/src/plugins/csp_configuration_provider/server/csp_handlers.ts @@ -6,11 +6,11 @@ import { CoreSetup, OnPreResponseHandler, OpenSearchClient } from '../../../core/server'; import { CspClient } from './types'; -const OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME = '.opensearch_dashboards_config'; const OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME = 'csp.rules'; export function createCspRulesPreResponseHandler( core: CoreSetup, + dynamicConfigIndex: string, getCspClient: (inputOpenSearchClient: OpenSearchClient) => CspClient ): OnPreResponseHandler { return async (request, response, toolkit) => { @@ -26,14 +26,14 @@ export function createCspRulesPreResponseHandler( const myClient = getCspClient(coreStart.opensearch.client.asInternalUser); - const existsValue = await myClient.exists(OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME); + const existsValue = await myClient.exists(dynamicConfigIndex); if (!existsValue) { return toolkit.next({}); } const cspRules = await myClient.get( - OPENSEARCH_DASHBOARDS_CONFIG_INDEX_NAME, + dynamicConfigIndex, OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME ); diff --git a/src/plugins/csp_configuration_provider/server/plugin.ts b/src/plugins/csp_configuration_provider/server/plugin.ts index 3e5b390bece6..e483fb219a42 100644 --- a/src/plugins/csp_configuration_provider/server/plugin.ts +++ b/src/plugins/csp_configuration_provider/server/plugin.ts @@ -3,6 +3,8 @@ * SPDX-License-Identifier: Apache-2.0 */ +import { Observable } from 'rxjs'; +import { first } from 'rxjs/operators'; import { CoreSetup, CoreStart, @@ -10,6 +12,7 @@ import { OpenSearchClient, Plugin, PluginInitializerContext, + SharedGlobalConfig, } from '../../../core/server'; import { createCspRulesPreResponseHandler } from './csp_handlers'; @@ -24,10 +27,12 @@ import { export class CspConfigurationProviderPlugin implements Plugin { private readonly logger: Logger; + private readonly config$: Observable; private cspClient: CspClient | undefined; constructor(initializerContext: PluginInitializerContext) { this.logger = initializerContext.logger.get(); + this.config$ = initializerContext.config.legacy.globalConfig$; } private setCspClient(inputCspClient: CspClient) { @@ -44,15 +49,21 @@ export class CspConfigurationProviderPlugin return this.cspClient; } - public setup(core: CoreSetup) { + public async setup(core: CoreSetup) { this.logger.debug('CspConfigurationProvider: Setup'); const router = core.http.createRouter(); // Register server side APIs defineRoutes(router); + const config = await this.config$.pipe(first()).toPromise(); + core.http.registerOnPreResponse( - createCspRulesPreResponseHandler(core, this.getCspClient.bind(this)) + createCspRulesPreResponseHandler( + core, + config.opensearchDashboards.dynamic_config_index, + this.getCspClient.bind(this) + ) ); return { From 29211c99e26b765f63bacaa424cc9314b961ede3 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 18 Jan 2024 04:07:32 +0000 Subject: [PATCH 20/59] expose APIs and update file structures Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 + .../.eslintrc.js | 0 .../configuration_provider/.i18nrc.json | 9 + src/plugins/configuration_provider/README.md | 82 ++++++ .../configuration_provider/common/index.ts | 7 + .../opensearch_dashboards.json | 2 +- .../server/csp_handlers.test.ts | 130 +++++---- .../server/csp_handlers.ts | 55 ++++ .../server/index.ts | 6 +- .../configuration_provider/server/plugin.ts | 85 ++++++ .../server/provider.test.ts | 269 ++++++++++++++++++ .../configuration_provider/server/provider.ts | 97 +++++++ .../server/routes/index.test.ts | 47 +++ .../server/routes/index.ts | 139 +++++++++ .../configuration_provider/server/types.ts | 19 ++ .../csp_configuration_provider/.i18nrc.json | 7 - .../csp_configuration_provider/README.md | 64 ----- .../common/index.ts | 7 - .../server/csp_handlers.ts | 50 ---- .../server/plugin.ts | 80 ------ .../server/provider.test.ts | 165 ----------- .../server/provider.ts | 65 ----- .../server/routes/index.ts | 8 - .../server/types.ts | 15 - 24 files changed, 887 insertions(+), 522 deletions(-) rename src/plugins/{csp_configuration_provider => configuration_provider}/.eslintrc.js (100%) create mode 100644 src/plugins/configuration_provider/.i18nrc.json create mode 100755 src/plugins/configuration_provider/README.md create mode 100644 src/plugins/configuration_provider/common/index.ts rename src/plugins/{csp_configuration_provider => configuration_provider}/opensearch_dashboards.json (82%) rename src/plugins/{csp_configuration_provider => configuration_provider}/server/csp_handlers.test.ts (51%) create mode 100644 src/plugins/configuration_provider/server/csp_handlers.ts rename src/plugins/{csp_configuration_provider => configuration_provider}/server/index.ts (60%) create mode 100644 src/plugins/configuration_provider/server/plugin.ts create mode 100644 src/plugins/configuration_provider/server/provider.test.ts create mode 100644 src/plugins/configuration_provider/server/provider.ts create mode 100644 src/plugins/configuration_provider/server/routes/index.test.ts create mode 100644 src/plugins/configuration_provider/server/routes/index.ts create mode 100644 src/plugins/configuration_provider/server/types.ts delete mode 100644 src/plugins/csp_configuration_provider/.i18nrc.json delete mode 100755 src/plugins/csp_configuration_provider/README.md delete mode 100644 src/plugins/csp_configuration_provider/common/index.ts delete mode 100644 src/plugins/csp_configuration_provider/server/csp_handlers.ts delete mode 100644 src/plugins/csp_configuration_provider/server/plugin.ts delete mode 100644 src/plugins/csp_configuration_provider/server/provider.test.ts delete mode 100644 src/plugins/csp_configuration_provider/server/provider.ts delete mode 100644 src/plugins/csp_configuration_provider/server/routes/index.ts delete mode 100644 src/plugins/csp_configuration_provider/server/types.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 83b3827ba731..ae434a6c16d0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) ## [Unreleased] ### 💥 Breaking Changes +- Support dynamic CSP rules to mitigate clickjacking ([#5641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641)) ### Deprecations diff --git a/src/plugins/csp_configuration_provider/.eslintrc.js b/src/plugins/configuration_provider/.eslintrc.js similarity index 100% rename from src/plugins/csp_configuration_provider/.eslintrc.js rename to src/plugins/configuration_provider/.eslintrc.js diff --git a/src/plugins/configuration_provider/.i18nrc.json b/src/plugins/configuration_provider/.i18nrc.json new file mode 100644 index 000000000000..ef54ab11b215 --- /dev/null +++ b/src/plugins/configuration_provider/.i18nrc.json @@ -0,0 +1,9 @@ +{ + "prefix": "configurationProvider", + "paths": { + "configurationProvider": "." + }, + "translations": [ + "translations/ja-JP.json" + ] +} \ No newline at end of file diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md new file mode 100755 index 000000000000..fef7519953b1 --- /dev/null +++ b/src/plugins/configuration_provider/README.md @@ -0,0 +1,82 @@ +# ConfigurationProvider + +A OpenSearch Dashboards plugin + +This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.dynamic_config_index` in OSD YAML file `opensearch_dashboards.yml`. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. + +The first use case onboarding to this new index is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from the new index and then rewrite to CSP header. The plugin exposes query and update APIs for OSD users to use against CSP rules. Currently there is no new OSD pages for ease of user interactions with the APIs. Users are able to call the API endpoint directly, e.g through CURL. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. + +--- + +## Configuration + +By default, the new index does not exist. For OSD users who do not need customized CSP rules, there is no need to create this index. The system will then use whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. + +Below is the current default value. + +``` +"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'" +``` +(Note that `frame-ancestors 'self'` is used to only allow self embedding and prevent clickjacking by default.) + +For OSD users who want to make changes, e.g allow this site `https://example-site.org` to embed OSD pages, they can update CSP rules through CURL. +(Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) + +``` +curl 'http://localhost:5601/api/configuration_provider/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' https://example-site.org"}' + +``` + +Below is the CURL command to delete CSP rules. + +``` +curl 'http://localhost:5601/api/configuration_provider/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' + +``` + +Below is the CURL command to check if CSP rules exist in the new index. + +``` +curl 'http://localhost:5601/api/configuration_provider/existsCspRules' +``` + +Below is the CURL command to get the CSP rules from the new index. + +``` +curl 'http://localhost:5601/api/configuration_provider/getCspRules' + +``` + +## External Configuration Providers +While a default OpenSearch based client is implemented, OSD users can use external configuration clients through an OSD plugin (outside OSD). + +Let's call this plugin `MyConfigurationClientPlugin`. + +First, this plugin will need to implement a class `MyConfigurationClient` based on interface `ConfigurationClient` defined in the `types.ts` under directory `src/plugins/configuration_provider/server/types.ts`. + +Second, this plugin needs to declare `configurationProvider` as its dependency by adding it to `requiredPlugins` in its own `opensearch_dashboards.json`. + +Third, the plugin will import the type `ConfigurationProviderPluginSetup` from the corresponding `types.ts` and add to its own setup input. Below is the skeleton of the class `MyConfigurationClientPlugin`. + +``` +// MyConfigurationClientPlugin + public setup(core: CoreSetup, { configurationProviderPluginSetup }: ConfigurationProviderPluginSetup) { + + ... + // The function createClient provides an instance of ConfigurationClient which + // could have a underlying DynamoDB or Postgres implementation. + const myConfigurationClient: ConfigurationClient = this.createClient(); + + configurationProviderPluginSetup.setConfigurationClient(myConfigurationClient); + ... + return {}; + } + +``` + +--- +## Development + +See the [OpenSearch Dashboards contributing +guide](https://github.com/opensearch-project/OpenSearch-Dashboards/blob/main/CONTRIBUTING.md) for instructions +setting up your development environment. diff --git a/src/plugins/configuration_provider/common/index.ts b/src/plugins/configuration_provider/common/index.ts new file mode 100644 index 000000000000..e58a79887133 --- /dev/null +++ b/src/plugins/configuration_provider/common/index.ts @@ -0,0 +1,7 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +export const PLUGIN_ID = 'configurationProvider'; +export const PLUGIN_NAME = 'ConfigurationProvider'; diff --git a/src/plugins/csp_configuration_provider/opensearch_dashboards.json b/src/plugins/configuration_provider/opensearch_dashboards.json similarity index 82% rename from src/plugins/csp_configuration_provider/opensearch_dashboards.json rename to src/plugins/configuration_provider/opensearch_dashboards.json index 0549de36132a..f971ed07cac0 100644 --- a/src/plugins/csp_configuration_provider/opensearch_dashboards.json +++ b/src/plugins/configuration_provider/opensearch_dashboards.json @@ -1,5 +1,5 @@ { - "id": "cspConfigurationProvider", + "id": "configurationProvider", "version": "1.0.0", "opensearchDashboardsVersion": "opensearchDashboards", "server": true, diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts b/src/plugins/configuration_provider/server/csp_handlers.test.ts similarity index 51% rename from src/plugins/csp_configuration_provider/server/csp_handlers.test.ts rename to src/plugins/configuration_provider/server/csp_handlers.test.ts index 6feb35574842..24dd5f668460 100644 --- a/src/plugins/csp_configuration_provider/server/csp_handlers.test.ts +++ b/src/plugins/configuration_provider/server/csp_handlers.test.ts @@ -10,6 +10,9 @@ import { } from '../../../core/server/http/router/request'; import { coreMock, httpServerMock } from '../../../core/server/mocks'; import { createCspRulesPreResponseHandler } from './csp_handlers'; +import { MockedLogger, loggerMock } from '@osd/logging/target/mocks'; + +const ERROR_MESSAGE = 'Service unavailable'; const forgeRequest = ({ headers = {}, @@ -30,32 +33,28 @@ const forgeRequest = ({ }); }; -const DEFAULT_DYNAMIC_CONFIG_INDEX = '.opensearch_dashboards_config'; - describe('CSP handlers', () => { let toolkit: ReturnType; + let logger: MockedLogger; beforeEach(() => { jest.resetAllMocks(); toolkit = httpServerMock.createToolkit(); + logger = loggerMock.create(); }); it('adds the CSP headers provided by the client', async () => { const coreSetup = coreMock.createSetup(); const cspRules = "frame-ancestors 'self'"; - const cspClient = { - exists: jest.fn().mockReturnValue(true), - get: jest.fn().mockReturnValue(cspRules), + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(true), + getCspRules: jest.fn().mockReturnValue(cspRules), }; - const getCspClient = jest.fn().mockReturnValue(cspClient); + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler( - coreSetup, - DEFAULT_DYNAMIC_CONFIG_INDEX, - getCspClient - ); + const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -72,26 +71,22 @@ describe('CSP handlers', () => { }, }); - expect(cspClient.exists).toBeCalledTimes(1); - expect(cspClient.get).toBeCalledTimes(1); + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).toBeCalledTimes(1); }); it('do not add CSP headers when the client returns empty', async () => { const coreSetup = coreMock.createSetup(); const emptyCspRules = ''; - const cspClient = { - exists: jest.fn().mockReturnValue(true), - get: jest.fn().mockReturnValue(emptyCspRules), + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(true), + getCspRules: jest.fn().mockReturnValue(emptyCspRules), }; - const getCspClient = jest.fn().mockReturnValue(cspClient); + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler( - coreSetup, - DEFAULT_DYNAMIC_CONFIG_INDEX, - getCspClient - ); + const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -103,25 +98,21 @@ describe('CSP handlers', () => { expect(toolkit.next).toHaveBeenCalledTimes(1); expect(toolkit.next).toHaveBeenCalledWith({}); - expect(cspClient.exists).toBeCalledTimes(1); - expect(cspClient.get).toBeCalledTimes(1); + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).toBeCalledTimes(1); }); it('do not add CSP headers when the configuration does not exist', async () => { const coreSetup = coreMock.createSetup(); - const cspClient = { - exists: jest.fn().mockReturnValue(false), - get: jest.fn(), + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(false), + getCspRules: jest.fn(), }; - const getCspClient = jest.fn().mockReturnValue(cspClient); + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler( - coreSetup, - DEFAULT_DYNAMIC_CONFIG_INDEX, - getCspClient - ); + const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -133,25 +124,21 @@ describe('CSP handlers', () => { expect(toolkit.next).toBeCalledTimes(1); expect(toolkit.next).toBeCalledWith({}); - expect(cspClient.exists).toBeCalledTimes(1); - expect(cspClient.get).toBeCalledTimes(0); + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).toBeCalledTimes(0); }); it('do not add CSP headers when request dest exists and shall skip', async () => { const coreSetup = coreMock.createSetup(); - const cspClient = { - exists: jest.fn(), - get: jest.fn(), + const configurationClient = { + existsCspRules: jest.fn(), + getCspRules: jest.fn(), }; - const getCspClient = jest.fn().mockReturnValue(cspClient); + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler( - coreSetup, - DEFAULT_DYNAMIC_CONFIG_INDEX, - getCspClient - ); + const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); const cssSecFetchDest = 'css'; const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': cssSecFetchDest } }); @@ -165,25 +152,21 @@ describe('CSP handlers', () => { expect(toolkit.next).toBeCalledTimes(1); expect(toolkit.next).toBeCalledWith({}); - expect(cspClient.exists).toBeCalledTimes(0); - expect(cspClient.get).toBeCalledTimes(0); + expect(configurationClient.existsCspRules).toBeCalledTimes(0); + expect(configurationClient.getCspRules).toBeCalledTimes(0); }); it('do not add CSP headers when request dest does not exist', async () => { const coreSetup = coreMock.createSetup(); - const cspClient = { - exists: jest.fn(), - get: jest.fn(), + const configurationClient = { + existsCspRules: jest.fn(), + getCspRules: jest.fn(), }; - const getCspClient = jest.fn().mockReturnValue(cspClient); + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler( - coreSetup, - DEFAULT_DYNAMIC_CONFIG_INDEX, - getCspClient - ); + const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); const request = forgeRequest({ method: 'get', headers: {} }); @@ -196,7 +179,40 @@ describe('CSP handlers', () => { expect(toolkit.next).toBeCalledTimes(1); expect(toolkit.next).toBeCalledWith({}); - expect(cspClient.exists).toBeCalledTimes(0); - expect(cspClient.get).toBeCalledTimes(0); + expect(configurationClient.existsCspRules).toBeCalledTimes(0); + expect(configurationClient.getCspRules).toBeCalledTimes(0); + }); + + it('do not the CSP headers when error happens', async () => { + const coreSetup = coreMock.createSetup(); + const error = new Error(ERROR_MESSAGE); + + const configurationClient = { + existsCspRules: jest.fn().mockImplementation(() => { + throw error; + }), + getCspRules: jest.fn(), + }; + + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); + + const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toHaveBeenCalledTimes(1); + expect(toolkit.next).toBeCalledWith({}); + + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).not.toBeCalled(); + + expect(logger.error).toBeCalledWith( + `Failure happened in CSP rules pre response handler due to ${error}` + ); }); }); diff --git a/src/plugins/configuration_provider/server/csp_handlers.ts b/src/plugins/configuration_provider/server/csp_handlers.ts new file mode 100644 index 000000000000..916dfebb8172 --- /dev/null +++ b/src/plugins/configuration_provider/server/csp_handlers.ts @@ -0,0 +1,55 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { + CoreSetup, + IScopedClusterClient, + Logger, + OnPreResponseHandler, +} from '../../../core/server'; +import { ConfigurationClient } from './types'; + +export function createCspRulesPreResponseHandler( + core: CoreSetup, + getConfigurationClient: (inputOpenSearchClient: IScopedClusterClient) => ConfigurationClient, + logger: Logger +): OnPreResponseHandler { + return async (request, response, toolkit) => { + try { + const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; + + const currentDest = request.headers['sec-fetch-dest']; + + if (!shouldCheckDest.includes(currentDest)) { + return toolkit.next({}); + } + + const [coreStart] = await core.getStartServices(); + + const myClient = getConfigurationClient(coreStart.opensearch.client.asScoped(request)); + + const existsValue = await myClient.existsCspRules(); + + if (!existsValue) { + return toolkit.next({}); + } + + const cspRules = await myClient.getCspRules(); + + if (!cspRules) { + return toolkit.next({}); + } + + const additionalHeaders = { + 'content-security-policy': cspRules, + }; + + return toolkit.next({ headers: additionalHeaders }); + } catch (e) { + logger.error(`Failure happened in CSP rules pre response handler due to ${e}`); + return toolkit.next({}); + } + }; +} diff --git a/src/plugins/csp_configuration_provider/server/index.ts b/src/plugins/configuration_provider/server/index.ts similarity index 60% rename from src/plugins/csp_configuration_provider/server/index.ts rename to src/plugins/configuration_provider/server/index.ts index 0302e51e9fea..d770a56b9544 100644 --- a/src/plugins/csp_configuration_provider/server/index.ts +++ b/src/plugins/configuration_provider/server/index.ts @@ -4,13 +4,13 @@ */ import { PluginInitializerContext } from '../../../core/server'; -import { CspConfigurationProviderPlugin } from './plugin'; +import { ConfigurationProviderPlugin } from './plugin'; // This exports static code and TypeScript types, // as well as, OpenSearch Dashboards Platform `plugin()` initializer. export function plugin(initializerContext: PluginInitializerContext) { - return new CspConfigurationProviderPlugin(initializerContext); + return new ConfigurationProviderPlugin(initializerContext); } -export { CspConfigurationProviderPluginSetup, CspConfigurationProviderPluginStart } from './types'; +export { ConfigurationProviderPluginSetup, ConfigurationProviderPluginStart } from './types'; diff --git a/src/plugins/configuration_provider/server/plugin.ts b/src/plugins/configuration_provider/server/plugin.ts new file mode 100644 index 000000000000..87f29a560572 --- /dev/null +++ b/src/plugins/configuration_provider/server/plugin.ts @@ -0,0 +1,85 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { Observable } from 'rxjs'; +import { first } from 'rxjs/operators'; +import { + CoreSetup, + CoreStart, + IScopedClusterClient, + Logger, + Plugin, + PluginInitializerContext, + SharedGlobalConfig, +} from '../../../core/server'; + +import { createCspRulesPreResponseHandler } from './csp_handlers'; +import { OpenSearchConfigurationClient } from './provider'; +import { defineRoutes } from './routes'; +import { + ConfigurationClient, + ConfigurationProviderPluginSetup, + ConfigurationProviderPluginStart, +} from './types'; + +export class ConfigurationProviderPlugin + implements Plugin { + private readonly logger: Logger; + private readonly config$: Observable; + private configurationClient: ConfigurationClient; + private configurationIndexName: string; + + constructor(initializerContext: PluginInitializerContext) { + this.logger = initializerContext.logger.get(); + this.config$ = initializerContext.config.legacy.globalConfig$; + this.configurationIndexName = ''; + } + + private setConfigurationClient(inputConfigurationClient: ConfigurationClient) { + this.configurationClient = inputConfigurationClient; + } + + private getConfigurationClient(inputOpenSearchClient: IScopedClusterClient) { + if (this.configurationClient) { + return this.configurationClient; + } + + const openSearchConfigurationClient = new OpenSearchConfigurationClient( + inputOpenSearchClient, + this.configurationIndexName, + this.logger + ); + + this.setConfigurationClient(openSearchConfigurationClient); + return this.configurationClient; + } + + public async setup(core: CoreSetup) { + this.logger.debug('ConfigurationProvider: Setup'); + const router = core.http.createRouter(); + + // Register server side APIs + defineRoutes(router, this.getConfigurationClient.bind(this), this.logger); + + const config = await this.config$.pipe(first()).toPromise(); + + this.configurationIndexName = config.opensearchDashboards.dynamic_config_index; + + core.http.registerOnPreResponse( + createCspRulesPreResponseHandler(core, this.getConfigurationClient.bind(this), this.logger) + ); + + return { + setConfigurationClient: this.setConfigurationClient.bind(this), + }; + } + + public start(core: CoreStart) { + this.logger.debug('ConfigurationProvider: Started'); + return {}; + } + + public stop() {} +} diff --git a/src/plugins/configuration_provider/server/provider.test.ts b/src/plugins/configuration_provider/server/provider.test.ts new file mode 100644 index 000000000000..4d0e6e29db99 --- /dev/null +++ b/src/plugins/configuration_provider/server/provider.test.ts @@ -0,0 +1,269 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { + ScopedClusterClientMock, + opensearchClientMock, +} from '../../../core/server/opensearch/client/mocks'; +import { OpenSearchConfigurationClient } from './provider'; +import { MockedLogger, loggerMock } from '@osd/logging/target/mocks'; +import { GetResponse } from 'src/core/server'; + +const INDEX_NAME = 'test_index'; +const INDEX_DOCUMENT_NAME = 'csp.rules'; +const ERROR_MESSAGE = 'Service unavailable'; + +describe('OpenSearchConfigurationClient', () => { + let opensearchClient: ScopedClusterClientMock; + let logger: MockedLogger; + + beforeEach(() => { + jest.resetAllMocks(); + opensearchClient = opensearchClientMock.createScopedClusterClient(); + logger = loggerMock.create(); + }); + + afterEach(() => {}); + + describe('existsCspRules', () => { + it('returns true if the target index does exists', async () => { + const indexExists = true; + opensearchClient.asInternalUser.exists.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const value = await client.existsCspRules(); + + expect(value).toBeTruthy(); + + expect(opensearchClient.asInternalUser.exists).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('returns false if the target index does not exists', async () => { + const indexExists = false; + opensearchClient.asInternalUser.exists.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const existsValue = await client.existsCspRules(); + + expect(existsValue).toBeFalsy(); + + expect(opensearchClient.asInternalUser.exists).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('throws error if opensearch errors happen', async () => { + const error = new Error(ERROR_MESSAGE); + + opensearchClient.asInternalUser.exists.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(error); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + + await expect(client.existsCspRules()).rejects.toThrowError(ERROR_MESSAGE); + + expect(opensearchClient.asInternalUser.exists).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).toBeCalledWith(`Failed to call cspRulesExists due to error ${error}`); + }); + }); + + describe('getCspRules', () => { + it('returns the csp rules from the index', async () => { + const cspRules = "frame-ancestors 'self'"; + + opensearchClient.asInternalUser.get.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({ + _source: { + value: cspRules, + }, + } as GetResponse); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const getValue = await client.getCspRules(); + + expect(getValue).toBe(cspRules); + + expect(opensearchClient.asInternalUser.get).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('throws error when opensearch response is malformed', async () => { + opensearchClient.asInternalUser.get.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({ + _index: INDEX_NAME, + } as GetResponse); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + + await expect(client.getCspRules()).rejects.toThrowError(); + + expect(opensearchClient.asInternalUser.get).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).toBeCalledWith( + "Failed to call getCspRules due to error TypeError: Cannot read properties of undefined (reading 'value')" + ); + }); + + it('returns empty when value field is missing in opensearch response', async () => { + const cspRules = "frame-ancestors 'self'"; + + opensearchClient.asInternalUser.get.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({ + _source: { + value_typo: cspRules, + }, + } as GetResponse); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const getValue = await client.getCspRules(); + + expect(getValue).toBe(''); + + expect(opensearchClient.asInternalUser.get).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('throws error when opensearch errors happen', async () => { + const error = new Error(ERROR_MESSAGE); + + opensearchClient.asInternalUser.get.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(error); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + + await expect(client.getCspRules()).rejects.toThrowError(ERROR_MESSAGE); + + expect(opensearchClient.asInternalUser.get).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).toBeCalledWith(`Failed to call getCspRules due to error ${error}`); + }); + }); + + describe('updateCspRules', () => { + it('runs updated value when opensearch successfully updates', async () => { + const cspRules = "frame-ancestors 'self'"; + + opensearchClient.asCurrentUser.index.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({}); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + + const updated = await client.updateCspRules(cspRules); + + expect(updated).toBe(cspRules); + + expect(opensearchClient.asCurrentUser.index).toBeCalledWith( + getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, cspRules) + ); + + expect(logger.error).not.toBeCalled(); + }); + + it('throws exception when opensearch throws exception', async () => { + const cspRules = "frame-ancestors 'self'"; + const error = new Error(ERROR_MESSAGE); + opensearchClient.asCurrentUser.index.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(error); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + + await expect(client.updateCspRules(cspRules)).rejects.toThrowError(ERROR_MESSAGE); + + expect(opensearchClient.asCurrentUser.index).toBeCalledWith( + getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, cspRules) + ); + + expect(logger.error).toBeCalledWith( + `Failed to call updateCspRules with cspRules ${cspRules} due to error ${error}` + ); + }); + }); + + describe('deleteCspRules', () => { + it('return deleted document ID when deletion succeeds', async () => { + opensearchClient.asCurrentUser.delete.mockImplementation(() => { + return opensearchClientMock.createSuccessTransportRequestPromise({}); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const deleted = await client.deleteCspRules(); + + expect(deleted).toBe(INDEX_DOCUMENT_NAME); + + expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('throws exception when opensearch throws exception', async () => { + const error = new Error(ERROR_MESSAGE); + + opensearchClient.asCurrentUser.delete.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(error); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + + await expect(client.deleteCspRules()).rejects.toThrowError(ERROR_MESSAGE); + + expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).toBeCalledWith(`Failed to call deleteCspRules due to error ${error}`); + }); + }); +}); + +function getIndexInput(indexName: string, documentName: string, cspRules: string) { + return { + index: indexName, + id: documentName, + body: { + value: cspRules, + }, + }; +} diff --git a/src/plugins/configuration_provider/server/provider.ts b/src/plugins/configuration_provider/server/provider.ts new file mode 100644 index 000000000000..f2a6573db03b --- /dev/null +++ b/src/plugins/configuration_provider/server/provider.ts @@ -0,0 +1,97 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { IScopedClusterClient, Logger } from '../../../../src/core/server'; + +import { ConfigurationClient } from './types'; + +const CSP_RULES_DOC_ID = 'csp.rules'; + +export class OpenSearchConfigurationClient implements ConfigurationClient { + private client: IScopedClusterClient; + private configurationIndexName: string; + private readonly logger: Logger; + + constructor( + inputOpenSearchClient: IScopedClusterClient, + inputConfigurationIndexName: string, + inputLogger: Logger + ) { + this.client = inputOpenSearchClient; + this.configurationIndexName = inputConfigurationIndexName; + this.logger = inputLogger; + } + + async existsCspRules(): Promise { + try { + const exists = await this.client.asInternalUser.exists({ + index: this.configurationIndexName, + id: CSP_RULES_DOC_ID, + }); + + return exists.body; + } catch (e) { + const errorMessage = `Failed to call cspRulesExists due to error ${e}`; + + this.logger.error(errorMessage); + + throw e; + } + } + + async getCspRules(): Promise { + try { + const data = await this.client.asInternalUser.get({ + index: this.configurationIndexName, + id: CSP_RULES_DOC_ID, + }); + + return data.body._source.value || ''; + } catch (e) { + const errorMessage = `Failed to call getCspRules due to error ${e}`; + + this.logger.error(errorMessage); + + throw e; + } + } + + async updateCspRules(cspRules: string): Promise { + try { + await this.client.asCurrentUser.index({ + index: this.configurationIndexName, + id: CSP_RULES_DOC_ID, + body: { + value: cspRules, + }, + }); + + return cspRules; + } catch (e) { + const errorMessage = `Failed to call updateCspRules with cspRules ${cspRules} due to error ${e}`; + + this.logger.error(errorMessage); + + throw e; + } + } + + async deleteCspRules(): Promise { + try { + await this.client.asCurrentUser.delete({ + index: this.configurationIndexName, + id: CSP_RULES_DOC_ID, + }); + + return CSP_RULES_DOC_ID; + } catch (e) { + const errorMessage = `Failed to call deleteCspRules due to error ${e}`; + + this.logger.error(errorMessage); + + throw e; + } + } +} diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts new file mode 100644 index 000000000000..e19586b135ee --- /dev/null +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -0,0 +1,47 @@ +import { defineRoutes } from '.'; +import { loggerMock } from '@osd/logging/target/mocks'; +import { httpServiceMock } from '../../../../core/server/mocks'; + +describe('index ts', () => { + it('routes', () => { + const router = httpServiceMock.createRouter(); + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(true), + getCspRules: jest.fn().mockReturnValue(''), + }; + + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); + + const logger = loggerMock.create(); + + defineRoutes(router, getConfigurationClient, logger); + + expect(router.get).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/existsCspRules', + }), + expect.any(Function) + ); + + expect(router.get).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/getCspRules', + }), + expect.any(Function) + ); + + expect(router.post).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/updateCspRules', + }), + expect.any(Function) + ); + + expect(router.post).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/deleteCspRules', + }), + expect.any(Function) + ); + }); +}); diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts new file mode 100644 index 000000000000..5f497714e0e9 --- /dev/null +++ b/src/plugins/configuration_provider/server/routes/index.ts @@ -0,0 +1,139 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { schema } from '@osd/config-schema'; +import { + IRouter, + IScopedClusterClient, + Logger, + OpenSearchDashboardsResponseFactory, +} from '../../../../core/server'; +import { ConfigurationClient } from '../types'; + +export function defineRoutes( + router: IRouter, + getConfigurationClient: (inputOpenSearchClient: IScopedClusterClient) => ConfigurationClient, + logger: Logger +) { + router.get( + { + path: '/api/configuration_provider/existsCspRules', + validate: false, + // validate: { + // params: schema.object({ + // configurationName: schema.string(), + // }), + // }, + }, + async (context, request, response) => { + const client = getConfigurationClient(context.core.opensearch.client); + // const configurationName = request.params.configurationName; + + try { + const result = await client.existsCspRules(); + return response.ok({ + body: { + exists: result, + }, + }); + } catch (e) { + return errorResponse(response, e); + } + } + ); + + router.get( + { + path: '/api/configuration_provider/getCspRules', + validate: false, + // validate: { + // params: schema.object({ + // configurationName: schema.string(), + // cspRulesName: schema.string(), + // }), + // }, + }, + async (context, request, response) => { + const client = getConfigurationClient(context.core.opensearch.client); + // const configurationName = request.params.configurationName; + // const cspRulesName = request.params.cspRulesName; + + try { + const result = await client.getCspRules(); + + return response.ok({ + body: { + cspRules: result, + }, + }); + } catch (e) { + return errorResponse(response, e); + } + } + ); + + router.post( + { + path: '/api/configuration_provider/updateCspRules', + validate: { + body: schema.object({ + value: schema.string(), + }), + }, + }, + async (context, request, response) => { + const inputCspRules = request.body.value.trim(); + + if (!inputCspRules) { + return errorResponse(response, new Error('Cannot update CSP rules to emtpy!')); + } + + const client = getConfigurationClient(context.core.opensearch.client); + + try { + const updatedRules = await client.updateCspRules(inputCspRules); + + return response.ok({ + body: { + updatedRules, + }, + }); + } catch (e) { + return errorResponse(response, e); + } + } + ); + + router.post( + { + path: '/api/configuration_provider/deleteCspRules', + validate: false, + }, + async (context, request, response) => { + const client = getConfigurationClient(context.core.opensearch.client); + + try { + const deletedCspRulesName = await client.deleteCspRules(); + + return response.ok({ + body: { + deletedCspRulesName, + }, + }); + } catch (e) { + return errorResponse(response, e); + } + } + ); + + function errorResponse(response: OpenSearchDashboardsResponseFactory, error: any) { + logger.info('Error from esClient call: ' + JSON.stringify(error)); + + return response.custom({ + statusCode: error?.statusCode || 500, + body: error, + }); + } +} diff --git a/src/plugins/configuration_provider/server/types.ts b/src/plugins/configuration_provider/server/types.ts new file mode 100644 index 000000000000..57e456ce3777 --- /dev/null +++ b/src/plugins/configuration_provider/server/types.ts @@ -0,0 +1,19 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +// eslint-disable-next-line @typescript-eslint/no-empty-interface +export interface ConfigurationProviderPluginSetup {} +// eslint-disable-next-line @typescript-eslint/no-empty-interface +export interface ConfigurationProviderPluginStart {} + +export interface ConfigurationClient { + existsCspRules(): Promise; + + getCspRules(): Promise; + + updateCspRules(cspRules: string): Promise; + + deleteCspRules(): Promise; +} diff --git a/src/plugins/csp_configuration_provider/.i18nrc.json b/src/plugins/csp_configuration_provider/.i18nrc.json deleted file mode 100644 index 5c8575b9d4fe..000000000000 --- a/src/plugins/csp_configuration_provider/.i18nrc.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "prefix": "cspConfigurationProvider", - "paths": { - "cspConfigurationProvider": "." - }, - "translations": ["translations/ja-JP.json"] -} diff --git a/src/plugins/csp_configuration_provider/README.md b/src/plugins/csp_configuration_provider/README.md deleted file mode 100755 index 0d9d9c35ba44..000000000000 --- a/src/plugins/csp_configuration_provider/README.md +++ /dev/null @@ -1,64 +0,0 @@ -# CspConfigurationProvider - -A OpenSearch Dashboards plugin - -This plugin introduces the support of self service dynamic configuration of Content Security Policy (CSP) rules without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from a new index `.opensearch_dashboards_config` and then rewrite to CSP header. OSD users could update the content of the index with new CSP rules and the change will take effect immediately. - -It also provides an interface `CspClient` for future extensions of external CSP providers. By default, an implementation based on OpenSearch as database is used. - ---- - -## Configuration - -By default, the new index does not exist. For OSD users who do not need customized CSP rules, there is no need to create this index. The system will then use whatever CSP rules aggregated by the values of `csp.rules` from `opensearch_dashboards.yml` and default values. - -Below is the current default value. - -``` -"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'" -``` -(Note that `frame-ancestors 'self'` is used to only allow self embedding and prevent clickjacking by default.) - -For OSD users who want to make changes, e.g allow this site `https://example-site.org` to embed OSD pages, they can update the index from DevTools Console. - -``` -PUT .opensearch_dashboards_config/_doc/csp.rules -{ - "value": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' https://example-site.org" -} - -``` - -## External CSP Clients -While a default OpenSearch based client is implemented, OSD users can use external CSP clients through an OSD plugin (outside OSD). - -Let's call this plugin `MyCspClientPlugin`. - -First, this plugin will need to implement a class `MyCspClient` based on interface `CspClient` defined in the `types.ts` under directory `src/plugins/csp_configuration_provider/server/types.ts`. - -Second, this plugin needs to declare `cspConfigurationProvider` as its dependency by adding it to `requiredPlugins` in its own `opensearch_dashboards.json`. - -Third, the plugin will import the type `CspConfigurationProviderPluginSetup` from the corresponding `types.ts` and add to its own setup input. Below is the skeleton of the class `MyCspClientPlugin`. - -``` -// MyCspClientPlugin - public setup(core: CoreSetup, { cspConfigurationProviderPluginSetup }: CspConfigurationProviderPluginSetup) { - - ... - // The function createClient provides an instance of MyCspClient which - // could have a underlying DynamoDB or Postgres implementation. - const myCspClient: CspClient = this.createClient(); - - cspConfigurationProviderPluginSetup.setCspClient(myCspClient); - ... - return {}; - } - -``` - ---- -## Development - -See the [OpenSearch Dashboards contributing -guide](https://github.com/opensearch-project/OpenSearch-Dashboards/blob/main/CONTRIBUTING.md) for instructions -setting up your development environment. diff --git a/src/plugins/csp_configuration_provider/common/index.ts b/src/plugins/csp_configuration_provider/common/index.ts deleted file mode 100644 index 9baae8401294..000000000000 --- a/src/plugins/csp_configuration_provider/common/index.ts +++ /dev/null @@ -1,7 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -export const PLUGIN_ID = 'cspConfigurationProvider'; -export const PLUGIN_NAME = 'CspConfigurationProvider'; diff --git a/src/plugins/csp_configuration_provider/server/csp_handlers.ts b/src/plugins/csp_configuration_provider/server/csp_handlers.ts deleted file mode 100644 index 378a38523ec8..000000000000 --- a/src/plugins/csp_configuration_provider/server/csp_handlers.ts +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { CoreSetup, OnPreResponseHandler, OpenSearchClient } from '../../../core/server'; -import { CspClient } from './types'; - -const OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME = 'csp.rules'; - -export function createCspRulesPreResponseHandler( - core: CoreSetup, - dynamicConfigIndex: string, - getCspClient: (inputOpenSearchClient: OpenSearchClient) => CspClient -): OnPreResponseHandler { - return async (request, response, toolkit) => { - const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; - - const currentDest = request.headers['sec-fetch-dest']; - - if (!shouldCheckDest.includes(currentDest)) { - return toolkit.next({}); - } - - const [coreStart] = await core.getStartServices(); - - const myClient = getCspClient(coreStart.opensearch.client.asInternalUser); - - const existsValue = await myClient.exists(dynamicConfigIndex); - - if (!existsValue) { - return toolkit.next({}); - } - - const cspRules = await myClient.get( - dynamicConfigIndex, - OPENSEARCH_DASHBOARDS_CONFIG_DOCUMENT_NAME - ); - - if (!cspRules) { - return toolkit.next({}); - } - - const additionalHeaders = { - 'content-security-policy': cspRules, - }; - - return toolkit.next({ headers: additionalHeaders }); - }; -} diff --git a/src/plugins/csp_configuration_provider/server/plugin.ts b/src/plugins/csp_configuration_provider/server/plugin.ts deleted file mode 100644 index e483fb219a42..000000000000 --- a/src/plugins/csp_configuration_provider/server/plugin.ts +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { Observable } from 'rxjs'; -import { first } from 'rxjs/operators'; -import { - CoreSetup, - CoreStart, - Logger, - OpenSearchClient, - Plugin, - PluginInitializerContext, - SharedGlobalConfig, -} from '../../../core/server'; - -import { createCspRulesPreResponseHandler } from './csp_handlers'; -import { OpenSearchCspClient } from './provider'; -import { defineRoutes } from './routes'; -import { - CspClient, - CspConfigurationProviderPluginSetup, - CspConfigurationProviderPluginStart, -} from './types'; - -export class CspConfigurationProviderPlugin - implements Plugin { - private readonly logger: Logger; - private readonly config$: Observable; - private cspClient: CspClient | undefined; - - constructor(initializerContext: PluginInitializerContext) { - this.logger = initializerContext.logger.get(); - this.config$ = initializerContext.config.legacy.globalConfig$; - } - - private setCspClient(inputCspClient: CspClient) { - this.cspClient = inputCspClient; - } - - private getCspClient(inputOpenSearchClient: OpenSearchClient) { - if (this.cspClient) { - return this.cspClient; - } - - const openSearchCspClient = new OpenSearchCspClient(inputOpenSearchClient); - this.setCspClient(openSearchCspClient); - return this.cspClient; - } - - public async setup(core: CoreSetup) { - this.logger.debug('CspConfigurationProvider: Setup'); - const router = core.http.createRouter(); - - // Register server side APIs - defineRoutes(router); - - const config = await this.config$.pipe(first()).toPromise(); - - core.http.registerOnPreResponse( - createCspRulesPreResponseHandler( - core, - config.opensearchDashboards.dynamic_config_index, - this.getCspClient.bind(this) - ) - ); - - return { - setCspClient: this.setCspClient.bind(this), - }; - } - - public start(core: CoreStart) { - this.logger.debug('CspConfigurationProvider: Started'); - return {}; - } - - public stop() {} -} diff --git a/src/plugins/csp_configuration_provider/server/provider.test.ts b/src/plugins/csp_configuration_provider/server/provider.test.ts deleted file mode 100644 index 09c68115dc09..000000000000 --- a/src/plugins/csp_configuration_provider/server/provider.test.ts +++ /dev/null @@ -1,165 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { SearchResponse } from '@opensearch-project/opensearch/api/types'; -import { - OpenSearchClientMock, - opensearchClientMock, -} from '../../../core/server/opensearch/client/mocks'; -import { OpenSearchCspClient } from './provider'; - -const INDEX_NAME = 'test_index'; -const INDEX_DOCUMENT_NAME = 'csp_doc'; -const ERROR_MESSAGE = 'Service unavailable'; - -describe('Provider', () => { - let opensearchClient: OpenSearchClientMock; - - beforeEach(() => { - jest.resetAllMocks(); - opensearchClient = opensearchClientMock.createOpenSearchClient(); - }); - - afterEach(() => {}); - - describe('exists', () => { - it('returns true if the target index does exists', async () => { - const indexExists = true; - opensearchClient.indices.exists.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const value = await client.exists(INDEX_NAME); - - expect(value).toBeTruthy(); - expect(opensearchClient.indices.exists).toBeCalledWith({ index: INDEX_NAME }); - }); - - it('returns false if the target index does not exists', async () => { - const indexExists = false; - opensearchClient.indices.exists.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const existsValue = await client.exists(INDEX_NAME); - - expect(existsValue).toBeFalsy(); - expect(opensearchClient.indices.exists).toBeCalledWith({ index: INDEX_NAME }); - }); - - it('returns false if opensearch errors happen', async () => { - opensearchClient.indices.exists.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(new Error(ERROR_MESSAGE)); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const existsValue = await client.exists(INDEX_NAME); - - expect(existsValue).toBeFalsy(); - expect(opensearchClient.indices.exists).toBeCalledWith({ index: INDEX_NAME }); - }); - }); - - describe('get', () => { - it('returns the csp rules from the index', async () => { - const cspRules = "frame-ancestors 'self'"; - - opensearchClient.search.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({ - hits: { - hits: [ - { - _source: { - value: cspRules, - }, - }, - ], - }, - } as SearchResponse); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const getValue = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); - - expect(getValue).toBe(cspRules); - expect(opensearchClient.search).toBeCalledWith( - getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) - ); - }); - - it('returns empty when opensearch response is malformed', async () => { - opensearchClient.search.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({ - hits: {}, - } as SearchResponse); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const getValue = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); - - expect(getValue).toBe(''); - expect(opensearchClient.search).toBeCalledWith( - getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) - ); - }); - - it('returns empty when value field is missing in opensearch response', async () => { - const cspRules = "frame-ancestors 'self'"; - - opensearchClient.search.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({ - hits: { - hits: [ - { - _source: { - value_typo: cspRules, - }, - }, - ], - }, - } as SearchResponse); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const getValue = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); - - expect(getValue).toBe(''); - expect(opensearchClient.search).toBeCalledWith( - getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) - ); - }); - - it('returns empty string when opensearch errors happen', async () => { - opensearchClient.search.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(new Error(ERROR_MESSAGE)); - }); - - const client = new OpenSearchCspClient(opensearchClient); - const cspRules = await client.get(INDEX_NAME, INDEX_DOCUMENT_NAME); - - expect(cspRules).toBe(''); - expect(opensearchClient.search).toBeCalledWith( - getSearchInput(INDEX_NAME, INDEX_DOCUMENT_NAME) - ); - }); - }); -}); - -function getSearchInput(indexName: string, documentName: string) { - return { - index: indexName, - body: { - query: { - match: { - _id: { - query: documentName, - }, - }, - }, - }, - }; -} diff --git a/src/plugins/csp_configuration_provider/server/provider.ts b/src/plugins/csp_configuration_provider/server/provider.ts deleted file mode 100644 index 1a59ea80209b..000000000000 --- a/src/plugins/csp_configuration_provider/server/provider.ts +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { OpenSearchClient } from '../../../../src/core/server'; - -import { CspClient } from './types'; - -export class OpenSearchCspClient implements CspClient { - private client: OpenSearchClient; - - constructor(inputOpenSearchClient: OpenSearchClient) { - this.client = inputOpenSearchClient; - } - - async exists(configurationName: string): Promise { - let value = false; - - try { - const exists = await this.client.indices.exists({ - index: configurationName, - }); - - value = exists.body; - } catch (e) { - // eslint-disable-next-line no-console - console.error( - `Failed to call exists with configurationName ${configurationName} due to error ${e}` - ); - } - - return value; - } - - async get(configurationName: string, cspRulesName: string): Promise { - const query = { - query: { - match: { - _id: { - query: cspRulesName, - }, - }, - }, - }; - - let value = ''; - - try { - const data = await this.client.search({ - index: configurationName, - body: query, - }); - - value = data?.body?.hits?.hits[0]?._source?.value || ''; - } catch (e) { - // eslint-disable-next-line no-console - console.error( - `Failed to call get with configurationName ${configurationName} and cspRulesName ${cspRulesName} due to error ${e}` - ); - } - - return value; - } -} diff --git a/src/plugins/csp_configuration_provider/server/routes/index.ts b/src/plugins/csp_configuration_provider/server/routes/index.ts deleted file mode 100644 index 06f88042a95c..000000000000 --- a/src/plugins/csp_configuration_provider/server/routes/index.ts +++ /dev/null @@ -1,8 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { IRouter } from '../../../../core/server'; - -export function defineRoutes(router: IRouter) {} diff --git a/src/plugins/csp_configuration_provider/server/types.ts b/src/plugins/csp_configuration_provider/server/types.ts deleted file mode 100644 index 9881652c389f..000000000000 --- a/src/plugins/csp_configuration_provider/server/types.ts +++ /dev/null @@ -1,15 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -// eslint-disable-next-line @typescript-eslint/no-empty-interface -export interface CspConfigurationProviderPluginSetup {} -// eslint-disable-next-line @typescript-eslint/no-empty-interface -export interface CspConfigurationProviderPluginStart {} - -export interface CspClient { - exists(configurationName: string): Promise; - - get(configurationName: string, cspRulesName: string): Promise; -} From 48ee280ee00721ce48a6188b439f549af8d7d668 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 18 Jan 2024 04:10:25 +0000 Subject: [PATCH 21/59] add header Signed-off-by: Tianle Huang --- .../configuration_provider/server/routes/index.test.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts index e19586b135ee..a9e30b921211 100644 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -1,3 +1,8 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + import { defineRoutes } from '.'; import { loggerMock } from '@osd/logging/target/mocks'; import { httpServiceMock } from '../../../../core/server/mocks'; From ce1b89afdef6095c828020dc1640859e0d156218 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 18 Jan 2024 04:30:45 +0000 Subject: [PATCH 22/59] fix link error Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index fef7519953b1..81c1aef01b7e 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -23,27 +23,27 @@ For OSD users who want to make changes, e.g allow this site `https://example-sit (Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) ``` -curl 'http://localhost:5601/api/configuration_provider/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' https://example-site.org"}' +curl 'http://{osd endpoint}/api/configuration_provider/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' https://example-site.org"}' ``` Below is the CURL command to delete CSP rules. ``` -curl 'http://localhost:5601/api/configuration_provider/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' +curl 'http://{osd endpoint}/api/configuration_provider/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' ``` Below is the CURL command to check if CSP rules exist in the new index. ``` -curl 'http://localhost:5601/api/configuration_provider/existsCspRules' +curl 'http://{osd endpoint}/api/configuration_provider/existsCspRules' ``` Below is the CURL command to get the CSP rules from the new index. ``` -curl 'http://localhost:5601/api/configuration_provider/getCspRules' +curl 'http://{osd endpoint}/api/configuration_provider/getCspRules' ``` From fe140d8c4ed63dae5dd79893811731438b3f1b4c Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 18 Jan 2024 17:58:49 +0000 Subject: [PATCH 23/59] fix link error Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index 81c1aef01b7e..ff73dd871bed 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -19,31 +19,31 @@ Below is the current default value. ``` (Note that `frame-ancestors 'self'` is used to only allow self embedding and prevent clickjacking by default.) -For OSD users who want to make changes, e.g allow this site `https://example-site.org` to embed OSD pages, they can update CSP rules through CURL. +For OSD users who want to make changes to allow a new site to embed OSD pages, they can update CSP rules through CURL. (Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) ``` -curl 'http://{osd endpoint}/api/configuration_provider/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' https://example-site.org"}' +curl '{osd endpoint}/api/configuration_provider/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' ``` Below is the CURL command to delete CSP rules. ``` -curl 'http://{osd endpoint}/api/configuration_provider/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' +curl '{osd endpoint}/api/configuration_provider/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' ``` Below is the CURL command to check if CSP rules exist in the new index. ``` -curl 'http://{osd endpoint}/api/configuration_provider/existsCspRules' +curl '{osd endpoint}/api/configuration_provider/existsCspRules' ``` Below is the CURL command to get the CSP rules from the new index. ``` -curl 'http://{osd endpoint}/api/configuration_provider/getCspRules' +curl '{osd endpoint}/api/configuration_provider/getCspRules' ``` From bd9ff1d8d207c76a9e0fb8280bb9a29921f45cbc Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 18 Jan 2024 20:10:37 +0000 Subject: [PATCH 24/59] add more unit tests Signed-off-by: Tianle Huang --- .../server/routes/index.test.ts | 125 ++++++++++++------ .../server/routes/index.ts | 28 +--- 2 files changed, 89 insertions(+), 64 deletions(-) diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts index a9e30b921211..77ce676a1bb9 100644 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -3,50 +3,91 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { defineRoutes } from '.'; +import { defineRoutes, errorResponse } from '.'; import { loggerMock } from '@osd/logging/target/mocks'; import { httpServiceMock } from '../../../../core/server/mocks'; -describe('index ts', () => { - it('routes', () => { - const router = httpServiceMock.createRouter(); - const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(true), - getCspRules: jest.fn().mockReturnValue(''), - }; - - const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - - const logger = loggerMock.create(); - - defineRoutes(router, getConfigurationClient, logger); - - expect(router.get).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/configuration_provider/existsCspRules', - }), - expect.any(Function) - ); - - expect(router.get).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/configuration_provider/getCspRules', - }), - expect.any(Function) - ); - - expect(router.post).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/configuration_provider/updateCspRules', - }), - expect.any(Function) - ); - - expect(router.post).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/configuration_provider/deleteCspRules', - }), - expect.any(Function) - ); +const ERROR_MESSAGE = 'Service unavailable'; + +describe('configuration provider routes', () => { + describe('defineRoutes', () => { + it('check route paths are defined', () => { + const router = httpServiceMock.createRouter(); + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(true), + getCspRules: jest.fn().mockReturnValue(''), + }; + + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); + + const logger = loggerMock.create(); + + defineRoutes(router, getConfigurationClient, logger); + + expect(router.get).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/existsCspRules', + }), + expect.any(Function) + ); + + expect(router.get).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/getCspRules', + }), + expect.any(Function) + ); + + expect(router.post).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/updateCspRules', + }), + expect.any(Function) + ); + + expect(router.post).toHaveBeenCalledWith( + expect.objectContaining({ + path: '/api/configuration_provider/deleteCspRules', + }), + expect.any(Function) + ); + }); + }); + + describe('errorResponse', () => { + it('return default 500 statusCode', () => { + const response = { + custom: jest.fn(), + }; + + const error = { + message: ERROR_MESSAGE, + }; + + errorResponse(response, error); + + expect(response.custom).toBeCalledWith({ + statusCode: 500, + body: error, + }); + }); + + it('return input statusCode', () => { + const response = { + custom: jest.fn(), + }; + + const error = { + statusCode: 400, + message: ERROR_MESSAGE, + }; + + errorResponse(response, error); + + expect(response.custom).toBeCalledWith({ + statusCode: 400, + body: error, + }); + }); }); }); diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts index 5f497714e0e9..81a3e5624e2a 100644 --- a/src/plugins/configuration_provider/server/routes/index.ts +++ b/src/plugins/configuration_provider/server/routes/index.ts @@ -21,15 +21,9 @@ export function defineRoutes( { path: '/api/configuration_provider/existsCspRules', validate: false, - // validate: { - // params: schema.object({ - // configurationName: schema.string(), - // }), - // }, }, async (context, request, response) => { const client = getConfigurationClient(context.core.opensearch.client); - // const configurationName = request.params.configurationName; try { const result = await client.existsCspRules(); @@ -48,17 +42,9 @@ export function defineRoutes( { path: '/api/configuration_provider/getCspRules', validate: false, - // validate: { - // params: schema.object({ - // configurationName: schema.string(), - // cspRulesName: schema.string(), - // }), - // }, }, async (context, request, response) => { const client = getConfigurationClient(context.core.opensearch.client); - // const configurationName = request.params.configurationName; - // const cspRulesName = request.params.cspRulesName; try { const result = await client.getCspRules(); @@ -127,13 +113,11 @@ export function defineRoutes( } } ); +} - function errorResponse(response: OpenSearchDashboardsResponseFactory, error: any) { - logger.info('Error from esClient call: ' + JSON.stringify(error)); - - return response.custom({ - statusCode: error?.statusCode || 500, - body: error, - }); - } +export function errorResponse(response: OpenSearchDashboardsResponseFactory, error: any) { + return response.custom({ + statusCode: error?.statusCode || 500, + body: error, + }); } From 9e1424886824f70ee6f27eda5caab3faba03c883 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 18 Jan 2024 23:31:31 +0000 Subject: [PATCH 25/59] add more unit tests Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 2 +- .../server/routes/index.test.ts | 344 +++++++++++++++++- .../server/routes/index.ts | 138 ++++--- 3 files changed, 433 insertions(+), 51 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index ff73dd871bed..60949361a460 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -4,7 +4,7 @@ A OpenSearch Dashboards plugin This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.dynamic_config_index` in OSD YAML file `opensearch_dashboards.yml`. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. -The first use case onboarding to this new index is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from the new index and then rewrite to CSP header. The plugin exposes query and update APIs for OSD users to use against CSP rules. Currently there is no new OSD pages for ease of user interactions with the APIs. Users are able to call the API endpoint directly, e.g through CURL. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. +The first use case onboarding to this new index is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from the new index and then rewrite to CSP header. The plugin exposes query and update APIs for OSD users to use against CSP rules. Currently there is no new OSD page for ease of user interactions with the APIs. Users are able to call the API endpoint directly, e.g through CURL. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. --- diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts index 77ce676a1bb9..8d8c03488bdb 100644 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -3,12 +3,23 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { defineRoutes, errorResponse } from '.'; +import { + defineRoutes, + errorResponse, + handleDeleteCspRules, + handleExistsCspRules, + handleGetCspRules, + handleUpdateCspRules, +} from '.'; import { loggerMock } from '@osd/logging/target/mocks'; import { httpServiceMock } from '../../../../core/server/mocks'; const ERROR_MESSAGE = 'Service unavailable'; +const ERROR_RESPONSE = { + statusCode: 500, +}; + describe('configuration provider routes', () => { describe('defineRoutes', () => { it('check route paths are defined', () => { @@ -54,6 +65,337 @@ describe('configuration provider routes', () => { }); }); + describe('handleExistsCspRules', () => { + it('return true when client returns true', async () => { + const existsValue = true; + + const client = { + existsCspRules: jest.fn().mockReturnValue(existsValue), + }; + + const okResponse = { + statusCode: 200, + }; + + const response = { + ok: jest.fn().mockReturnValue(okResponse), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleExistsCspRules(client, response, logger); + + expect(returnedResponse).toBe(okResponse); + + expect(client.existsCspRules).toBeCalledTimes(1); + + expect(response.ok).toBeCalledWith({ + body: { + exists: existsValue, + }, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('return false when client returns false', async () => { + const existsValue = false; + + const client = { + existsCspRules: jest.fn().mockReturnValue(existsValue), + }; + + const okResponse = { + statusCode: 200, + }; + + const response = { + ok: jest.fn().mockReturnValue(okResponse), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleExistsCspRules(client, response, logger); + + expect(returnedResponse).toBe(okResponse); + + expect(client.existsCspRules).toBeCalledTimes(1); + + expect(response.ok).toBeCalledWith({ + body: { + exists: existsValue, + }, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('return error response when client throws error', async () => { + const error = new Error(ERROR_MESSAGE); + const client = { + existsCspRules: jest.fn().mockImplementation(() => { + throw error; + }), + }; + + const response = { + custom: jest.fn().mockReturnValue(ERROR_RESPONSE), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleExistsCspRules(client, response, logger); + + expect(returnedResponse).toBe(ERROR_RESPONSE); + + expect(client.existsCspRules).toBeCalledTimes(1); + + expect(response.custom).toBeCalledWith({ + body: error, + statusCode: 500, + }); + + expect(logger.error).toBeCalledWith(error); + }); + }); + + describe('handleGetCspRules', () => { + it('return CSP rules when client returns CSP rules', async () => { + const cspRules = "frame-ancestors 'self'"; + + const client = { + getCspRules: jest.fn().mockReturnValue(cspRules), + }; + + const okResponse = { + statusCode: 200, + }; + + const response = { + ok: jest.fn().mockReturnValue(okResponse), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleGetCspRules(client, response, logger); + + expect(returnedResponse).toBe(okResponse); + + expect(client.getCspRules).toBeCalledTimes(1); + + expect(response.ok).toBeCalledWith({ + body: { + cspRules, + }, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('return error response when client throws error', async () => { + const error = new Error(ERROR_MESSAGE); + + const client = { + getCspRules: jest.fn().mockImplementation(() => { + throw error; + }), + }; + + const response = { + custom: jest.fn().mockReturnValue(ERROR_RESPONSE), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleGetCspRules(client, response, logger); + + expect(returnedResponse).toBe(ERROR_RESPONSE); + + expect(client.getCspRules).toBeCalledTimes(1); + + expect(response.custom).toBeCalledWith({ + body: error, + statusCode: 500, + }); + + expect(logger.error).toBeCalledWith(error); + }); + }); + + describe('handleUpdateCspRules', () => { + it('return updated CSP rules when client updates CSP rules', async () => { + const cspRules = "frame-ancestors 'self'"; + + const client = { + updateCspRules: jest.fn().mockReturnValue(cspRules), + }; + + const okResponse = { + statusCode: 200, + }; + + const request = { + body: { + value: cspRules, + }, + }; + + const response = { + ok: jest.fn().mockReturnValue(okResponse), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleUpdateCspRules(client, request, response, logger); + + expect(returnedResponse).toBe(okResponse); + + expect(client.updateCspRules).toBeCalledTimes(1); + + expect(response.ok).toBeCalledWith({ + body: { + updatedRules: cspRules, + }, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('return error response when client throws error', async () => { + const cspRules = "frame-ancestors 'self'"; + + const error = new Error(ERROR_MESSAGE); + + const client = { + updateCspRules: jest.fn().mockImplementation(() => { + throw error; + }), + }; + + const request = { + body: { + value: cspRules, + }, + }; + + const response = { + custom: jest.fn().mockReturnValue(ERROR_RESPONSE), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleUpdateCspRules(client, request, response, logger); + + expect(returnedResponse).toBe(ERROR_RESPONSE); + + expect(client.updateCspRules).toBeCalledTimes(1); + + expect(response.custom).toBeCalledWith({ + body: error, + statusCode: 500, + }); + + expect(logger.error).toBeCalledWith(error); + }); + + it('return error response when input is empty', async () => { + const emptyCspRules = ' '; + const error = new Error('Cannot update CSP rules to emtpy!'); + + const client = { + updateCspRules: jest.fn(), + }; + + const request = { + body: { + value: emptyCspRules, + }, + }; + + const response = { + custom: jest.fn().mockReturnValue(ERROR_RESPONSE), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleUpdateCspRules(client, request, response, logger); + + expect(returnedResponse).toBe(ERROR_RESPONSE); + + expect(client.updateCspRules).not.toBeCalled(); + + expect(response.custom).toBeCalledWith({ + body: error, + statusCode: 500, + }); + + expect(logger.error).toBeCalledWith(error); + }); + }); + + describe('handleDeleteCspRules', () => { + it('return deleted CSP rules when client deletes CSP rules', async () => { + const cspRulesName = 'csp.rules'; + + const client = { + deleteCspRules: jest.fn().mockReturnValue(cspRulesName), + }; + + const okResponse = { + statusCode: 200, + }; + + const response = { + ok: jest.fn().mockReturnValue(okResponse), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleDeleteCspRules(client, response, logger); + + expect(returnedResponse).toBe(okResponse); + + expect(client.deleteCspRules).toBeCalledTimes(1); + + expect(response.ok).toBeCalledWith({ + body: { + deletedCspRulesName: cspRulesName, + }, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('return error response when client throws error', async () => { + const error = new Error(ERROR_MESSAGE); + + const client = { + deleteCspRules: jest.fn().mockImplementation(() => { + throw error; + }), + }; + + const response = { + custom: jest.fn().mockReturnValue(ERROR_RESPONSE), + }; + + const logger = loggerMock.create(); + + const returnedResponse = await handleDeleteCspRules(client, response, logger); + + expect(returnedResponse).toBe(ERROR_RESPONSE); + + expect(client.deleteCspRules).toBeCalledTimes(1); + + expect(response.custom).toBeCalledWith({ + body: error, + statusCode: 500, + }); + + expect(logger.error).toBeCalledWith(error); + }); + }); + describe('errorResponse', () => { it('return default 500 statusCode', () => { const response = { diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts index 81a3e5624e2a..19b539aed42b 100644 --- a/src/plugins/configuration_provider/server/routes/index.ts +++ b/src/plugins/configuration_provider/server/routes/index.ts @@ -8,6 +8,7 @@ import { IRouter, IScopedClusterClient, Logger, + OpenSearchDashboardsRequest, OpenSearchDashboardsResponseFactory, } from '../../../../core/server'; import { ConfigurationClient } from '../types'; @@ -25,16 +26,7 @@ export function defineRoutes( async (context, request, response) => { const client = getConfigurationClient(context.core.opensearch.client); - try { - const result = await client.existsCspRules(); - return response.ok({ - body: { - exists: result, - }, - }); - } catch (e) { - return errorResponse(response, e); - } + return await handleExistsCspRules(client, response, logger); } ); @@ -46,17 +38,7 @@ export function defineRoutes( async (context, request, response) => { const client = getConfigurationClient(context.core.opensearch.client); - try { - const result = await client.getCspRules(); - - return response.ok({ - body: { - cspRules: result, - }, - }); - } catch (e) { - return errorResponse(response, e); - } + return await handleGetCspRules(client, response, logger); } ); @@ -70,25 +52,9 @@ export function defineRoutes( }, }, async (context, request, response) => { - const inputCspRules = request.body.value.trim(); - - if (!inputCspRules) { - return errorResponse(response, new Error('Cannot update CSP rules to emtpy!')); - } - const client = getConfigurationClient(context.core.opensearch.client); - try { - const updatedRules = await client.updateCspRules(inputCspRules); - - return response.ok({ - body: { - updatedRules, - }, - }); - } catch (e) { - return errorResponse(response, e); - } + return await handleUpdateCspRules(client, request, response, logger); } ); @@ -100,21 +66,95 @@ export function defineRoutes( async (context, request, response) => { const client = getConfigurationClient(context.core.opensearch.client); - try { - const deletedCspRulesName = await client.deleteCspRules(); - - return response.ok({ - body: { - deletedCspRulesName, - }, - }); - } catch (e) { - return errorResponse(response, e); - } + return await handleDeleteCspRules(client, response, logger); } ); } +export async function handleExistsCspRules( + client: ConfigurationClient, + response: OpenSearchDashboardsResponseFactory, + logger: Logger +) { + try { + const result = await client.existsCspRules(); + return response.ok({ + body: { + exists: result, + }, + }); + } catch (e) { + logger.error(e); + return errorResponse(response, e); + } +} + +export async function handleGetCspRules( + client: ConfigurationClient, + response: OpenSearchDashboardsResponseFactory, + logger: Logger +) { + try { + const result = await client.getCspRules(); + + return response.ok({ + body: { + cspRules: result, + }, + }); + } catch (e) { + logger.error(e); + return errorResponse(response, e); + } +} + +export async function handleUpdateCspRules( + client: ConfigurationClient, + request: OpenSearchDashboardsRequest, + response: OpenSearchDashboardsResponseFactory, + logger: Logger +) { + const inputCspRules = request.body.value.trim(); + + if (!inputCspRules) { + const error = new Error('Cannot update CSP rules to emtpy!'); + logger.error(error); + return errorResponse(response, error); + } + + try { + const updatedRules = await client.updateCspRules(inputCspRules); + + return response.ok({ + body: { + updatedRules, + }, + }); + } catch (e) { + logger.error(e); + return errorResponse(response, e); + } +} + +export async function handleDeleteCspRules( + client: ConfigurationClient, + response: OpenSearchDashboardsResponseFactory, + logger: Logger +) { + try { + const deletedCspRulesName = await client.deleteCspRules(); + + return response.ok({ + body: { + deletedCspRulesName, + }, + }); + } catch (e) { + logger.error(e); + return errorResponse(response, e); + } +} + export function errorResponse(response: OpenSearchDashboardsResponseFactory, error: any) { return response.custom({ statusCode: error?.statusCode || 500, From fca973891944307490e912ed51e069e0c95b85f7 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 19 Jan 2024 00:40:42 +0000 Subject: [PATCH 26/59] update api path Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 8 +-- .../server/provider.test.ts | 63 +++++++++++++++++++ .../configuration_provider/server/provider.ts | 10 +++ .../server/routes/index.test.ts | 8 +-- .../server/routes/index.ts | 10 +-- 5 files changed, 87 insertions(+), 12 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index 60949361a460..99d7dcf76e6f 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -23,27 +23,27 @@ For OSD users who want to make changes to allow a new site to embed OSD pages, t (Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) ``` -curl '{osd endpoint}/api/configuration_provider/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' +curl '{osd endpoint}/api/configuration/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' ``` Below is the CURL command to delete CSP rules. ``` -curl '{osd endpoint}/api/configuration_provider/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' +curl '{osd endpoint}/api/configuration/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' ``` Below is the CURL command to check if CSP rules exist in the new index. ``` -curl '{osd endpoint}/api/configuration_provider/existsCspRules' +curl '{osd endpoint}/api/configuration/existsCspRules' ``` Below is the CURL command to get the CSP rules from the new index. ``` -curl '{osd endpoint}/api/configuration_provider/getCspRules' +curl '{osd endpoint}/api/configuration/getCspRules' ``` diff --git a/src/plugins/configuration_provider/server/provider.test.ts b/src/plugins/configuration_provider/server/provider.test.ts index 4d0e6e29db99..9abcf80be4f4 100644 --- a/src/plugins/configuration_provider/server/provider.test.ts +++ b/src/plugins/configuration_provider/server/provider.test.ts @@ -10,6 +10,7 @@ import { import { OpenSearchConfigurationClient } from './provider'; import { MockedLogger, loggerMock } from '@osd/logging/target/mocks'; import { GetResponse } from 'src/core/server'; +import { ResponseError } from '@opensearch-project/opensearch/lib/errors'; const INDEX_NAME = 'test_index'; const INDEX_DOCUMENT_NAME = 'csp.rules'; @@ -255,6 +256,68 @@ describe('OpenSearchConfigurationClient', () => { expect(logger.error).toBeCalledWith(`Failed to call deleteCspRules due to error ${error}`); }); + + it('return deleted document ID when deletion fails due to index not found', async () => { + const error = new ResponseError({ + statusCode: 401, + body: { + error: { + type: 'index_not_found_exception', + }, + }, + warnings: [], + headers: { + 'WWW-Authenticate': 'content', + }, + meta: {} as any, + }); + + opensearchClient.asCurrentUser.delete.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(error); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const deletedCspRulesName = await client.deleteCspRules(); + + expect(deletedCspRulesName).toBe(INDEX_DOCUMENT_NAME); + + expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); + + it('return deleted document ID when deletion fails due to document not found', async () => { + const error = new ResponseError({ + statusCode: 401, + body: { + result: 'not_found', + }, + warnings: [], + headers: { + 'WWW-Authenticate': 'content', + }, + meta: {} as any, + }); + + opensearchClient.asCurrentUser.delete.mockImplementation(() => { + return opensearchClientMock.createErrorTransportRequestPromise(error); + }); + + const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); + const deletedCspRulesName = await client.deleteCspRules(); + + expect(deletedCspRulesName).toBe(INDEX_DOCUMENT_NAME); + + expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ + index: INDEX_NAME, + id: INDEX_DOCUMENT_NAME, + }); + + expect(logger.error).not.toBeCalled(); + }); }); }); diff --git a/src/plugins/configuration_provider/server/provider.ts b/src/plugins/configuration_provider/server/provider.ts index f2a6573db03b..da830c6412a4 100644 --- a/src/plugins/configuration_provider/server/provider.ts +++ b/src/plugins/configuration_provider/server/provider.ts @@ -87,6 +87,16 @@ export class OpenSearchConfigurationClient implements ConfigurationClient { return CSP_RULES_DOC_ID; } catch (e) { + if (e?.body?.error?.type === 'index_not_found_exception') { + this.logger.info('Attemp to delete a not found index.'); + return CSP_RULES_DOC_ID; + } + + if (e?.body?.result === 'not_found') { + this.logger.info('Attemp to delete a not found document.'); + return CSP_RULES_DOC_ID; + } + const errorMessage = `Failed to call deleteCspRules due to error ${e}`; this.logger.error(errorMessage); diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts index 8d8c03488bdb..9da9feb86255 100644 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -37,28 +37,28 @@ describe('configuration provider routes', () => { expect(router.get).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration_provider/existsCspRules', + path: '/api/configuration/existsCspRules', }), expect.any(Function) ); expect(router.get).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration_provider/getCspRules', + path: '/api/configuration/getCspRules', }), expect.any(Function) ); expect(router.post).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration_provider/updateCspRules', + path: '/api/configuration/updateCspRules', }), expect.any(Function) ); expect(router.post).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration_provider/deleteCspRules', + path: '/api/configuration/deleteCspRules', }), expect.any(Function) ); diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts index 19b539aed42b..955424e0fdcf 100644 --- a/src/plugins/configuration_provider/server/routes/index.ts +++ b/src/plugins/configuration_provider/server/routes/index.ts @@ -20,7 +20,7 @@ export function defineRoutes( ) { router.get( { - path: '/api/configuration_provider/existsCspRules', + path: '/api/configuration/existsCspRules', validate: false, }, async (context, request, response) => { @@ -32,7 +32,7 @@ export function defineRoutes( router.get( { - path: '/api/configuration_provider/getCspRules', + path: '/api/configuration/getCspRules', validate: false, }, async (context, request, response) => { @@ -44,7 +44,7 @@ export function defineRoutes( router.post( { - path: '/api/configuration_provider/updateCspRules', + path: '/api/configuration/updateCspRules', validate: { body: schema.object({ value: schema.string(), @@ -60,7 +60,7 @@ export function defineRoutes( router.post( { - path: '/api/configuration_provider/deleteCspRules', + path: '/api/configuration/deleteCspRules', validate: false, }, async (context, request, response) => { @@ -141,6 +141,8 @@ export async function handleDeleteCspRules( response: OpenSearchDashboardsResponseFactory, logger: Logger ) { + logger.info('handleDeleteCspRules'); + try { const deletedCspRulesName = await client.deleteCspRules(); From 6f2e0d4f9433fd1aa2d00fb616e1f10390d562fa Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 19 Jan 2024 23:57:54 +0000 Subject: [PATCH 27/59] remove logging Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/server/routes/index.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts index 955424e0fdcf..a7efbc4620c2 100644 --- a/src/plugins/configuration_provider/server/routes/index.ts +++ b/src/plugins/configuration_provider/server/routes/index.ts @@ -141,8 +141,6 @@ export async function handleDeleteCspRules( response: OpenSearchDashboardsResponseFactory, logger: Logger ) { - logger.info('handleDeleteCspRules'); - try { const deletedCspRulesName = await client.deleteCspRules(); From 60c89b5539aed2517be2354fcb96962f6ea10b78 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 25 Jan 2024 19:38:05 +0000 Subject: [PATCH 28/59] update path Signed-off-by: Tianle Huang --- .../configuration_provider/server/routes/index.test.ts | 8 ++++---- src/plugins/configuration_provider/server/routes/index.ts | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts index 9da9feb86255..6cca295d3588 100644 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -37,28 +37,28 @@ describe('configuration provider routes', () => { expect(router.get).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration/existsCspRules', + path: '/api/config/csp/exists', }), expect.any(Function) ); expect(router.get).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration/getCspRules', + path: '/api/config/csp/get', }), expect.any(Function) ); expect(router.post).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration/updateCspRules', + path: '/api/config/csp/update', }), expect.any(Function) ); expect(router.post).toHaveBeenCalledWith( expect.objectContaining({ - path: '/api/configuration/deleteCspRules', + path: '/api/config/csp/delete', }), expect.any(Function) ); diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts index a7efbc4620c2..455bdebe7e83 100644 --- a/src/plugins/configuration_provider/server/routes/index.ts +++ b/src/plugins/configuration_provider/server/routes/index.ts @@ -20,7 +20,7 @@ export function defineRoutes( ) { router.get( { - path: '/api/configuration/existsCspRules', + path: '/api/config/csp/exists', validate: false, }, async (context, request, response) => { @@ -32,7 +32,7 @@ export function defineRoutes( router.get( { - path: '/api/configuration/getCspRules', + path: '/api/config/csp/get', validate: false, }, async (context, request, response) => { @@ -44,7 +44,7 @@ export function defineRoutes( router.post( { - path: '/api/configuration/updateCspRules', + path: '/api/config/csp/update', validate: { body: schema.object({ value: schema.string(), @@ -60,7 +60,7 @@ export function defineRoutes( router.post( { - path: '/api/configuration/deleteCspRules', + path: '/api/config/csp/delete', validate: false, }, async (context, request, response) => { From e9bfdc664e09ff3e7783274eac2600022c1ce25d Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 25 Jan 2024 19:43:22 +0000 Subject: [PATCH 29/59] rename index name Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 2 +- src/plugins/configuration_provider/server/plugin.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index 99d7dcf76e6f..ce39c1ce415f 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -2,7 +2,7 @@ A OpenSearch Dashboards plugin -This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.dynamic_config_index` in OSD YAML file `opensearch_dashboards.yml`. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. +This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.config_index` in OSD YAML file `opensearch_dashboards.yml`. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. The first use case onboarding to this new index is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from the new index and then rewrite to CSP header. The plugin exposes query and update APIs for OSD users to use against CSP rules. Currently there is no new OSD page for ease of user interactions with the APIs. Users are able to call the API endpoint directly, e.g through CURL. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. diff --git a/src/plugins/configuration_provider/server/plugin.ts b/src/plugins/configuration_provider/server/plugin.ts index 87f29a560572..908c6e7d9403 100644 --- a/src/plugins/configuration_provider/server/plugin.ts +++ b/src/plugins/configuration_provider/server/plugin.ts @@ -65,7 +65,7 @@ export class ConfigurationProviderPlugin const config = await this.config$.pipe(first()).toPromise(); - this.configurationIndexName = config.opensearchDashboards.dynamic_config_index; + this.configurationIndexName = config.opensearchDashboards.config_index; core.http.registerOnPreResponse( createCspRulesPreResponseHandler(core, this.getConfigurationClient.bind(this), this.logger) From f4d9f63540315c02823b8ce287369a35ca8badab Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 25 Jan 2024 19:58:46 +0000 Subject: [PATCH 30/59] update wording Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index ce39c1ce415f..f0525921b8fd 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -10,7 +10,7 @@ The first use case onboarding to this new index is to support updating Content S ## Configuration -By default, the new index does not exist. For OSD users who do not need customized CSP rules, there is no need to create this index. The system will then use whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. +By default, the new index does not exist. For OSD users who do not need customized CSP rules, the index won't exist at all. The system will then use whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. Below is the current default value. From e4efc0ecdce1e8de3cf7ef87ae718265fddc2b29 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 30 Jan 2024 01:52:04 +0000 Subject: [PATCH 31/59] make the new plugin disabled by default Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/config.ts | 12 ++++++++++++ src/plugins/configuration_provider/server/index.ts | 7 ++++++- 2 files changed, 18 insertions(+), 1 deletion(-) create mode 100644 src/plugins/configuration_provider/config.ts diff --git a/src/plugins/configuration_provider/config.ts b/src/plugins/configuration_provider/config.ts new file mode 100644 index 000000000000..9ae3ef7dafc2 --- /dev/null +++ b/src/plugins/configuration_provider/config.ts @@ -0,0 +1,12 @@ +/* + * Copyright OpenSearch Contributors + * SPDX-License-Identifier: Apache-2.0 + */ + +import { schema, TypeOf } from '@osd/config-schema'; + +export const configSchema = schema.object({ + enabled: schema.boolean({ defaultValue: false }), +}); + +export type ConfigurationProviderConfigSchema = TypeOf; diff --git a/src/plugins/configuration_provider/server/index.ts b/src/plugins/configuration_provider/server/index.ts index d770a56b9544..51b6a36d70ea 100644 --- a/src/plugins/configuration_provider/server/index.ts +++ b/src/plugins/configuration_provider/server/index.ts @@ -3,12 +3,17 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { PluginInitializerContext } from '../../../core/server'; +import { PluginConfigDescriptor, PluginInitializerContext } from '../../../core/server'; +import { ConfigurationProviderConfigSchema, configSchema } from '../config'; import { ConfigurationProviderPlugin } from './plugin'; // This exports static code and TypeScript types, // as well as, OpenSearch Dashboards Platform `plugin()` initializer. +export const config: PluginConfigDescriptor = { + schema: configSchema, +}; + export function plugin(initializerContext: PluginInitializerContext) { return new ConfigurationProviderPlugin(initializerContext); } From b8be888adcd134592d7bba121dd459ca207b1a97 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 30 Jan 2024 19:53:12 +0000 Subject: [PATCH 32/59] do not update defaults to avoid breaking change Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 - src/core/server/csp/config.ts | 1 - src/core/server/csp/csp_config.test.ts | 9 +++---- .../http_resources_service.test.ts | 12 ++++----- .../server/provider.test.ts | 26 +++++++------------ .../server/routes/index.test.ts | 20 ++++++-------- 6 files changed, 27 insertions(+), 42 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ae434a6c16d0..83b3827ba731 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) ## [Unreleased] ### 💥 Breaking Changes -- Support dynamic CSP rules to mitigate clickjacking ([#5641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641)) ### Deprecations diff --git a/src/core/server/csp/config.ts b/src/core/server/csp/config.ts index 6e0d2e8aac91..3cb120b47730 100644 --- a/src/core/server/csp/config.ts +++ b/src/core/server/csp/config.ts @@ -45,7 +45,6 @@ export const config = { `script-src 'unsafe-eval' 'self'`, `worker-src blob: 'self'`, `style-src 'unsafe-inline' 'self'`, - `frame-ancestors 'self'`, ], }), strict: schema.boolean({ defaultValue: false }), diff --git a/src/core/server/csp/csp_config.test.ts b/src/core/server/csp/csp_config.test.ts index 61c6f0a73c8b..cd452a7d8c42 100644 --- a/src/core/server/csp/csp_config.test.ts +++ b/src/core/server/csp/csp_config.test.ts @@ -47,12 +47,11 @@ describe('CspConfig', () => { test('DEFAULT', () => { expect(CspConfig.DEFAULT).toMatchInlineSnapshot(` CspConfig { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", "rules": Array [ "script-src 'unsafe-eval' 'self'", "worker-src blob: 'self'", "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", ], "strict": false, "warnLegacyBrowsers": true, @@ -63,12 +62,11 @@ describe('CspConfig', () => { test('defaults from config', () => { expect(new CspConfig()).toMatchInlineSnapshot(` CspConfig { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", "rules": Array [ "script-src 'unsafe-eval' 'self'", "worker-src blob: 'self'", "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", ], "strict": false, "warnLegacyBrowsers": true, @@ -79,12 +77,11 @@ describe('CspConfig', () => { test('creates from partial config', () => { expect(new CspConfig({ strict: true, warnLegacyBrowsers: false })).toMatchInlineSnapshot(` CspConfig { - "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "header": "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", "rules": Array [ "script-src 'unsafe-eval' 'self'", "worker-src blob: 'self'", "style-src 'unsafe-inline' 'self'", - "frame-ancestors 'self'", ], "strict": true, "warnLegacyBrowsers": false, diff --git a/src/core/server/http_resources/http_resources_service.test.ts b/src/core/server/http_resources/http_resources_service.test.ts index 1f5948823232..4a61c977e7ff 100644 --- a/src/core/server/http_resources/http_resources_service.test.ts +++ b/src/core/server/http_resources/http_resources_service.test.ts @@ -101,7 +101,7 @@ describe('HttpResources service', () => { headers: { 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", }, }); }); @@ -150,7 +150,7 @@ describe('HttpResources service', () => { headers: { 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", }, }); }); @@ -173,7 +173,7 @@ describe('HttpResources service', () => { headers: { 'content-type': 'text/html', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", }, }); }); @@ -205,7 +205,7 @@ describe('HttpResources service', () => { 'content-type': 'text/html', 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", }, }); }); @@ -228,7 +228,7 @@ describe('HttpResources service', () => { headers: { 'content-type': 'text/javascript', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", }, }); }); @@ -260,7 +260,7 @@ describe('HttpResources service', () => { 'content-type': 'text/javascript', 'x-opensearch-dashboards': '42', 'content-security-policy': - "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'", + "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'", }, }); }); diff --git a/src/plugins/configuration_provider/server/provider.test.ts b/src/plugins/configuration_provider/server/provider.test.ts index 9abcf80be4f4..21de2545edbe 100644 --- a/src/plugins/configuration_provider/server/provider.test.ts +++ b/src/plugins/configuration_provider/server/provider.test.ts @@ -15,6 +15,7 @@ import { ResponseError } from '@opensearch-project/opensearch/lib/errors'; const INDEX_NAME = 'test_index'; const INDEX_DOCUMENT_NAME = 'csp.rules'; const ERROR_MESSAGE = 'Service unavailable'; +const CSP_RULES = "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'"; describe('OpenSearchConfigurationClient', () => { let opensearchClient: ScopedClusterClientMock; @@ -89,12 +90,10 @@ describe('OpenSearchConfigurationClient', () => { describe('getCspRules', () => { it('returns the csp rules from the index', async () => { - const cspRules = "frame-ancestors 'self'"; - opensearchClient.asInternalUser.get.mockImplementation(() => { return opensearchClientMock.createSuccessTransportRequestPromise({ _source: { - value: cspRules, + value: CSP_RULES, }, } as GetResponse); }); @@ -102,7 +101,7 @@ describe('OpenSearchConfigurationClient', () => { const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); const getValue = await client.getCspRules(); - expect(getValue).toBe(cspRules); + expect(getValue).toBe(CSP_RULES); expect(opensearchClient.asInternalUser.get).toBeCalledWith({ index: INDEX_NAME, @@ -134,12 +133,10 @@ describe('OpenSearchConfigurationClient', () => { }); it('returns empty when value field is missing in opensearch response', async () => { - const cspRules = "frame-ancestors 'self'"; - opensearchClient.asInternalUser.get.mockImplementation(() => { return opensearchClientMock.createSuccessTransportRequestPromise({ _source: { - value_typo: cspRules, + value_typo: CSP_RULES, }, } as GetResponse); }); @@ -179,27 +176,24 @@ describe('OpenSearchConfigurationClient', () => { describe('updateCspRules', () => { it('runs updated value when opensearch successfully updates', async () => { - const cspRules = "frame-ancestors 'self'"; - opensearchClient.asCurrentUser.index.mockImplementation(() => { return opensearchClientMock.createSuccessTransportRequestPromise({}); }); const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const updated = await client.updateCspRules(cspRules); + const updated = await client.updateCspRules(CSP_RULES); - expect(updated).toBe(cspRules); + expect(updated).toBe(CSP_RULES); expect(opensearchClient.asCurrentUser.index).toBeCalledWith( - getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, cspRules) + getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, CSP_RULES) ); expect(logger.error).not.toBeCalled(); }); it('throws exception when opensearch throws exception', async () => { - const cspRules = "frame-ancestors 'self'"; const error = new Error(ERROR_MESSAGE); opensearchClient.asCurrentUser.index.mockImplementation(() => { return opensearchClientMock.createErrorTransportRequestPromise(error); @@ -207,14 +201,14 @@ describe('OpenSearchConfigurationClient', () => { const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - await expect(client.updateCspRules(cspRules)).rejects.toThrowError(ERROR_MESSAGE); + await expect(client.updateCspRules(CSP_RULES)).rejects.toThrowError(ERROR_MESSAGE); expect(opensearchClient.asCurrentUser.index).toBeCalledWith( - getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, cspRules) + getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, CSP_RULES) ); expect(logger.error).toBeCalledWith( - `Failed to call updateCspRules with cspRules ${cspRules} due to error ${error}` + `Failed to call updateCspRules with cspRules ${CSP_RULES} due to error ${error}` ); }); }); diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts index 6cca295d3588..b8b7aa197c2d 100644 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ b/src/plugins/configuration_provider/server/routes/index.test.ts @@ -20,6 +20,8 @@ const ERROR_RESPONSE = { statusCode: 500, }; +const CSP_RULES = "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'"; + describe('configuration provider routes', () => { describe('defineRoutes', () => { it('check route paths are defined', () => { @@ -161,10 +163,8 @@ describe('configuration provider routes', () => { describe('handleGetCspRules', () => { it('return CSP rules when client returns CSP rules', async () => { - const cspRules = "frame-ancestors 'self'"; - const client = { - getCspRules: jest.fn().mockReturnValue(cspRules), + getCspRules: jest.fn().mockReturnValue(CSP_RULES), }; const okResponse = { @@ -185,7 +185,7 @@ describe('configuration provider routes', () => { expect(response.ok).toBeCalledWith({ body: { - cspRules, + cspRules: CSP_RULES, }, }); @@ -224,10 +224,8 @@ describe('configuration provider routes', () => { describe('handleUpdateCspRules', () => { it('return updated CSP rules when client updates CSP rules', async () => { - const cspRules = "frame-ancestors 'self'"; - const client = { - updateCspRules: jest.fn().mockReturnValue(cspRules), + updateCspRules: jest.fn().mockReturnValue(CSP_RULES), }; const okResponse = { @@ -236,7 +234,7 @@ describe('configuration provider routes', () => { const request = { body: { - value: cspRules, + value: CSP_RULES, }, }; @@ -254,7 +252,7 @@ describe('configuration provider routes', () => { expect(response.ok).toBeCalledWith({ body: { - updatedRules: cspRules, + updatedRules: CSP_RULES, }, }); @@ -262,8 +260,6 @@ describe('configuration provider routes', () => { }); it('return error response when client throws error', async () => { - const cspRules = "frame-ancestors 'self'"; - const error = new Error(ERROR_MESSAGE); const client = { @@ -274,7 +270,7 @@ describe('configuration provider routes', () => { const request = { body: { - value: cspRules, + value: CSP_RULES, }, }; From e58875820ce8497f9b573b257c3fce0c61bb373c Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 31 Jan 2024 19:54:45 +0000 Subject: [PATCH 33/59] update readme to reflect new API path Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index f0525921b8fd..e7b23171dc82 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -23,27 +23,27 @@ For OSD users who want to make changes to allow a new site to embed OSD pages, t (Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) ``` -curl '{osd endpoint}/api/configuration/updateCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' +curl '{osd endpoint}/api/config/csp/update' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' ``` Below is the CURL command to delete CSP rules. ``` -curl '{osd endpoint}/api/configuration/deleteCspRules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' +curl '{osd endpoint}/api/config/csp/delete' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' ``` Below is the CURL command to check if CSP rules exist in the new index. ``` -curl '{osd endpoint}/api/configuration/existsCspRules' +curl '{osd endpoint}/api/config/csp/exists' ``` Below is the CURL command to get the CSP rules from the new index. ``` -curl '{osd endpoint}/api/configuration/getCspRules' +curl '{osd endpoint}/api/config/csp/get' ``` From 6bc00ce059d875e9b7ce9696954cfe54385ee2c3 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Sat, 3 Feb 2024 01:54:50 +0000 Subject: [PATCH 34/59] update handler to append frame-ancestors conditionally Signed-off-by: Tianle Huang --- .../server/csp_handlers.test.ts | 176 ++++++++++++++++-- .../server/csp_handlers.ts | 28 ++- .../configuration_provider/server/plugin.ts | 7 +- 3 files changed, 194 insertions(+), 17 deletions(-) diff --git a/src/plugins/configuration_provider/server/csp_handlers.test.ts b/src/plugins/configuration_provider/server/csp_handlers.test.ts index 24dd5f668460..f2f171147fa6 100644 --- a/src/plugins/configuration_provider/server/csp_handlers.test.ts +++ b/src/plugins/configuration_provider/server/csp_handlers.test.ts @@ -45,16 +45,22 @@ describe('CSP handlers', () => { it('adds the CSP headers provided by the client', async () => { const coreSetup = coreMock.createSetup(); - const cspRules = "frame-ancestors 'self'"; + const cspRulesFromIndex = "frame-ancestors 'self'"; + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { existsCspRules: jest.fn().mockReturnValue(true), - getCspRules: jest.fn().mockReturnValue(cspRules), + getCspRules: jest.fn().mockReturnValue(cspRulesFromIndex), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -67,7 +73,7 @@ describe('CSP handlers', () => { expect(toolkit.next).toHaveBeenCalledWith({ headers: { - 'content-security-policy': cspRules, + 'content-security-policy': cspRulesFromIndex, }, }); @@ -75,9 +81,10 @@ describe('CSP handlers', () => { expect(configurationClient.getCspRules).toBeCalledTimes(1); }); - it('do not add CSP headers when the client returns empty', async () => { + it('do not add CSP headers when the client returns empty and CSP from YML already has frame-ancestors', async () => { const coreSetup = coreMock.createSetup(); const emptyCspRules = ''; + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'; frame-ancestors 'self'"; const configurationClient = { existsCspRules: jest.fn().mockReturnValue(true), @@ -86,7 +93,12 @@ describe('CSP handlers', () => { const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -102,8 +114,46 @@ describe('CSP handlers', () => { expect(configurationClient.getCspRules).toBeCalledTimes(1); }); - it('do not add CSP headers when the configuration does not exist', async () => { + it('add frame-ancestors CSP headers when the client returns empty and CSP from YML has no frame-ancestors', async () => { + const coreSetup = coreMock.createSetup(); + const emptyCspRules = ''; + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; + + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(true), + getCspRules: jest.fn().mockReturnValue(emptyCspRules), + }; + + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); + + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toHaveBeenCalledTimes(1); + expect(toolkit.next).toHaveBeenCalledWith({ + headers: { + 'content-security-policy': "frame-ancestors 'self'; " + cspRulesFromYML, + }, + }); + + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).toBeCalledTimes(1); + }); + + it('do not add CSP headers when the configuration does not exist and CSP from YML already has frame-ancestors', async () => { const coreSetup = coreMock.createSetup(); + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'; frame-ancestors 'self'"; const configurationClient = { existsCspRules: jest.fn().mockReturnValue(false), @@ -112,7 +162,12 @@ describe('CSP handlers', () => { const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -128,8 +183,45 @@ describe('CSP handlers', () => { expect(configurationClient.getCspRules).toBeCalledTimes(0); }); + it('add frame-ancestors CSP headers when the configuration does not exist and CSP from YML has no frame-ancestors', async () => { + const coreSetup = coreMock.createSetup(); + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; + + const configurationClient = { + existsCspRules: jest.fn().mockReturnValue(false), + getCspRules: jest.fn(), + }; + + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); + + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toBeCalledTimes(1); + expect(toolkit.next).toBeCalledWith({ + headers: { + 'content-security-policy': "frame-ancestors 'self'; " + cspRulesFromYML, + }, + }); + + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).toBeCalledTimes(0); + }); + it('do not add CSP headers when request dest exists and shall skip', async () => { const coreSetup = coreMock.createSetup(); + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { existsCspRules: jest.fn(), @@ -138,7 +230,12 @@ describe('CSP handlers', () => { const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); const cssSecFetchDest = 'css'; const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': cssSecFetchDest } }); @@ -158,6 +255,7 @@ describe('CSP handlers', () => { it('do not add CSP headers when request dest does not exist', async () => { const coreSetup = coreMock.createSetup(); + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { existsCspRules: jest.fn(), @@ -166,7 +264,12 @@ describe('CSP handlers', () => { const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); const request = forgeRequest({ method: 'get', headers: {} }); @@ -183,9 +286,10 @@ describe('CSP handlers', () => { expect(configurationClient.getCspRules).toBeCalledTimes(0); }); - it('do not the CSP headers when error happens', async () => { + it('do not the CSP headers when error happens and CSP from YML already has frame-ancestors', async () => { const coreSetup = coreMock.createSetup(); const error = new Error(ERROR_MESSAGE); + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'; frame-ancestors 'self'"; const configurationClient = { existsCspRules: jest.fn().mockImplementation(() => { @@ -196,7 +300,12 @@ describe('CSP handlers', () => { const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - const handler = createCspRulesPreResponseHandler(coreSetup, getConfigurationClient, logger); + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); toolkit.next.mockReturnValue('next' as any); @@ -215,4 +324,47 @@ describe('CSP handlers', () => { `Failure happened in CSP rules pre response handler due to ${error}` ); }); + + it('add frame-ancestors CSP headers when error happens and CSP from YML has no frame-ancestors', async () => { + const coreSetup = coreMock.createSetup(); + const error = new Error(ERROR_MESSAGE); + const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; + + const configurationClient = { + existsCspRules: jest.fn().mockImplementation(() => { + throw error; + }), + getCspRules: jest.fn(), + }; + + const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); + + const handler = createCspRulesPreResponseHandler( + coreSetup, + cspRulesFromYML, + getConfigurationClient, + logger + ); + const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + toolkit.next.mockReturnValue('next' as any); + + const result = await handler(request, {} as any, toolkit); + + expect(result).toEqual('next'); + + expect(toolkit.next).toHaveBeenCalledTimes(1); + expect(toolkit.next).toBeCalledWith({ + headers: { + 'content-security-policy': "frame-ancestors 'self'; " + cspRulesFromYML, + }, + }); + + expect(configurationClient.existsCspRules).toBeCalledTimes(1); + expect(configurationClient.getCspRules).not.toBeCalled(); + + expect(logger.error).toBeCalledWith( + `Failure happened in CSP rules pre response handler due to ${error}` + ); + }); }); diff --git a/src/plugins/configuration_provider/server/csp_handlers.ts b/src/plugins/configuration_provider/server/csp_handlers.ts index 916dfebb8172..c06128a77e97 100644 --- a/src/plugins/configuration_provider/server/csp_handlers.ts +++ b/src/plugins/configuration_provider/server/csp_handlers.ts @@ -8,15 +8,23 @@ import { IScopedClusterClient, Logger, OnPreResponseHandler, + OnPreResponseInfo, + OnPreResponseToolkit, + OpenSearchDashboardsRequest, } from '../../../core/server'; import { ConfigurationClient } from './types'; export function createCspRulesPreResponseHandler( core: CoreSetup, + cspHeader: string, getConfigurationClient: (inputOpenSearchClient: IScopedClusterClient) => ConfigurationClient, logger: Logger ): OnPreResponseHandler { - return async (request, response, toolkit) => { + return async ( + request: OpenSearchDashboardsRequest, + response: OnPreResponseInfo, + toolkit: OnPreResponseToolkit + ) => { try { const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; @@ -33,13 +41,13 @@ export function createCspRulesPreResponseHandler( const existsValue = await myClient.existsCspRules(); if (!existsValue) { - return toolkit.next({}); + return updateFrameAncestors(cspHeader, toolkit); } const cspRules = await myClient.getCspRules(); if (!cspRules) { - return toolkit.next({}); + return updateFrameAncestors(cspHeader, toolkit); } const additionalHeaders = { @@ -49,7 +57,19 @@ export function createCspRulesPreResponseHandler( return toolkit.next({ headers: additionalHeaders }); } catch (e) { logger.error(`Failure happened in CSP rules pre response handler due to ${e}`); - return toolkit.next({}); + return updateFrameAncestors(cspHeader, toolkit); } }; } + +function updateFrameAncestors(cspHeader: string, toolkit: OnPreResponseToolkit) { + if (cspHeader.includes('frame-ancestors')) { + return toolkit.next({}); + } + + const additionalHeaders = { + 'content-security-policy': "frame-ancestors 'self'; " + cspHeader, + }; + + return toolkit.next({ headers: additionalHeaders }); +} diff --git a/src/plugins/configuration_provider/server/plugin.ts b/src/plugins/configuration_provider/server/plugin.ts index 908c6e7d9403..705240227ca6 100644 --- a/src/plugins/configuration_provider/server/plugin.ts +++ b/src/plugins/configuration_provider/server/plugin.ts @@ -68,7 +68,12 @@ export class ConfigurationProviderPlugin this.configurationIndexName = config.opensearchDashboards.config_index; core.http.registerOnPreResponse( - createCspRulesPreResponseHandler(core, this.getConfigurationClient.bind(this), this.logger) + createCspRulesPreResponseHandler( + core, + core.http.csp.header, + this.getConfigurationClient.bind(this), + this.logger + ) ); return { From 8f682288089a0c04bbd048b89c720eada6eff7c0 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 6 Feb 2024 03:03:15 +0000 Subject: [PATCH 35/59] update readme Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index e7b23171dc82..918400dc9bdb 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -2,23 +2,16 @@ A OpenSearch Dashboards plugin -This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.config_index` in OSD YAML file `opensearch_dashboards.yml`. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. +This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file `opensearch_dashboards.yml`. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.config_index` in OSD YAML file. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. This plugin is by default disabled and could be enabled by setting `configuration_provider.enabled` in OSD YAML to true. The first use case onboarding to this new index is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from the new index and then rewrite to CSP header. The plugin exposes query and update APIs for OSD users to use against CSP rules. Currently there is no new OSD page for ease of user interactions with the APIs. Users are able to call the API endpoint directly, e.g through CURL. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. +By default, the new index does not exist. For OSD users who do not need customized CSP rules, the index won't exist at all. The plugin will check whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. If the aggregated CSP rules don't contain the CSP directive `frame-ancestors` which specifies valid parents that may embed OSD page, then the plugin will append `frame-ancestors 'self'` to prevent Clickjacking. + --- ## Configuration -By default, the new index does not exist. For OSD users who do not need customized CSP rules, the index won't exist at all. The system will then use whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. - -Below is the current default value. - -``` -"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self'" -``` -(Note that `frame-ancestors 'self'` is used to only allow self embedding and prevent clickjacking by default.) - For OSD users who want to make changes to allow a new site to embed OSD pages, they can update CSP rules through CURL. (Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) From 4dbcc211cf24d4b82379f26aed5a1dd0c44a6d1e Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 29 Feb 2024 21:44:13 +0000 Subject: [PATCH 36/59] clean up code to prepare for application config Signed-off-by: Tianle Huang --- .../configuration_provider/.eslintrc.js | 7 - .../configuration_provider/.i18nrc.json | 9 - .../configuration_provider/server/plugin.ts | 53 +-- .../server/provider.test.ts | 326 ------------- .../configuration_provider/server/provider.ts | 107 ----- .../server/routes/index.test.ts | 431 ------------------ .../configuration_provider/server/types.ts | 10 - 7 files changed, 5 insertions(+), 938 deletions(-) delete mode 100644 src/plugins/configuration_provider/.eslintrc.js delete mode 100644 src/plugins/configuration_provider/.i18nrc.json delete mode 100644 src/plugins/configuration_provider/server/provider.test.ts delete mode 100644 src/plugins/configuration_provider/server/provider.ts delete mode 100644 src/plugins/configuration_provider/server/routes/index.test.ts diff --git a/src/plugins/configuration_provider/.eslintrc.js b/src/plugins/configuration_provider/.eslintrc.js deleted file mode 100644 index b16a8b23a08e..000000000000 --- a/src/plugins/configuration_provider/.eslintrc.js +++ /dev/null @@ -1,7 +0,0 @@ -module.exports = { - root: true, - extends: ['@elastic/eslint-config-kibana', 'plugin:@elastic/eui/recommended'], - rules: { - '@osd/eslint/require-license-header': 'off', - }, -}; diff --git a/src/plugins/configuration_provider/.i18nrc.json b/src/plugins/configuration_provider/.i18nrc.json deleted file mode 100644 index ef54ab11b215..000000000000 --- a/src/plugins/configuration_provider/.i18nrc.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "prefix": "configurationProvider", - "paths": { - "configurationProvider": "." - }, - "translations": [ - "translations/ja-JP.json" - ] -} \ No newline at end of file diff --git a/src/plugins/configuration_provider/server/plugin.ts b/src/plugins/configuration_provider/server/plugin.ts index 705240227ca6..59f0969f3a32 100644 --- a/src/plugins/configuration_provider/server/plugin.ts +++ b/src/plugins/configuration_provider/server/plugin.ts @@ -3,82 +3,39 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { Observable } from 'rxjs'; -import { first } from 'rxjs/operators'; import { CoreSetup, CoreStart, - IScopedClusterClient, Logger, Plugin, PluginInitializerContext, - SharedGlobalConfig, } from '../../../core/server'; import { createCspRulesPreResponseHandler } from './csp_handlers'; -import { OpenSearchConfigurationClient } from './provider'; -import { defineRoutes } from './routes'; -import { - ConfigurationClient, - ConfigurationProviderPluginSetup, - ConfigurationProviderPluginStart, -} from './types'; +import { ConfigurationProviderPluginSetup, ConfigurationProviderPluginStart } from './types'; export class ConfigurationProviderPlugin implements Plugin { private readonly logger: Logger; - private readonly config$: Observable; - private configurationClient: ConfigurationClient; - private configurationIndexName: string; constructor(initializerContext: PluginInitializerContext) { this.logger = initializerContext.logger.get(); - this.config$ = initializerContext.config.legacy.globalConfig$; - this.configurationIndexName = ''; - } - - private setConfigurationClient(inputConfigurationClient: ConfigurationClient) { - this.configurationClient = inputConfigurationClient; - } - - private getConfigurationClient(inputOpenSearchClient: IScopedClusterClient) { - if (this.configurationClient) { - return this.configurationClient; - } - - const openSearchConfigurationClient = new OpenSearchConfigurationClient( - inputOpenSearchClient, - this.configurationIndexName, - this.logger - ); - - this.setConfigurationClient(openSearchConfigurationClient); - return this.configurationClient; } public async setup(core: CoreSetup) { - this.logger.debug('ConfigurationProvider: Setup'); - const router = core.http.createRouter(); - - // Register server side APIs - defineRoutes(router, this.getConfigurationClient.bind(this), this.logger); - - const config = await this.config$.pipe(first()).toPromise(); - - this.configurationIndexName = config.opensearchDashboards.config_index; + // TODO: replace this with real + const getConfigurationClient = {}; core.http.registerOnPreResponse( createCspRulesPreResponseHandler( core, core.http.csp.header, - this.getConfigurationClient.bind(this), + getConfigurationClient, this.logger ) ); - return { - setConfigurationClient: this.setConfigurationClient.bind(this), - }; + return {}; } public start(core: CoreStart) { diff --git a/src/plugins/configuration_provider/server/provider.test.ts b/src/plugins/configuration_provider/server/provider.test.ts deleted file mode 100644 index 21de2545edbe..000000000000 --- a/src/plugins/configuration_provider/server/provider.test.ts +++ /dev/null @@ -1,326 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { - ScopedClusterClientMock, - opensearchClientMock, -} from '../../../core/server/opensearch/client/mocks'; -import { OpenSearchConfigurationClient } from './provider'; -import { MockedLogger, loggerMock } from '@osd/logging/target/mocks'; -import { GetResponse } from 'src/core/server'; -import { ResponseError } from '@opensearch-project/opensearch/lib/errors'; - -const INDEX_NAME = 'test_index'; -const INDEX_DOCUMENT_NAME = 'csp.rules'; -const ERROR_MESSAGE = 'Service unavailable'; -const CSP_RULES = "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'"; - -describe('OpenSearchConfigurationClient', () => { - let opensearchClient: ScopedClusterClientMock; - let logger: MockedLogger; - - beforeEach(() => { - jest.resetAllMocks(); - opensearchClient = opensearchClientMock.createScopedClusterClient(); - logger = loggerMock.create(); - }); - - afterEach(() => {}); - - describe('existsCspRules', () => { - it('returns true if the target index does exists', async () => { - const indexExists = true; - opensearchClient.asInternalUser.exists.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const value = await client.existsCspRules(); - - expect(value).toBeTruthy(); - - expect(opensearchClient.asInternalUser.exists).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('returns false if the target index does not exists', async () => { - const indexExists = false; - opensearchClient.asInternalUser.exists.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise(indexExists); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const existsValue = await client.existsCspRules(); - - expect(existsValue).toBeFalsy(); - - expect(opensearchClient.asInternalUser.exists).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('throws error if opensearch errors happen', async () => { - const error = new Error(ERROR_MESSAGE); - - opensearchClient.asInternalUser.exists.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(error); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - - await expect(client.existsCspRules()).rejects.toThrowError(ERROR_MESSAGE); - - expect(opensearchClient.asInternalUser.exists).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).toBeCalledWith(`Failed to call cspRulesExists due to error ${error}`); - }); - }); - - describe('getCspRules', () => { - it('returns the csp rules from the index', async () => { - opensearchClient.asInternalUser.get.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({ - _source: { - value: CSP_RULES, - }, - } as GetResponse); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const getValue = await client.getCspRules(); - - expect(getValue).toBe(CSP_RULES); - - expect(opensearchClient.asInternalUser.get).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('throws error when opensearch response is malformed', async () => { - opensearchClient.asInternalUser.get.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({ - _index: INDEX_NAME, - } as GetResponse); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - - await expect(client.getCspRules()).rejects.toThrowError(); - - expect(opensearchClient.asInternalUser.get).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).toBeCalledWith( - "Failed to call getCspRules due to error TypeError: Cannot read properties of undefined (reading 'value')" - ); - }); - - it('returns empty when value field is missing in opensearch response', async () => { - opensearchClient.asInternalUser.get.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({ - _source: { - value_typo: CSP_RULES, - }, - } as GetResponse); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const getValue = await client.getCspRules(); - - expect(getValue).toBe(''); - - expect(opensearchClient.asInternalUser.get).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('throws error when opensearch errors happen', async () => { - const error = new Error(ERROR_MESSAGE); - - opensearchClient.asInternalUser.get.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(error); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - - await expect(client.getCspRules()).rejects.toThrowError(ERROR_MESSAGE); - - expect(opensearchClient.asInternalUser.get).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).toBeCalledWith(`Failed to call getCspRules due to error ${error}`); - }); - }); - - describe('updateCspRules', () => { - it('runs updated value when opensearch successfully updates', async () => { - opensearchClient.asCurrentUser.index.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({}); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - - const updated = await client.updateCspRules(CSP_RULES); - - expect(updated).toBe(CSP_RULES); - - expect(opensearchClient.asCurrentUser.index).toBeCalledWith( - getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, CSP_RULES) - ); - - expect(logger.error).not.toBeCalled(); - }); - - it('throws exception when opensearch throws exception', async () => { - const error = new Error(ERROR_MESSAGE); - opensearchClient.asCurrentUser.index.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(error); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - - await expect(client.updateCspRules(CSP_RULES)).rejects.toThrowError(ERROR_MESSAGE); - - expect(opensearchClient.asCurrentUser.index).toBeCalledWith( - getIndexInput(INDEX_NAME, INDEX_DOCUMENT_NAME, CSP_RULES) - ); - - expect(logger.error).toBeCalledWith( - `Failed to call updateCspRules with cspRules ${CSP_RULES} due to error ${error}` - ); - }); - }); - - describe('deleteCspRules', () => { - it('return deleted document ID when deletion succeeds', async () => { - opensearchClient.asCurrentUser.delete.mockImplementation(() => { - return opensearchClientMock.createSuccessTransportRequestPromise({}); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const deleted = await client.deleteCspRules(); - - expect(deleted).toBe(INDEX_DOCUMENT_NAME); - - expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('throws exception when opensearch throws exception', async () => { - const error = new Error(ERROR_MESSAGE); - - opensearchClient.asCurrentUser.delete.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(error); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - - await expect(client.deleteCspRules()).rejects.toThrowError(ERROR_MESSAGE); - - expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).toBeCalledWith(`Failed to call deleteCspRules due to error ${error}`); - }); - - it('return deleted document ID when deletion fails due to index not found', async () => { - const error = new ResponseError({ - statusCode: 401, - body: { - error: { - type: 'index_not_found_exception', - }, - }, - warnings: [], - headers: { - 'WWW-Authenticate': 'content', - }, - meta: {} as any, - }); - - opensearchClient.asCurrentUser.delete.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(error); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const deletedCspRulesName = await client.deleteCspRules(); - - expect(deletedCspRulesName).toBe(INDEX_DOCUMENT_NAME); - - expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('return deleted document ID when deletion fails due to document not found', async () => { - const error = new ResponseError({ - statusCode: 401, - body: { - result: 'not_found', - }, - warnings: [], - headers: { - 'WWW-Authenticate': 'content', - }, - meta: {} as any, - }); - - opensearchClient.asCurrentUser.delete.mockImplementation(() => { - return opensearchClientMock.createErrorTransportRequestPromise(error); - }); - - const client = new OpenSearchConfigurationClient(opensearchClient, INDEX_NAME, logger); - const deletedCspRulesName = await client.deleteCspRules(); - - expect(deletedCspRulesName).toBe(INDEX_DOCUMENT_NAME); - - expect(opensearchClient.asCurrentUser.delete).toBeCalledWith({ - index: INDEX_NAME, - id: INDEX_DOCUMENT_NAME, - }); - - expect(logger.error).not.toBeCalled(); - }); - }); -}); - -function getIndexInput(indexName: string, documentName: string, cspRules: string) { - return { - index: indexName, - id: documentName, - body: { - value: cspRules, - }, - }; -} diff --git a/src/plugins/configuration_provider/server/provider.ts b/src/plugins/configuration_provider/server/provider.ts deleted file mode 100644 index da830c6412a4..000000000000 --- a/src/plugins/configuration_provider/server/provider.ts +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { IScopedClusterClient, Logger } from '../../../../src/core/server'; - -import { ConfigurationClient } from './types'; - -const CSP_RULES_DOC_ID = 'csp.rules'; - -export class OpenSearchConfigurationClient implements ConfigurationClient { - private client: IScopedClusterClient; - private configurationIndexName: string; - private readonly logger: Logger; - - constructor( - inputOpenSearchClient: IScopedClusterClient, - inputConfigurationIndexName: string, - inputLogger: Logger - ) { - this.client = inputOpenSearchClient; - this.configurationIndexName = inputConfigurationIndexName; - this.logger = inputLogger; - } - - async existsCspRules(): Promise { - try { - const exists = await this.client.asInternalUser.exists({ - index: this.configurationIndexName, - id: CSP_RULES_DOC_ID, - }); - - return exists.body; - } catch (e) { - const errorMessage = `Failed to call cspRulesExists due to error ${e}`; - - this.logger.error(errorMessage); - - throw e; - } - } - - async getCspRules(): Promise { - try { - const data = await this.client.asInternalUser.get({ - index: this.configurationIndexName, - id: CSP_RULES_DOC_ID, - }); - - return data.body._source.value || ''; - } catch (e) { - const errorMessage = `Failed to call getCspRules due to error ${e}`; - - this.logger.error(errorMessage); - - throw e; - } - } - - async updateCspRules(cspRules: string): Promise { - try { - await this.client.asCurrentUser.index({ - index: this.configurationIndexName, - id: CSP_RULES_DOC_ID, - body: { - value: cspRules, - }, - }); - - return cspRules; - } catch (e) { - const errorMessage = `Failed to call updateCspRules with cspRules ${cspRules} due to error ${e}`; - - this.logger.error(errorMessage); - - throw e; - } - } - - async deleteCspRules(): Promise { - try { - await this.client.asCurrentUser.delete({ - index: this.configurationIndexName, - id: CSP_RULES_DOC_ID, - }); - - return CSP_RULES_DOC_ID; - } catch (e) { - if (e?.body?.error?.type === 'index_not_found_exception') { - this.logger.info('Attemp to delete a not found index.'); - return CSP_RULES_DOC_ID; - } - - if (e?.body?.result === 'not_found') { - this.logger.info('Attemp to delete a not found document.'); - return CSP_RULES_DOC_ID; - } - - const errorMessage = `Failed to call deleteCspRules due to error ${e}`; - - this.logger.error(errorMessage); - - throw e; - } - } -} diff --git a/src/plugins/configuration_provider/server/routes/index.test.ts b/src/plugins/configuration_provider/server/routes/index.test.ts deleted file mode 100644 index b8b7aa197c2d..000000000000 --- a/src/plugins/configuration_provider/server/routes/index.test.ts +++ /dev/null @@ -1,431 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { - defineRoutes, - errorResponse, - handleDeleteCspRules, - handleExistsCspRules, - handleGetCspRules, - handleUpdateCspRules, -} from '.'; -import { loggerMock } from '@osd/logging/target/mocks'; -import { httpServiceMock } from '../../../../core/server/mocks'; - -const ERROR_MESSAGE = 'Service unavailable'; - -const ERROR_RESPONSE = { - statusCode: 500, -}; - -const CSP_RULES = "script-src 'unsafe-eval' 'self'; worker-src blob: 'self'"; - -describe('configuration provider routes', () => { - describe('defineRoutes', () => { - it('check route paths are defined', () => { - const router = httpServiceMock.createRouter(); - const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(true), - getCspRules: jest.fn().mockReturnValue(''), - }; - - const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - - const logger = loggerMock.create(); - - defineRoutes(router, getConfigurationClient, logger); - - expect(router.get).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/config/csp/exists', - }), - expect.any(Function) - ); - - expect(router.get).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/config/csp/get', - }), - expect.any(Function) - ); - - expect(router.post).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/config/csp/update', - }), - expect.any(Function) - ); - - expect(router.post).toHaveBeenCalledWith( - expect.objectContaining({ - path: '/api/config/csp/delete', - }), - expect.any(Function) - ); - }); - }); - - describe('handleExistsCspRules', () => { - it('return true when client returns true', async () => { - const existsValue = true; - - const client = { - existsCspRules: jest.fn().mockReturnValue(existsValue), - }; - - const okResponse = { - statusCode: 200, - }; - - const response = { - ok: jest.fn().mockReturnValue(okResponse), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleExistsCspRules(client, response, logger); - - expect(returnedResponse).toBe(okResponse); - - expect(client.existsCspRules).toBeCalledTimes(1); - - expect(response.ok).toBeCalledWith({ - body: { - exists: existsValue, - }, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('return false when client returns false', async () => { - const existsValue = false; - - const client = { - existsCspRules: jest.fn().mockReturnValue(existsValue), - }; - - const okResponse = { - statusCode: 200, - }; - - const response = { - ok: jest.fn().mockReturnValue(okResponse), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleExistsCspRules(client, response, logger); - - expect(returnedResponse).toBe(okResponse); - - expect(client.existsCspRules).toBeCalledTimes(1); - - expect(response.ok).toBeCalledWith({ - body: { - exists: existsValue, - }, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('return error response when client throws error', async () => { - const error = new Error(ERROR_MESSAGE); - const client = { - existsCspRules: jest.fn().mockImplementation(() => { - throw error; - }), - }; - - const response = { - custom: jest.fn().mockReturnValue(ERROR_RESPONSE), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleExistsCspRules(client, response, logger); - - expect(returnedResponse).toBe(ERROR_RESPONSE); - - expect(client.existsCspRules).toBeCalledTimes(1); - - expect(response.custom).toBeCalledWith({ - body: error, - statusCode: 500, - }); - - expect(logger.error).toBeCalledWith(error); - }); - }); - - describe('handleGetCspRules', () => { - it('return CSP rules when client returns CSP rules', async () => { - const client = { - getCspRules: jest.fn().mockReturnValue(CSP_RULES), - }; - - const okResponse = { - statusCode: 200, - }; - - const response = { - ok: jest.fn().mockReturnValue(okResponse), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleGetCspRules(client, response, logger); - - expect(returnedResponse).toBe(okResponse); - - expect(client.getCspRules).toBeCalledTimes(1); - - expect(response.ok).toBeCalledWith({ - body: { - cspRules: CSP_RULES, - }, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('return error response when client throws error', async () => { - const error = new Error(ERROR_MESSAGE); - - const client = { - getCspRules: jest.fn().mockImplementation(() => { - throw error; - }), - }; - - const response = { - custom: jest.fn().mockReturnValue(ERROR_RESPONSE), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleGetCspRules(client, response, logger); - - expect(returnedResponse).toBe(ERROR_RESPONSE); - - expect(client.getCspRules).toBeCalledTimes(1); - - expect(response.custom).toBeCalledWith({ - body: error, - statusCode: 500, - }); - - expect(logger.error).toBeCalledWith(error); - }); - }); - - describe('handleUpdateCspRules', () => { - it('return updated CSP rules when client updates CSP rules', async () => { - const client = { - updateCspRules: jest.fn().mockReturnValue(CSP_RULES), - }; - - const okResponse = { - statusCode: 200, - }; - - const request = { - body: { - value: CSP_RULES, - }, - }; - - const response = { - ok: jest.fn().mockReturnValue(okResponse), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleUpdateCspRules(client, request, response, logger); - - expect(returnedResponse).toBe(okResponse); - - expect(client.updateCspRules).toBeCalledTimes(1); - - expect(response.ok).toBeCalledWith({ - body: { - updatedRules: CSP_RULES, - }, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('return error response when client throws error', async () => { - const error = new Error(ERROR_MESSAGE); - - const client = { - updateCspRules: jest.fn().mockImplementation(() => { - throw error; - }), - }; - - const request = { - body: { - value: CSP_RULES, - }, - }; - - const response = { - custom: jest.fn().mockReturnValue(ERROR_RESPONSE), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleUpdateCspRules(client, request, response, logger); - - expect(returnedResponse).toBe(ERROR_RESPONSE); - - expect(client.updateCspRules).toBeCalledTimes(1); - - expect(response.custom).toBeCalledWith({ - body: error, - statusCode: 500, - }); - - expect(logger.error).toBeCalledWith(error); - }); - - it('return error response when input is empty', async () => { - const emptyCspRules = ' '; - const error = new Error('Cannot update CSP rules to emtpy!'); - - const client = { - updateCspRules: jest.fn(), - }; - - const request = { - body: { - value: emptyCspRules, - }, - }; - - const response = { - custom: jest.fn().mockReturnValue(ERROR_RESPONSE), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleUpdateCspRules(client, request, response, logger); - - expect(returnedResponse).toBe(ERROR_RESPONSE); - - expect(client.updateCspRules).not.toBeCalled(); - - expect(response.custom).toBeCalledWith({ - body: error, - statusCode: 500, - }); - - expect(logger.error).toBeCalledWith(error); - }); - }); - - describe('handleDeleteCspRules', () => { - it('return deleted CSP rules when client deletes CSP rules', async () => { - const cspRulesName = 'csp.rules'; - - const client = { - deleteCspRules: jest.fn().mockReturnValue(cspRulesName), - }; - - const okResponse = { - statusCode: 200, - }; - - const response = { - ok: jest.fn().mockReturnValue(okResponse), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleDeleteCspRules(client, response, logger); - - expect(returnedResponse).toBe(okResponse); - - expect(client.deleteCspRules).toBeCalledTimes(1); - - expect(response.ok).toBeCalledWith({ - body: { - deletedCspRulesName: cspRulesName, - }, - }); - - expect(logger.error).not.toBeCalled(); - }); - - it('return error response when client throws error', async () => { - const error = new Error(ERROR_MESSAGE); - - const client = { - deleteCspRules: jest.fn().mockImplementation(() => { - throw error; - }), - }; - - const response = { - custom: jest.fn().mockReturnValue(ERROR_RESPONSE), - }; - - const logger = loggerMock.create(); - - const returnedResponse = await handleDeleteCspRules(client, response, logger); - - expect(returnedResponse).toBe(ERROR_RESPONSE); - - expect(client.deleteCspRules).toBeCalledTimes(1); - - expect(response.custom).toBeCalledWith({ - body: error, - statusCode: 500, - }); - - expect(logger.error).toBeCalledWith(error); - }); - }); - - describe('errorResponse', () => { - it('return default 500 statusCode', () => { - const response = { - custom: jest.fn(), - }; - - const error = { - message: ERROR_MESSAGE, - }; - - errorResponse(response, error); - - expect(response.custom).toBeCalledWith({ - statusCode: 500, - body: error, - }); - }); - - it('return input statusCode', () => { - const response = { - custom: jest.fn(), - }; - - const error = { - statusCode: 400, - message: ERROR_MESSAGE, - }; - - errorResponse(response, error); - - expect(response.custom).toBeCalledWith({ - statusCode: 400, - body: error, - }); - }); - }); -}); diff --git a/src/plugins/configuration_provider/server/types.ts b/src/plugins/configuration_provider/server/types.ts index 57e456ce3777..a9cb9705663c 100644 --- a/src/plugins/configuration_provider/server/types.ts +++ b/src/plugins/configuration_provider/server/types.ts @@ -7,13 +7,3 @@ export interface ConfigurationProviderPluginSetup {} // eslint-disable-next-line @typescript-eslint/no-empty-interface export interface ConfigurationProviderPluginStart {} - -export interface ConfigurationClient { - existsCspRules(): Promise; - - getCspRules(): Promise; - - updateCspRules(cspRules: string): Promise; - - deleteCspRules(): Promise; -} From 22e5394e935c525115353714d02297390b2e3cd5 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 29 Feb 2024 21:46:14 +0000 Subject: [PATCH 37/59] reset change log Signed-off-by: Tianle Huang --- CHANGELOG.md | 22 ++-------------------- 1 file changed, 2 insertions(+), 20 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 83b3827ba731..aa6f4933efff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -72,24 +72,16 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Add support for TLS v1.3 ([#5133](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5133)) - [CVE-2023-45133] Bump all babel dependencies from `7.16.x` to `7.22.9` to fix upstream vulnerability ([#5428](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5428)) - [CVE-2023-45857] Bump `axios` from `0.27.2` to `1.6.1` ([#5470](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5470)) -- [CVE-2023-26159] Bump `follow-redirects` from `1.15.2` to `1.15.4` ([#5669](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5669)) -- [CVE-2023-52079] Bump `msgpackr` from `1.9.7` to `1.10.1` ([#5803](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5803)) -- [CVE-2020-8203] Bump `cheerio` from `0.22.0` to `1.0.0-rc.1` to fix vulnerable `lodash` dependency ([#5797](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5797)) -- Support dynamic CSP rules to mitigate clickjacking ([#5641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641)) ### 📈 Features/Enhancements - Add support for read-only mode through tenants ([#4498](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4498)) -- Replace OuiSelect component with OuiSuperSelect in data-source plugin ([#5315](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5315)) - [Workspace] Add core workspace service module to enable the implementation of workspace features within OSD plugins ([#5092](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5092)) - [Workspace] Setup workspace skeleton and implement basic CRUD API ([#5075](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5075)) - [Workspace] Add ACL related functions ([#5084](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5084/)) - [Decouple] Add new cross compatibility check core service which export functionality for plugins to verify if their OpenSearch plugin counterpart is installed on the cluster or has incompatible version to configure the plugin behavior([#4710](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4710)) -- [Discover] Add long numerals support [#5592](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5592) - [Discover] Display inner properties in the left navigation bar [#5429](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5429) -- [Discover] Added customizable pagination options based on Discover UI settings [#5610](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5610) - [Chrome] Introduce registerCollapsibleNavHeader to allow plugins to customize the rendering of nav menu header ([#5244](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5244)) -- [PM] Enhance single version requirements imposed during bootstrapping ([#5675](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5675)) - [Custom Branding] Relative URL should be allowed for logos ([#5572](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5572)) - Revert to legacy discover table and add toggle to new discover table ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) - [Discover] Add collapsible and resizeable sidebar ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) @@ -112,7 +104,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [BUG][Data] Fix empty suggestion history when querying in search bar [#5349](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5349) - [BUG][Discover] Fix what is displayed in `selected fields` when removing columns from canvas [#5537](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5537) - [BUG][Discover] Fix advanced setting `discover:modifyColumnsOnSwitch` ([#5508](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5508)) -- [BUG][Discover] Show 0 filters when there are no active filters ([#5508](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5508)) - [Discover] Fix missing index pattern field from breaking Discover [#5626](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5626) - [BUG][Discover] Fix Discover table panel not adjusting its size automatically when the time range changes ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) - [BUG] Fix issue where changing from a search with few results to a search with more results keeps the number of rows from the previous search ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) @@ -132,9 +123,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [CI] Enable inputs for manually triggered Cypress test jobs ([#5134](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5134)) - [CI] Replace usage of deprecated `set-output` in workflows ([#5340](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5340)) - [Chore] Add `--security` for `opensearch snapshot` and `opensearch_dashboards` to configure local setup with the security plugin ([#5451](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5451)) -- [Tests] Add Github workflow for Test Orchestrator in FT Repo to run cypress tests within Dashboards repo ([#5725](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5725)) -- [Chore] Updates default dev environment security credentials ([#5736](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5736)) -- [Tests] Baseline screenshots for area and tsvb functional tests ([#5915](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5915)) ### 📝 Documentation @@ -151,23 +139,21 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Replace `node-sass` with `sass-embedded` ([#5338](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5338)) - Bump `chromedriver` from `107.0.3` to `119.0.1` ([#5465](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5465)) - Bump `typescript` resolution from `4.0.2` to `4.6.4` ([#5470](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5470)) -- Bump `OUI` to `1.5.1` ([#5862](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5862)) - Add @SuZhou-Joe as a maintainer ([#5594](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5594)) - Move @seanneumann to emeritus maintainer ([#5634](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5634)) - Remove `ui-select` dev dependency ([#5660](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5660)) - Bump `chromedriver` dependency to `121.0.1"` ([#5926](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5926)) - Add @ruanyl as a maintainer ([#5982](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5982)) +- Add @BionIT as a maintainer ([#5988](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5988)) ### 🪛 Refactoring - [Console] Remove unused ul element and its custom styling ([#3993](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/3993)) - Remove unused Sass in `tile_map` plugin ([#4110](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4110)) - [Home] Remove unused tutorials ([#5212](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5212)) -- [UiSharedDeps] Standardize theme JSON imports to be light/dark-mode aware ([#5662](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5662)) ### 🔩 Tests -- Update caniuse to `1.0.30001587` to fix failed integration tests ([#5886](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5886)) - [Home] Add more unit tests for other complications of overview ([#5418](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5418)) ## [2.11.1 - 2023-11-21](https://github.com/opensearch-project/OpenSearch-Dashboards/releases/tag/2.11.1) @@ -305,7 +291,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Bump OpenSearch-Dashboards 2.10.0 to use nodejs 18.16.0 version ([#4948](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4948)) - Bump `oui` to `1.3.0` ([#4941](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4941)) - Add @curq as maintainer ([#4760](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4760)) -- Bump OpenSearch Dashboards to use nodejs v18.19.0 ([#4948](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5830)) ### 🪛 Refactoring @@ -418,7 +403,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [Dashboard De-Angular] Add more unit tests for utils folder ([#4641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4641)) - [Dashboard De-Angular] Add unit tests for dashboard_listing and dashboard_top_nav ([#4640](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4640)) - Optimize `augment-vis` saved obj searching by adding arg to saved obj client ([#4595](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4595)) -- Change SavedObjects' Import API to allow selecting a data source when uploading files ([#5777](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5777)) ### 🐛 Bug Fixes @@ -724,8 +708,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [Search Telemetry] Fix search telemetry's observable object that won't be GC-ed([#3390](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/3390)) - [Region Maps] Add ui setting to configure custom vector map's size parameter([#3399](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/3399)) -- [Import API] Fix import saved objects always display overwritten issue([#5861](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5871)) - ### 🚞 Infrastructure @@ -1049,4 +1031,4 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) ### 🔩 Tests -- Update caniuse to fix failed integration tests ([#2322](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/2322)) +- Update caniuse to fix failed integration tests ([#2322](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/2322)) \ No newline at end of file From 27ce0b1e8c4bc6e74d84bf71db54cbcb73d3fc5e Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Thu, 29 Feb 2024 21:47:46 +0000 Subject: [PATCH 38/59] reset change log again Signed-off-by: Tianle Huang --- CHANGELOG.md | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index aa6f4933efff..2ea6268217f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -72,16 +72,23 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Add support for TLS v1.3 ([#5133](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5133)) - [CVE-2023-45133] Bump all babel dependencies from `7.16.x` to `7.22.9` to fix upstream vulnerability ([#5428](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5428)) - [CVE-2023-45857] Bump `axios` from `0.27.2` to `1.6.1` ([#5470](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5470)) +- [CVE-2023-26159] Bump `follow-redirects` from `1.15.2` to `1.15.4` ([#5669](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5669)) +- [CVE-2023-52079] Bump `msgpackr` from `1.9.7` to `1.10.1` ([#5803](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5803)) +- [CVE-2020-8203] Bump `cheerio` from `0.22.0` to `1.0.0-rc.1` to fix vulnerable `lodash` dependency ([#5797](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5797)) ### 📈 Features/Enhancements - Add support for read-only mode through tenants ([#4498](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4498)) +- Replace OuiSelect component with OuiSuperSelect in data-source plugin ([#5315](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5315)) - [Workspace] Add core workspace service module to enable the implementation of workspace features within OSD plugins ([#5092](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5092)) - [Workspace] Setup workspace skeleton and implement basic CRUD API ([#5075](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5075)) - [Workspace] Add ACL related functions ([#5084](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5084/)) - [Decouple] Add new cross compatibility check core service which export functionality for plugins to verify if their OpenSearch plugin counterpart is installed on the cluster or has incompatible version to configure the plugin behavior([#4710](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4710)) +- [Discover] Add long numerals support [#5592](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5592) - [Discover] Display inner properties in the left navigation bar [#5429](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5429) +- [Discover] Added customizable pagination options based on Discover UI settings [#5610](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5610) - [Chrome] Introduce registerCollapsibleNavHeader to allow plugins to customize the rendering of nav menu header ([#5244](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5244)) +- [PM] Enhance single version requirements imposed during bootstrapping ([#5675](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5675)) - [Custom Branding] Relative URL should be allowed for logos ([#5572](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5572)) - Revert to legacy discover table and add toggle to new discover table ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) - [Discover] Add collapsible and resizeable sidebar ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) @@ -104,6 +111,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [BUG][Data] Fix empty suggestion history when querying in search bar [#5349](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5349) - [BUG][Discover] Fix what is displayed in `selected fields` when removing columns from canvas [#5537](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5537) - [BUG][Discover] Fix advanced setting `discover:modifyColumnsOnSwitch` ([#5508](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5508)) +- [BUG][Discover] Show 0 filters when there are no active filters ([#5508](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5508)) - [Discover] Fix missing index pattern field from breaking Discover [#5626](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5626) - [BUG][Discover] Fix Discover table panel not adjusting its size automatically when the time range changes ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) - [BUG] Fix issue where changing from a search with few results to a search with more results keeps the number of rows from the previous search ([#5789](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5789)) @@ -123,6 +131,9 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [CI] Enable inputs for manually triggered Cypress test jobs ([#5134](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5134)) - [CI] Replace usage of deprecated `set-output` in workflows ([#5340](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5340)) - [Chore] Add `--security` for `opensearch snapshot` and `opensearch_dashboards` to configure local setup with the security plugin ([#5451](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5451)) +- [Tests] Add Github workflow for Test Orchestrator in FT Repo to run cypress tests within Dashboards repo ([#5725](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5725)) +- [Chore] Updates default dev environment security credentials ([#5736](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5736)) +- [Tests] Baseline screenshots for area and tsvb functional tests ([#5915](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5915)) ### 📝 Documentation @@ -139,6 +150,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Replace `node-sass` with `sass-embedded` ([#5338](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5338)) - Bump `chromedriver` from `107.0.3` to `119.0.1` ([#5465](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5465)) - Bump `typescript` resolution from `4.0.2` to `4.6.4` ([#5470](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5470)) +- Bump `OUI` to `1.5.1` ([#5862](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5862)) - Add @SuZhou-Joe as a maintainer ([#5594](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5594)) - Move @seanneumann to emeritus maintainer ([#5634](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5634)) - Remove `ui-select` dev dependency ([#5660](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5660)) @@ -151,9 +163,11 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [Console] Remove unused ul element and its custom styling ([#3993](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/3993)) - Remove unused Sass in `tile_map` plugin ([#4110](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4110)) - [Home] Remove unused tutorials ([#5212](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5212)) +- [UiSharedDeps] Standardize theme JSON imports to be light/dark-mode aware ([#5662](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5662)) ### 🔩 Tests +- Update caniuse to `1.0.30001587` to fix failed integration tests ([#5886](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5886)) - [Home] Add more unit tests for other complications of overview ([#5418](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5418)) ## [2.11.1 - 2023-11-21](https://github.com/opensearch-project/OpenSearch-Dashboards/releases/tag/2.11.1) @@ -291,6 +305,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Bump OpenSearch-Dashboards 2.10.0 to use nodejs 18.16.0 version ([#4948](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4948)) - Bump `oui` to `1.3.0` ([#4941](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4941)) - Add @curq as maintainer ([#4760](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4760)) +- Bump OpenSearch Dashboards to use nodejs v18.19.0 ([#4948](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5830)) ### 🪛 Refactoring @@ -403,6 +418,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [Dashboard De-Angular] Add more unit tests for utils folder ([#4641](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4641)) - [Dashboard De-Angular] Add unit tests for dashboard_listing and dashboard_top_nav ([#4640](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4640)) - Optimize `augment-vis` saved obj searching by adding arg to saved obj client ([#4595](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/4595)) +- Change SavedObjects' Import API to allow selecting a data source when uploading files ([#5777](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5777)) ### 🐛 Bug Fixes @@ -708,6 +724,8 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [Search Telemetry] Fix search telemetry's observable object that won't be GC-ed([#3390](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/3390)) - [Region Maps] Add ui setting to configure custom vector map's size parameter([#3399](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/3399)) +- [Import API] Fix import saved objects always display overwritten issue([#5861](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5871)) + ### 🚞 Infrastructure @@ -1031,4 +1049,4 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) ### 🔩 Tests -- Update caniuse to fix failed integration tests ([#2322](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/2322)) \ No newline at end of file +- Update caniuse to fix failed integration tests ([#2322](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/2322)) From d55b4592aab31312082f1963e006bdc9fe090166 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 1 Mar 2024 00:00:46 +0000 Subject: [PATCH 39/59] update accordingly to new changes in applicationConfig Signed-off-by: Tianle Huang --- src/plugins/configuration_provider/README.md | 33 +--- .../configuration_provider/server/plugin.ts | 1 - .../server/routes/index.ts | 163 ------------------ 3 files changed, 2 insertions(+), 195 deletions(-) delete mode 100644 src/plugins/configuration_provider/server/routes/index.ts diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/configuration_provider/README.md index 918400dc9bdb..adb72dd26fec 100755 --- a/src/plugins/configuration_provider/README.md +++ b/src/plugins/configuration_provider/README.md @@ -2,11 +2,9 @@ A OpenSearch Dashboards plugin -This plugin introduces the support of a dynamic configuration as opposed to the existing static configuration in OSD YAML file `opensearch_dashboards.yml`. It stores the configuration in an index whose default name is `.opensearch_dashboards_config` and could be customized through the key `opensearchDashboards.config_index` in OSD YAML file. It also provides an interface `ConfigurationClient` for future extensions of external configuration providers. By default, an implementation based on OpenSearch as database is used. This plugin is by default disabled and could be enabled by setting `configuration_provider.enabled` in OSD YAML to true. +This plugin is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from a dependent plugin `applicationConfig` and then rewrite to CSP header. Users are able to call the API endpoint exposed by the `applicationConfig` plugin directly, e.g through CURL. Currently there is no new OSD page for ease of user interactions with the APIs. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. -The first use case onboarding to this new index is to support updating Content Security Policy (CSP) rules dynamically without requiring a server restart. It registers a pre-response handler to `HttpServiceSetup` which can get CSP rules from the new index and then rewrite to CSP header. The plugin exposes query and update APIs for OSD users to use against CSP rules. Currently there is no new OSD page for ease of user interactions with the APIs. Users are able to call the API endpoint directly, e.g through CURL. Updates to the CSP rules will take effect immediately. As a comparison, modifying CSP rules through the key `csp.rules` in OSD YAML file would require a server restart. - -By default, the new index does not exist. For OSD users who do not need customized CSP rules, the index won't exist at all. The plugin will check whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. If the aggregated CSP rules don't contain the CSP directive `frame-ancestors` which specifies valid parents that may embed OSD page, then the plugin will append `frame-ancestors 'self'` to prevent Clickjacking. +By default, this plugin is disabled. Once enabled, the plugin will first use what users have configured through `applicationConfig`. If not configured, it will check whatever CSP rules aggregated by the values of `csp.rules` from OSD YAML file and default values. If the aggregated CSP rules don't contain the CSP directive `frame-ancestors` which specifies valid parents that may embed OSD page, then the plugin will append `frame-ancestors 'self'` to prevent Clickjacking. --- @@ -40,33 +38,6 @@ curl '{osd endpoint}/api/config/csp/get' ``` -## External Configuration Providers -While a default OpenSearch based client is implemented, OSD users can use external configuration clients through an OSD plugin (outside OSD). - -Let's call this plugin `MyConfigurationClientPlugin`. - -First, this plugin will need to implement a class `MyConfigurationClient` based on interface `ConfigurationClient` defined in the `types.ts` under directory `src/plugins/configuration_provider/server/types.ts`. - -Second, this plugin needs to declare `configurationProvider` as its dependency by adding it to `requiredPlugins` in its own `opensearch_dashboards.json`. - -Third, the plugin will import the type `ConfigurationProviderPluginSetup` from the corresponding `types.ts` and add to its own setup input. Below is the skeleton of the class `MyConfigurationClientPlugin`. - -``` -// MyConfigurationClientPlugin - public setup(core: CoreSetup, { configurationProviderPluginSetup }: ConfigurationProviderPluginSetup) { - - ... - // The function createClient provides an instance of ConfigurationClient which - // could have a underlying DynamoDB or Postgres implementation. - const myConfigurationClient: ConfigurationClient = this.createClient(); - - configurationProviderPluginSetup.setConfigurationClient(myConfigurationClient); - ... - return {}; - } - -``` - --- ## Development diff --git a/src/plugins/configuration_provider/server/plugin.ts b/src/plugins/configuration_provider/server/plugin.ts index 59f0969f3a32..4aa89edb8198 100644 --- a/src/plugins/configuration_provider/server/plugin.ts +++ b/src/plugins/configuration_provider/server/plugin.ts @@ -39,7 +39,6 @@ export class ConfigurationProviderPlugin } public start(core: CoreStart) { - this.logger.debug('ConfigurationProvider: Started'); return {}; } diff --git a/src/plugins/configuration_provider/server/routes/index.ts b/src/plugins/configuration_provider/server/routes/index.ts deleted file mode 100644 index 455bdebe7e83..000000000000 --- a/src/plugins/configuration_provider/server/routes/index.ts +++ /dev/null @@ -1,163 +0,0 @@ -/* - * Copyright OpenSearch Contributors - * SPDX-License-Identifier: Apache-2.0 - */ - -import { schema } from '@osd/config-schema'; -import { - IRouter, - IScopedClusterClient, - Logger, - OpenSearchDashboardsRequest, - OpenSearchDashboardsResponseFactory, -} from '../../../../core/server'; -import { ConfigurationClient } from '../types'; - -export function defineRoutes( - router: IRouter, - getConfigurationClient: (inputOpenSearchClient: IScopedClusterClient) => ConfigurationClient, - logger: Logger -) { - router.get( - { - path: '/api/config/csp/exists', - validate: false, - }, - async (context, request, response) => { - const client = getConfigurationClient(context.core.opensearch.client); - - return await handleExistsCspRules(client, response, logger); - } - ); - - router.get( - { - path: '/api/config/csp/get', - validate: false, - }, - async (context, request, response) => { - const client = getConfigurationClient(context.core.opensearch.client); - - return await handleGetCspRules(client, response, logger); - } - ); - - router.post( - { - path: '/api/config/csp/update', - validate: { - body: schema.object({ - value: schema.string(), - }), - }, - }, - async (context, request, response) => { - const client = getConfigurationClient(context.core.opensearch.client); - - return await handleUpdateCspRules(client, request, response, logger); - } - ); - - router.post( - { - path: '/api/config/csp/delete', - validate: false, - }, - async (context, request, response) => { - const client = getConfigurationClient(context.core.opensearch.client); - - return await handleDeleteCspRules(client, response, logger); - } - ); -} - -export async function handleExistsCspRules( - client: ConfigurationClient, - response: OpenSearchDashboardsResponseFactory, - logger: Logger -) { - try { - const result = await client.existsCspRules(); - return response.ok({ - body: { - exists: result, - }, - }); - } catch (e) { - logger.error(e); - return errorResponse(response, e); - } -} - -export async function handleGetCspRules( - client: ConfigurationClient, - response: OpenSearchDashboardsResponseFactory, - logger: Logger -) { - try { - const result = await client.getCspRules(); - - return response.ok({ - body: { - cspRules: result, - }, - }); - } catch (e) { - logger.error(e); - return errorResponse(response, e); - } -} - -export async function handleUpdateCspRules( - client: ConfigurationClient, - request: OpenSearchDashboardsRequest, - response: OpenSearchDashboardsResponseFactory, - logger: Logger -) { - const inputCspRules = request.body.value.trim(); - - if (!inputCspRules) { - const error = new Error('Cannot update CSP rules to emtpy!'); - logger.error(error); - return errorResponse(response, error); - } - - try { - const updatedRules = await client.updateCspRules(inputCspRules); - - return response.ok({ - body: { - updatedRules, - }, - }); - } catch (e) { - logger.error(e); - return errorResponse(response, e); - } -} - -export async function handleDeleteCspRules( - client: ConfigurationClient, - response: OpenSearchDashboardsResponseFactory, - logger: Logger -) { - try { - const deletedCspRulesName = await client.deleteCspRules(); - - return response.ok({ - body: { - deletedCspRulesName, - }, - }); - } catch (e) { - logger.error(e); - return errorResponse(response, e); - } -} - -export function errorResponse(response: OpenSearchDashboardsResponseFactory, error: any) { - return response.custom({ - statusCode: error?.statusCode || 500, - body: error, - }); -} From 9f371e73f6b75f417f81e8e779427e61c09cbb5d Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 1 Mar 2024 00:06:54 +0000 Subject: [PATCH 40/59] update changelog Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ea6268217f2..6ed03e315cce 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -75,6 +75,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [CVE-2023-26159] Bump `follow-redirects` from `1.15.2` to `1.15.4` ([#5669](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5669)) - [CVE-2023-52079] Bump `msgpackr` from `1.9.7` to `1.10.1` ([#5803](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5803)) - [CVE-2020-8203] Bump `cheerio` from `0.22.0` to `1.0.0-rc.1` to fix vulnerable `lodash` dependency ([#5797](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5797)) +- Support dynamic CSP rules to mitigate clickjacking https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641 ### 📈 Features/Enhancements From 54a5db1eaa5d05bb88497ceb8cc45bde6c273d03 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 1 Mar 2024 00:13:12 +0000 Subject: [PATCH 41/59] rename to a new plugin name Signed-off-by: Tianle Huang --- .../{configuration_provider => csp_handler}/README.md | 0 .../{configuration_provider => csp_handler}/common/index.ts | 0 .../{configuration_provider => csp_handler}/config.ts | 0 .../opensearch_dashboards.json | 4 ++-- .../server/csp_handlers.test.ts | 5 +++++ .../server/csp_handlers.ts | 0 .../{configuration_provider => csp_handler}/server/index.ts | 0 .../{configuration_provider => csp_handler}/server/plugin.ts | 0 .../{configuration_provider => csp_handler}/server/types.ts | 0 9 files changed, 7 insertions(+), 2 deletions(-) rename src/plugins/{configuration_provider => csp_handler}/README.md (100%) rename src/plugins/{configuration_provider => csp_handler}/common/index.ts (100%) rename src/plugins/{configuration_provider => csp_handler}/config.ts (100%) rename src/plugins/{configuration_provider => csp_handler}/opensearch_dashboards.json (70%) rename src/plugins/{configuration_provider => csp_handler}/server/csp_handlers.test.ts (99%) rename src/plugins/{configuration_provider => csp_handler}/server/csp_handlers.ts (100%) rename src/plugins/{configuration_provider => csp_handler}/server/index.ts (100%) rename src/plugins/{configuration_provider => csp_handler}/server/plugin.ts (100%) rename src/plugins/{configuration_provider => csp_handler}/server/types.ts (100%) diff --git a/src/plugins/configuration_provider/README.md b/src/plugins/csp_handler/README.md similarity index 100% rename from src/plugins/configuration_provider/README.md rename to src/plugins/csp_handler/README.md diff --git a/src/plugins/configuration_provider/common/index.ts b/src/plugins/csp_handler/common/index.ts similarity index 100% rename from src/plugins/configuration_provider/common/index.ts rename to src/plugins/csp_handler/common/index.ts diff --git a/src/plugins/configuration_provider/config.ts b/src/plugins/csp_handler/config.ts similarity index 100% rename from src/plugins/configuration_provider/config.ts rename to src/plugins/csp_handler/config.ts diff --git a/src/plugins/configuration_provider/opensearch_dashboards.json b/src/plugins/csp_handler/opensearch_dashboards.json similarity index 70% rename from src/plugins/configuration_provider/opensearch_dashboards.json rename to src/plugins/csp_handler/opensearch_dashboards.json index f971ed07cac0..28ec18d55328 100644 --- a/src/plugins/configuration_provider/opensearch_dashboards.json +++ b/src/plugins/csp_handler/opensearch_dashboards.json @@ -1,6 +1,6 @@ { - "id": "configurationProvider", - "version": "1.0.0", + "id": "cspHandler", + "version": "opensearchDashboards", "opensearchDashboardsVersion": "opensearchDashboards", "server": true, "ui": false, diff --git a/src/plugins/configuration_provider/server/csp_handlers.test.ts b/src/plugins/csp_handler/server/csp_handlers.test.ts similarity index 99% rename from src/plugins/configuration_provider/server/csp_handlers.test.ts rename to src/plugins/csp_handler/server/csp_handlers.test.ts index f2f171147fa6..1da7aa600e61 100644 --- a/src/plugins/configuration_provider/server/csp_handlers.test.ts +++ b/src/plugins/csp_handler/server/csp_handlers.test.ts @@ -4,10 +4,15 @@ */ import { RouteMethod } from '../../../core/server'; +/* eslint-disable */ + import { OpenSearchDashboardsRequest, OpenSearchDashboardsRouteOptions, } from '../../../core/server/http/router/request'; + +/* eslint-enable */ + import { coreMock, httpServerMock } from '../../../core/server/mocks'; import { createCspRulesPreResponseHandler } from './csp_handlers'; import { MockedLogger, loggerMock } from '@osd/logging/target/mocks'; diff --git a/src/plugins/configuration_provider/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts similarity index 100% rename from src/plugins/configuration_provider/server/csp_handlers.ts rename to src/plugins/csp_handler/server/csp_handlers.ts diff --git a/src/plugins/configuration_provider/server/index.ts b/src/plugins/csp_handler/server/index.ts similarity index 100% rename from src/plugins/configuration_provider/server/index.ts rename to src/plugins/csp_handler/server/index.ts diff --git a/src/plugins/configuration_provider/server/plugin.ts b/src/plugins/csp_handler/server/plugin.ts similarity index 100% rename from src/plugins/configuration_provider/server/plugin.ts rename to src/plugins/csp_handler/server/plugin.ts diff --git a/src/plugins/configuration_provider/server/types.ts b/src/plugins/csp_handler/server/types.ts similarity index 100% rename from src/plugins/configuration_provider/server/types.ts rename to src/plugins/csp_handler/server/types.ts From 0e9e14614e22e4ed578bd0ba0001e65773f35c8d Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 1 Mar 2024 00:21:32 +0000 Subject: [PATCH 42/59] rename Signed-off-by: Tianle Huang --- src/plugins/csp_handler/README.md | 2 +- src/plugins/csp_handler/config.ts | 2 +- src/plugins/csp_handler/server/index.ts | 10 +++++----- src/plugins/csp_handler/server/plugin.ts | 5 ++--- src/plugins/csp_handler/server/types.ts | 4 ++-- 5 files changed, 11 insertions(+), 12 deletions(-) diff --git a/src/plugins/csp_handler/README.md b/src/plugins/csp_handler/README.md index adb72dd26fec..5229bb68c195 100755 --- a/src/plugins/csp_handler/README.md +++ b/src/plugins/csp_handler/README.md @@ -1,4 +1,4 @@ -# ConfigurationProvider +# CspHandler A OpenSearch Dashboards plugin diff --git a/src/plugins/csp_handler/config.ts b/src/plugins/csp_handler/config.ts index 9ae3ef7dafc2..914dcf8b2792 100644 --- a/src/plugins/csp_handler/config.ts +++ b/src/plugins/csp_handler/config.ts @@ -9,4 +9,4 @@ export const configSchema = schema.object({ enabled: schema.boolean({ defaultValue: false }), }); -export type ConfigurationProviderConfigSchema = TypeOf; +export type CspHandlerConfigSchema = TypeOf; diff --git a/src/plugins/csp_handler/server/index.ts b/src/plugins/csp_handler/server/index.ts index 51b6a36d70ea..3e929048a317 100644 --- a/src/plugins/csp_handler/server/index.ts +++ b/src/plugins/csp_handler/server/index.ts @@ -4,18 +4,18 @@ */ import { PluginConfigDescriptor, PluginInitializerContext } from '../../../core/server'; -import { ConfigurationProviderConfigSchema, configSchema } from '../config'; -import { ConfigurationProviderPlugin } from './plugin'; +import { CspHandlerConfigSchema, configSchema } from '../config'; +import { CspHandlerPlugin } from './plugin'; // This exports static code and TypeScript types, // as well as, OpenSearch Dashboards Platform `plugin()` initializer. -export const config: PluginConfigDescriptor = { +export const config: PluginConfigDescriptor = { schema: configSchema, }; export function plugin(initializerContext: PluginInitializerContext) { - return new ConfigurationProviderPlugin(initializerContext); + return new CspHandlerPlugin(initializerContext); } -export { ConfigurationProviderPluginSetup, ConfigurationProviderPluginStart } from './types'; +export { CspHandlerPluginSetup, CspHandlerPluginStart } from './types'; diff --git a/src/plugins/csp_handler/server/plugin.ts b/src/plugins/csp_handler/server/plugin.ts index 4aa89edb8198..3f69a626ed39 100644 --- a/src/plugins/csp_handler/server/plugin.ts +++ b/src/plugins/csp_handler/server/plugin.ts @@ -12,10 +12,9 @@ import { } from '../../../core/server'; import { createCspRulesPreResponseHandler } from './csp_handlers'; -import { ConfigurationProviderPluginSetup, ConfigurationProviderPluginStart } from './types'; +import { CspHandlerPluginSetup, CspHandlerPluginStart } from './types'; -export class ConfigurationProviderPlugin - implements Plugin { +export class CspHandlerPlugin implements Plugin { private readonly logger: Logger; constructor(initializerContext: PluginInitializerContext) { diff --git a/src/plugins/csp_handler/server/types.ts b/src/plugins/csp_handler/server/types.ts index a9cb9705663c..16a080fcb697 100644 --- a/src/plugins/csp_handler/server/types.ts +++ b/src/plugins/csp_handler/server/types.ts @@ -4,6 +4,6 @@ */ // eslint-disable-next-line @typescript-eslint/no-empty-interface -export interface ConfigurationProviderPluginSetup {} +export interface CspHandlerPluginSetup {} // eslint-disable-next-line @typescript-eslint/no-empty-interface -export interface ConfigurationProviderPluginStart {} +export interface CspHandlerPluginStart {} From b434169864ab0bf4df5c417e5a61023faec93531 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 1 Mar 2024 00:37:10 +0000 Subject: [PATCH 43/59] rename more Signed-off-by: Tianle Huang --- src/plugins/csp_handler/common/index.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plugins/csp_handler/common/index.ts b/src/plugins/csp_handler/common/index.ts index e58a79887133..23a8ca4bd730 100644 --- a/src/plugins/csp_handler/common/index.ts +++ b/src/plugins/csp_handler/common/index.ts @@ -3,5 +3,5 @@ * SPDX-License-Identifier: Apache-2.0 */ -export const PLUGIN_ID = 'configurationProvider'; -export const PLUGIN_NAME = 'ConfigurationProvider'; +export const PLUGIN_ID = 'cspHandler'; +export const PLUGIN_NAME = 'CspHandler'; From e67af3c1f6dfc8e73c465ec17d634040ceee757b Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Mon, 4 Mar 2024 19:39:29 +0000 Subject: [PATCH 44/59] sync changelog from main Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 - 1 file changed, 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6ed03e315cce..2ea6268217f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -75,7 +75,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - [CVE-2023-26159] Bump `follow-redirects` from `1.15.2` to `1.15.4` ([#5669](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5669)) - [CVE-2023-52079] Bump `msgpackr` from `1.9.7` to `1.10.1` ([#5803](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5803)) - [CVE-2020-8203] Bump `cheerio` from `0.22.0` to `1.0.0-rc.1` to fix vulnerable `lodash` dependency ([#5797](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5797)) -- Support dynamic CSP rules to mitigate clickjacking https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641 ### 📈 Features/Enhancements From 2d1257579c3bd4e22e56da6cd99dd6454d4572ec Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Mon, 4 Mar 2024 23:00:05 +0000 Subject: [PATCH 45/59] onboard to app config Signed-off-by: Tianle Huang --- config/opensearch_dashboards.yml | 4 +- .../application_config/server/index.ts | 6 +- .../csp_handler/opensearch_dashboards.json | 4 +- .../csp_handler/server/csp_handlers.test.ts | 192 ++++-------------- .../csp_handler/server/csp_handlers.ts | 12 +- src/plugins/csp_handler/server/plugin.ts | 9 +- src/plugins/csp_handler/server/types.ts | 6 + 7 files changed, 69 insertions(+), 164 deletions(-) diff --git a/config/opensearch_dashboards.yml b/config/opensearch_dashboards.yml index b2710ad4cba6..806efd7b7635 100644 --- a/config/opensearch_dashboards.yml +++ b/config/opensearch_dashboards.yml @@ -34,7 +34,9 @@ # opensearchDashboards.configIndex: ".opensearch_dashboards_config" # Set the value of this setting to true to enable plugin application config. By default it is disabled. -# application_config.enabled: false +application_config.enabled: true + +csp_handler.enabled: true # The default application to load. #opensearchDashboards.defaultAppId: "home" diff --git a/src/plugins/application_config/server/index.ts b/src/plugins/application_config/server/index.ts index 1ef2bbc3baf9..3eb85b455afa 100644 --- a/src/plugins/application_config/server/index.ts +++ b/src/plugins/application_config/server/index.ts @@ -20,4 +20,8 @@ export function plugin(initializerContext: PluginInitializerContext) { return new ApplicationConfigPlugin(initializerContext); } -export { ApplicationConfigPluginSetup, ApplicationConfigPluginStart } from './types'; +export { + ApplicationConfigPluginSetup, + ApplicationConfigPluginStart, + ConfigurationClient, +} from './types'; diff --git a/src/plugins/csp_handler/opensearch_dashboards.json b/src/plugins/csp_handler/opensearch_dashboards.json index 28ec18d55328..8cc8f8e1f658 100644 --- a/src/plugins/csp_handler/opensearch_dashboards.json +++ b/src/plugins/csp_handler/opensearch_dashboards.json @@ -4,6 +4,8 @@ "opensearchDashboardsVersion": "opensearchDashboards", "server": true, "ui": false, - "requiredPlugins": [], + "requiredPlugins": [ + "applicationConfig" + ], "optionalPlugins": [] } \ No newline at end of file diff --git a/src/plugins/csp_handler/server/csp_handlers.test.ts b/src/plugins/csp_handler/server/csp_handlers.test.ts index 1da7aa600e61..d6c2f8a16d49 100644 --- a/src/plugins/csp_handler/server/csp_handlers.test.ts +++ b/src/plugins/csp_handler/server/csp_handlers.test.ts @@ -3,47 +3,17 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { RouteMethod } from '../../../core/server'; -/* eslint-disable */ - -import { - OpenSearchDashboardsRequest, - OpenSearchDashboardsRouteOptions, -} from '../../../core/server/http/router/request'; - -/* eslint-enable */ - import { coreMock, httpServerMock } from '../../../core/server/mocks'; import { createCspRulesPreResponseHandler } from './csp_handlers'; import { MockedLogger, loggerMock } from '@osd/logging/target/mocks'; const ERROR_MESSAGE = 'Service unavailable'; -const forgeRequest = ({ - headers = {}, - path = '/', - method = 'get', - opensearchDashboardsRouteOptions, -}: Partial<{ - headers: Record; - path: string; - method: RouteMethod; - opensearchDashboardsRouteOptions: OpenSearchDashboardsRouteOptions; -}>): OpenSearchDashboardsRequest => { - return httpServerMock.createOpenSearchDashboardsRequest({ - headers, - path, - method, - opensearchDashboardsRouteOptions, - }); -}; - describe('CSP handlers', () => { let toolkit: ReturnType; let logger: MockedLogger; beforeEach(() => { - jest.resetAllMocks(); toolkit = httpServerMock.createToolkit(); logger = loggerMock.create(); }); @@ -54,8 +24,7 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(true), - getCspRules: jest.fn().mockReturnValue(cspRulesFromIndex), + getEntityConfig: jest.fn().mockReturnValue(cspRulesFromIndex), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -66,7 +35,10 @@ describe('CSP handlers', () => { getConfigurationClient, logger ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + const request = { + method: 'get', + headers: { 'sec-fetch-dest': 'document' }, + }; toolkit.next.mockReturnValue('next' as any); @@ -82,8 +54,7 @@ describe('CSP handlers', () => { }, }); - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).toBeCalledTimes(1); + expect(configurationClient.getEntityConfig).toBeCalledTimes(1); }); it('do not add CSP headers when the client returns empty and CSP from YML already has frame-ancestors', async () => { @@ -92,8 +63,7 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'; frame-ancestors 'self'"; const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(true), - getCspRules: jest.fn().mockReturnValue(emptyCspRules), + getEntityConfig: jest.fn().mockReturnValue(emptyCspRules), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -104,7 +74,10 @@ describe('CSP handlers', () => { getConfigurationClient, logger ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + const request = { + method: 'get', + headers: { 'sec-fetch-dest': 'document' }, + }; toolkit.next.mockReturnValue('next' as any); @@ -115,8 +88,7 @@ describe('CSP handlers', () => { expect(toolkit.next).toHaveBeenCalledTimes(1); expect(toolkit.next).toHaveBeenCalledWith({}); - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).toBeCalledTimes(1); + expect(configurationClient.getEntityConfig).toBeCalledTimes(1); }); it('add frame-ancestors CSP headers when the client returns empty and CSP from YML has no frame-ancestors', async () => { @@ -125,8 +97,7 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(true), - getCspRules: jest.fn().mockReturnValue(emptyCspRules), + getEntityConfig: jest.fn().mockReturnValue(emptyCspRules), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -137,7 +108,11 @@ describe('CSP handlers', () => { getConfigurationClient, logger ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + const request = { + method: 'get', + headers: { 'sec-fetch-dest': 'document' }, + }; toolkit.next.mockReturnValue('next' as any); @@ -152,8 +127,7 @@ describe('CSP handlers', () => { }, }); - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).toBeCalledTimes(1); + expect(configurationClient.getEntityConfig).toBeCalledTimes(1); }); it('do not add CSP headers when the configuration does not exist and CSP from YML already has frame-ancestors', async () => { @@ -161,8 +135,9 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'; frame-ancestors 'self'"; const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(false), - getCspRules: jest.fn(), + getEntityConfig: jest.fn().mockImplementation(() => { + throw new Error(ERROR_MESSAGE); + }), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -173,7 +148,11 @@ describe('CSP handlers', () => { getConfigurationClient, logger ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + + const request = { + method: 'get', + headers: { 'sec-fetch-dest': 'document' }, + }; toolkit.next.mockReturnValue('next' as any); @@ -184,8 +163,7 @@ describe('CSP handlers', () => { expect(toolkit.next).toBeCalledTimes(1); expect(toolkit.next).toBeCalledWith({}); - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).toBeCalledTimes(0); + expect(configurationClient.getEntityConfig).toBeCalledTimes(1); }); it('add frame-ancestors CSP headers when the configuration does not exist and CSP from YML has no frame-ancestors', async () => { @@ -193,8 +171,9 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { - existsCspRules: jest.fn().mockReturnValue(false), - getCspRules: jest.fn(), + getEntityConfig: jest.fn().mockImplementation(() => { + throw new Error(ERROR_MESSAGE); + }), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -205,7 +184,7 @@ describe('CSP handlers', () => { getConfigurationClient, logger ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); + const request = { method: 'get', headers: { 'sec-fetch-dest': 'document' } }; toolkit.next.mockReturnValue('next' as any); @@ -220,8 +199,7 @@ describe('CSP handlers', () => { }, }); - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).toBeCalledTimes(0); + expect(configurationClient.getEntityConfig).toBeCalledTimes(1); }); it('do not add CSP headers when request dest exists and shall skip', async () => { @@ -229,8 +207,7 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { - existsCspRules: jest.fn(), - getCspRules: jest.fn(), + getEntityConfig: jest.fn(), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -243,7 +220,10 @@ describe('CSP handlers', () => { ); const cssSecFetchDest = 'css'; - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': cssSecFetchDest } }); + const request = { + method: 'get', + headers: { 'sec-fetch-dest': cssSecFetchDest }, + }; toolkit.next.mockReturnValue('next' as any); @@ -254,8 +234,7 @@ describe('CSP handlers', () => { expect(toolkit.next).toBeCalledTimes(1); expect(toolkit.next).toBeCalledWith({}); - expect(configurationClient.existsCspRules).toBeCalledTimes(0); - expect(configurationClient.getCspRules).toBeCalledTimes(0); + expect(configurationClient.getEntityConfig).toBeCalledTimes(0); }); it('do not add CSP headers when request dest does not exist', async () => { @@ -263,8 +242,7 @@ describe('CSP handlers', () => { const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; const configurationClient = { - existsCspRules: jest.fn(), - getCspRules: jest.fn(), + getEntityConfig: jest.fn(), }; const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); @@ -276,100 +254,20 @@ describe('CSP handlers', () => { logger ); - const request = forgeRequest({ method: 'get', headers: {} }); - - toolkit.next.mockReturnValue('next' as any); - - const result = await handler(request, {} as any, toolkit); - - expect(result).toEqual('next'); - - expect(toolkit.next).toBeCalledTimes(1); - expect(toolkit.next).toBeCalledWith({}); - - expect(configurationClient.existsCspRules).toBeCalledTimes(0); - expect(configurationClient.getCspRules).toBeCalledTimes(0); - }); - - it('do not the CSP headers when error happens and CSP from YML already has frame-ancestors', async () => { - const coreSetup = coreMock.createSetup(); - const error = new Error(ERROR_MESSAGE); - const cspRulesFromYML = "script-src 'unsafe-eval' 'self'; frame-ancestors 'self'"; - - const configurationClient = { - existsCspRules: jest.fn().mockImplementation(() => { - throw error; - }), - getCspRules: jest.fn(), + const request = { + method: 'get', + headers: {}, }; - const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - - const handler = createCspRulesPreResponseHandler( - coreSetup, - cspRulesFromYML, - getConfigurationClient, - logger - ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); - toolkit.next.mockReturnValue('next' as any); const result = await handler(request, {} as any, toolkit); expect(result).toEqual('next'); - expect(toolkit.next).toHaveBeenCalledTimes(1); + expect(toolkit.next).toBeCalledTimes(1); expect(toolkit.next).toBeCalledWith({}); - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).not.toBeCalled(); - - expect(logger.error).toBeCalledWith( - `Failure happened in CSP rules pre response handler due to ${error}` - ); - }); - - it('add frame-ancestors CSP headers when error happens and CSP from YML has no frame-ancestors', async () => { - const coreSetup = coreMock.createSetup(); - const error = new Error(ERROR_MESSAGE); - const cspRulesFromYML = "script-src 'unsafe-eval' 'self'"; - - const configurationClient = { - existsCspRules: jest.fn().mockImplementation(() => { - throw error; - }), - getCspRules: jest.fn(), - }; - - const getConfigurationClient = jest.fn().mockReturnValue(configurationClient); - - const handler = createCspRulesPreResponseHandler( - coreSetup, - cspRulesFromYML, - getConfigurationClient, - logger - ); - const request = forgeRequest({ method: 'get', headers: { 'sec-fetch-dest': 'document' } }); - - toolkit.next.mockReturnValue('next' as any); - - const result = await handler(request, {} as any, toolkit); - - expect(result).toEqual('next'); - - expect(toolkit.next).toHaveBeenCalledTimes(1); - expect(toolkit.next).toBeCalledWith({ - headers: { - 'content-security-policy': "frame-ancestors 'self'; " + cspRulesFromYML, - }, - }); - - expect(configurationClient.existsCspRules).toBeCalledTimes(1); - expect(configurationClient.getCspRules).not.toBeCalled(); - - expect(logger.error).toBeCalledWith( - `Failure happened in CSP rules pre response handler due to ${error}` - ); + expect(configurationClient.getEntityConfig).toBeCalledTimes(0); }); }); diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index c06128a77e97..02daa0600890 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -3,6 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ +import { ConfigurationClient } from '../../application_config/server'; import { CoreSetup, IScopedClusterClient, @@ -12,7 +13,8 @@ import { OnPreResponseToolkit, OpenSearchDashboardsRequest, } from '../../../core/server'; -import { ConfigurationClient } from './types'; + +const CSP_RULES_CONFIG_KEY = 'csp.rules'; export function createCspRulesPreResponseHandler( core: CoreSetup, @@ -38,13 +40,7 @@ export function createCspRulesPreResponseHandler( const myClient = getConfigurationClient(coreStart.opensearch.client.asScoped(request)); - const existsValue = await myClient.existsCspRules(); - - if (!existsValue) { - return updateFrameAncestors(cspHeader, toolkit); - } - - const cspRules = await myClient.getCspRules(); + const cspRules = await myClient.getEntityConfig(CSP_RULES_CONFIG_KEY); if (!cspRules) { return updateFrameAncestors(cspHeader, toolkit); diff --git a/src/plugins/csp_handler/server/plugin.ts b/src/plugins/csp_handler/server/plugin.ts index 3f69a626ed39..9f4094262452 100644 --- a/src/plugins/csp_handler/server/plugin.ts +++ b/src/plugins/csp_handler/server/plugin.ts @@ -12,7 +12,7 @@ import { } from '../../../core/server'; import { createCspRulesPreResponseHandler } from './csp_handlers'; -import { CspHandlerPluginSetup, CspHandlerPluginStart } from './types'; +import { AppPluginSetupDependencies, CspHandlerPluginSetup, CspHandlerPluginStart } from './types'; export class CspHandlerPlugin implements Plugin { private readonly logger: Logger; @@ -21,15 +21,12 @@ export class CspHandlerPlugin implements Plugin Date: Mon, 4 Mar 2024 23:45:36 +0000 Subject: [PATCH 46/59] fix comment Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/index.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/plugins/csp_handler/server/index.ts b/src/plugins/csp_handler/server/index.ts index 3e929048a317..3cbe9b3b14ff 100644 --- a/src/plugins/csp_handler/server/index.ts +++ b/src/plugins/csp_handler/server/index.ts @@ -7,9 +7,10 @@ import { PluginConfigDescriptor, PluginInitializerContext } from '../../../core/ import { CspHandlerConfigSchema, configSchema } from '../config'; import { CspHandlerPlugin } from './plugin'; -// This exports static code and TypeScript types, -// as well as, OpenSearch Dashboards Platform `plugin()` initializer. - +/* +This exports static code and TypeScript types, +as well as, OpenSearch Dashboards Platform `plugin()` initializer. +*/ export const config: PluginConfigDescriptor = { schema: configSchema, }; From f2ac166f1c72710fc22cdffdfc9b6ea5bf1cbf77 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 00:07:33 +0000 Subject: [PATCH 47/59] update yml Signed-off-by: Tianle Huang --- config/opensearch_dashboards.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/config/opensearch_dashboards.yml b/config/opensearch_dashboards.yml index 806efd7b7635..99df1d808bab 100644 --- a/config/opensearch_dashboards.yml +++ b/config/opensearch_dashboards.yml @@ -34,9 +34,11 @@ # opensearchDashboards.configIndex: ".opensearch_dashboards_config" # Set the value of this setting to true to enable plugin application config. By default it is disabled. -application_config.enabled: true +# application_config.enabled: false -csp_handler.enabled: true +# Set the value of this setting to true to enable plugin CSP handler. By default it is disabled. +# It requires the application config plugin as its dependency. +# csp_handler.enabled: false # The default application to load. #opensearchDashboards.defaultAppId: "home" From f8dc3b45b241cc2ac12986b7f039030202e8c0ce Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 00:17:16 +0000 Subject: [PATCH 48/59] update readme Signed-off-by: Tianle Huang --- src/plugins/csp_handler/README.md | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/src/plugins/csp_handler/README.md b/src/plugins/csp_handler/README.md index 5229bb68c195..2764e3412718 100755 --- a/src/plugins/csp_handler/README.md +++ b/src/plugins/csp_handler/README.md @@ -10,31 +10,36 @@ By default, this plugin is disabled. Once enabled, the plugin will first use wha ## Configuration -For OSD users who want to make changes to allow a new site to embed OSD pages, they can update CSP rules through CURL. -(Note that the commands following could be first obtained from a copy as curl option from the network tab of a browser development tool and then replaced with the API names) +The plugin can be enabled by adding this line in OSD YML. ``` -curl '{osd endpoint}/api/config/csp/update' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"value":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' +csp_handler.enabled: true ``` -Below is the CURL command to delete CSP rules. +Since it has a required dependency `applicationConfig`, make sure that the dependency is also enabled. + +``` +application_config.enabled: true +``` + +For OSD users who want to make changes to allow a new site to embed OSD pages, they can update CSP rules through CURL. (See the README of `applicationConfig` for more details about the APIs.) ``` -curl '{osd endpoint}/api/config/csp/delete' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' +curl '{osd endpoint}/api/appconfig/csp.rules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"newValue":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' ``` -Below is the CURL command to check if CSP rules exist in the new index. +Below is the CURL command to delete CSP rules. ``` -curl '{osd endpoint}/api/config/csp/exists' +curl '{osd endpoint}/api/appconfig/csp.rules' -X DELETE -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' ``` -Below is the CURL command to get the CSP rules from the new index. +Below is the CURL command to get the CSP rules. ``` -curl '{osd endpoint}/api/config/csp/get' +curl '{osd endpoint}/api/appconfig/csp.rules' ``` From 0c6a1cc517ad11242e8ce7270fccada23fdf5c69 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 00:20:45 +0000 Subject: [PATCH 49/59] update change log Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ea6268217f2..b9ec06754e10 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) ### Deprecations ### 🛡 Security +- Support dynamic CSP rules to mitigate Clickjacking https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5641 ### 📈 Features/Enhancements - [MD]Change cluster selector component name to data source selector ([#6042](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/6042)) From 78004c94d375188fe84b3f29135c1d85888b0c29 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 01:51:18 +0000 Subject: [PATCH 50/59] call out single quotes in readme Signed-off-by: Tianle Huang --- config/opensearch_dashboards.yml | 4 ---- src/plugins/csp_handler/README.md | 4 ++-- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/config/opensearch_dashboards.yml b/config/opensearch_dashboards.yml index 99df1d808bab..b2710ad4cba6 100644 --- a/config/opensearch_dashboards.yml +++ b/config/opensearch_dashboards.yml @@ -36,10 +36,6 @@ # Set the value of this setting to true to enable plugin application config. By default it is disabled. # application_config.enabled: false -# Set the value of this setting to true to enable plugin CSP handler. By default it is disabled. -# It requires the application config plugin as its dependency. -# csp_handler.enabled: false - # The default application to load. #opensearchDashboards.defaultAppId: "home" diff --git a/src/plugins/csp_handler/README.md b/src/plugins/csp_handler/README.md index 2764e3412718..04a6ca34f0dd 100755 --- a/src/plugins/csp_handler/README.md +++ b/src/plugins/csp_handler/README.md @@ -23,10 +23,10 @@ Since it has a required dependency `applicationConfig`, make sure that the depen application_config.enabled: true ``` -For OSD users who want to make changes to allow a new site to embed OSD pages, they can update CSP rules through CURL. (See the README of `applicationConfig` for more details about the APIs.) +For OSD users who want to make changes to allow a new site to embed OSD pages, they can update CSP rules through CURL. (See the README of `applicationConfig` for more details about the APIs.) **Please note that use backslash as string wrapper for single quotes inside the `data-raw` parameter. E.g use `'\''` to represent `'`** ``` -curl '{osd endpoint}/api/appconfig/csp.rules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"newValue":"script-src 'unsafe-eval' 'self'; worker-src blob: 'self'; style-src 'unsafe-inline' 'self'; frame-ancestors 'self' {new site}"}' +curl '{osd endpoint}/api/appconfig/csp.rules' -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'osd-xsrf: osd-fetch' -H 'Sec-Fetch-Dest: empty' --data-raw '{"newValue":"script-src '\''unsafe-eval'\'' '\''self'\''; worker-src blob: '\''self'\''; style-src '\''unsafe-inline'\'' '\''self'\''; frame-ancestors '\''self'\'' {new site}"}' ``` From 3dc2024980e7a6e3965e1eed7bdcc7ab49388b82 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 01:57:03 +0000 Subject: [PATCH 51/59] update yml Signed-off-by: Tianle Huang --- config/opensearch_dashboards.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/config/opensearch_dashboards.yml b/config/opensearch_dashboards.yml index b2710ad4cba6..f65b1ff69845 100644 --- a/config/opensearch_dashboards.yml +++ b/config/opensearch_dashboards.yml @@ -34,7 +34,11 @@ # opensearchDashboards.configIndex: ".opensearch_dashboards_config" # Set the value of this setting to true to enable plugin application config. By default it is disabled. -# application_config.enabled: false +# application_config.enabled: true + +# Set the value of this setting to true to enable plugin CSP handler. By default it is disabled. +# It requires the application config plugin as its dependency. +# csp_handler.enabled: false # The default application to load. #opensearchDashboards.defaultAppId: "home" From 140375fb99574f3f35f3de3634581dc3a60c6b77 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 02:08:42 +0000 Subject: [PATCH 52/59] update default Signed-off-by: Tianle Huang --- config/opensearch_dashboards.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config/opensearch_dashboards.yml b/config/opensearch_dashboards.yml index f65b1ff69845..99df1d808bab 100644 --- a/config/opensearch_dashboards.yml +++ b/config/opensearch_dashboards.yml @@ -34,7 +34,7 @@ # opensearchDashboards.configIndex: ".opensearch_dashboards_config" # Set the value of this setting to true to enable plugin application config. By default it is disabled. -# application_config.enabled: true +# application_config.enabled: false # Set the value of this setting to true to enable plugin CSP handler. By default it is disabled. # It requires the application config plugin as its dependency. From e31cc9b256ae897a25c044aed16eea0ce3d8668f Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 02:37:09 +0000 Subject: [PATCH 53/59] add reference link Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/csp_handlers.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index 02daa0600890..94006e5010bc 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -28,6 +28,7 @@ export function createCspRulesPreResponseHandler( toolkit: OnPreResponseToolkit ) => { try { + // Refer to this link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; const currentDest = request.headers['sec-fetch-dest']; From 688f65a04f420d16f258b7e91979a3c6f5f96144 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 03:29:51 +0000 Subject: [PATCH 54/59] update js doc Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/csp_handlers.ts | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index 94006e5010bc..bf06ae03c1aa 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -16,10 +16,21 @@ import { const CSP_RULES_CONFIG_KEY = 'csp.rules'; +/** + * This function creates a pre-response handler to dynamically set the CSP rules. + * It give precedence to the rules from application config plugin over those from YML. + * In case no value from application config, it will ensure a default frame-ancestors is set. + * + * @param core Context passed to the plugins `setup` method + * @param cspHeader The CSP header from YML + * @param getConfigurationClient The function provided by application config plugin to retrieve configurations + * @param logger The logger + * @returns The pre-response handler + */ export function createCspRulesPreResponseHandler( core: CoreSetup, cspHeader: string, - getConfigurationClient: (inputOpenSearchClient: IScopedClusterClient) => ConfigurationClient, + getConfigurationClient: (scopedClusterClient: IScopedClusterClient) => ConfigurationClient, logger: Logger ): OnPreResponseHandler { return async ( From c99b02f38e40355f64c6ece9b021597214389e15 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 03:40:24 +0000 Subject: [PATCH 55/59] rename Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/csp_handlers.ts | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index bf06ae03c1aa..9c5992c74a53 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -65,12 +65,15 @@ export function createCspRulesPreResponseHandler( return toolkit.next({ headers: additionalHeaders }); } catch (e) { logger.error(`Failure happened in CSP rules pre response handler due to ${e}`); - return updateFrameAncestors(cspHeader, toolkit); + return appendFrameAncestorsWhenMissing(cspHeader, toolkit); } }; } -function updateFrameAncestors(cspHeader: string, toolkit: OnPreResponseToolkit) { +/** + * Append frame-ancestors with default value 'self' when it is missing. + */ +function appendFrameAncestorsWhenMissing(cspHeader: string, toolkit: OnPreResponseToolkit) { if (cspHeader.includes('frame-ancestors')) { return toolkit.next({}); } From 68f3ea2e5aad8b4e347e32399defe12c4129a35b Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Tue, 5 Mar 2024 03:42:17 +0000 Subject: [PATCH 56/59] use new name Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/csp_handlers.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index 9c5992c74a53..2a84317885fc 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -55,7 +55,7 @@ export function createCspRulesPreResponseHandler( const cspRules = await myClient.getEntityConfig(CSP_RULES_CONFIG_KEY); if (!cspRules) { - return updateFrameAncestors(cspHeader, toolkit); + return appendFrameAncestorsWhenMissing(cspHeader, toolkit); } const additionalHeaders = { From 8c8eb0f2212331a8d70711919f96a600c3798e75 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 6 Mar 2024 23:00:50 +0000 Subject: [PATCH 57/59] redo changelog update Signed-off-by: Tianle Huang --- CHANGELOG.md | 1 - 1 file changed, 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b9ec06754e10..5b07ea1dde7b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -157,7 +157,6 @@ Inspired from [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) - Remove `ui-select` dev dependency ([#5660](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5660)) - Bump `chromedriver` dependency to `121.0.1"` ([#5926](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5926)) - Add @ruanyl as a maintainer ([#5982](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5982)) -- Add @BionIT as a maintainer ([#5988](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/5988)) ### 🪛 Refactoring From 78d8b32d962c0b05ca32b0c199508cdbe22672a0 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Wed, 6 Mar 2024 23:04:54 +0000 Subject: [PATCH 58/59] remove link Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/csp_handlers.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index 2a84317885fc..434a384b1510 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -39,7 +39,6 @@ export function createCspRulesPreResponseHandler( toolkit: OnPreResponseToolkit ) => { try { - // Refer to this link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors const shouldCheckDest = ['document', 'frame', 'iframe', 'embed', 'object']; const currentDest = request.headers['sec-fetch-dest']; From fcc987574965c5cff7177696c59aec244954c494 Mon Sep 17 00:00:00 2001 From: Tianle Huang Date: Fri, 8 Mar 2024 19:38:35 +0000 Subject: [PATCH 59/59] better name Signed-off-by: Tianle Huang --- src/plugins/csp_handler/server/csp_handlers.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/plugins/csp_handler/server/csp_handlers.ts b/src/plugins/csp_handler/server/csp_handlers.ts index 434a384b1510..cc14da74aed5 100644 --- a/src/plugins/csp_handler/server/csp_handlers.ts +++ b/src/plugins/csp_handler/server/csp_handlers.ts @@ -49,9 +49,9 @@ export function createCspRulesPreResponseHandler( const [coreStart] = await core.getStartServices(); - const myClient = getConfigurationClient(coreStart.opensearch.client.asScoped(request)); + const client = getConfigurationClient(coreStart.opensearch.client.asScoped(request)); - const cspRules = await myClient.getEntityConfig(CSP_RULES_CONFIG_KEY); + const cspRules = await client.getEntityConfig(CSP_RULES_CONFIG_KEY); if (!cspRules) { return appendFrameAncestorsWhenMissing(cspHeader, toolkit);