Source: api/api/cluster.js

  1. /*
  2.  * Copyright OpenSearch Contributors
  3.  * SPDX-License-Identifier: Apache-2.0
  4.  *
  5.  * The OpenSearch Contributors require contributions made to
  6.  * this file be licensed under the Apache-2.0 license or a
  7.  * compatible open source license.
  8.  *
  9.  */
  11. /*
  12.  * Licensed to Elasticsearch B.V. under one or more contributor
  13.  * license agreements. See the NOTICE file distributed with
  14.  * this work for additional information regarding copyright
  15.  * ownership. Elasticsearch B.V. licenses this file to you under
  16.  * the Apache License, Version 2.0 (the "License"); you may
  17.  * not use this file except in compliance with the License.
  18.  * You may obtain a copy of the License at
  19.  *
  20.  *    http://www.apache.org/licenses/LICENSE-2.0
  21.  *
  22.  * Unless required by applicable law or agreed to in writing,
  23.  * software distributed under the License is distributed on an
  24.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  25.  * KIND, either express or implied.  See the License for the
  26.  * specific language governing permissions and limitations
  27.  * under the License.
  28.  */
  30. 'use strict';
  32. /* eslint camelcase: 0 */
  33. /* eslint no-unused-vars: 0 */
  35. /** @namespace API-Cluster */
  37. const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils');
  38. const acceptedQuerystring = [
  39.   'include_yes_decisions',
  40.   'include_disk_info',
  41.   'pretty',
  42.   'human',
  43.   'error_trace',
  44.   'source',
  45.   'filter_path',
  46.   'timeout',
  47.   'cluster_manager_timeout',
  48.   'master_timeout',
  49.   'wait_for_removal',
  50.   'local',
  51.   'flat_settings',
  52.   'include_defaults',
  53.   'expand_wildcards',
  54.   'level',
  55.   'wait_for_active_shards',
  56.   'wait_for_nodes',
  57.   'wait_for_events',
  58.   'wait_for_no_relocating_shards',
  59.   'wait_for_no_initializing_shards',
  60.   'wait_for_status',
  61.   'node_ids',
  62.   'node_names',
  63.   'create',
  64.   'dry_run',
  65.   'explain',
  66.   'retry_failed',
  67.   'metric',
  68.   'wait_for_metadata_version',
  69.   'wait_for_timeout',
  70.   'ignore_unavailable',
  71.   'allow_no_indices',
  72. ];
  73. const snakeCase = {
  74.   includeYesDecisions: 'include_yes_decisions',
  75.   includeDiskInfo: 'include_disk_info',
  76.   errorTrace: 'error_trace',
  77.   filterPath: 'filter_path',
  78.   clusterManagerTimeout: 'cluster_manager_timeout',
  79.   masterTimeout: 'master_timeout',
  80.   waitForRemoval: 'wait_for_removal',
  81.   flatSettings: 'flat_settings',
  82.   includeDefaults: 'include_defaults',
  83.   expandWildcards: 'expand_wildcards',
  84.   waitForActiveShards: 'wait_for_active_shards',
  85.   waitForNodes: 'wait_for_nodes',
  86.   waitForEvents: 'wait_for_events',
  87.   waitForNoRelocatingShards: 'wait_for_no_relocating_shards',
  88.   waitForNoInitializingShards: 'wait_for_no_initializing_shards',
  89.   waitForStatus: 'wait_for_status',
  90.   nodeIds: 'node_ids',
  91.   nodeNames: 'node_names',
  92.   dryRun: 'dry_run',
  93.   retryFailed: 'retry_failed',
  94.   waitForMetadataVersion: 'wait_for_metadata_version',
  95.   waitForTimeout: 'wait_for_timeout',
  96.   ignoreUnavailable: 'ignore_unavailable',
  97.   allowNoIndices: 'allow_no_indices',
  98. };
  100. function ClusterApi(transport, ConfigurationError) {
  101.   this.transport = transport;
  102.   this[kConfigurationError] = ConfigurationError;
  103. }
  105. /**
  106.  * The most basic cluster allocation explain request finds an unassigned shard and explains why it can’t be allocated to a node. If you add some options, you can instead get information on a specific shard, including why OpenSearch assigned it to its current node.
  107.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/cluster-allocation/ OpenSearch - Cluster allocation explain}
  108.  *
  109.  * @memberOf API-Cluster
  110.  *
  111.  * @param {Object} params
  112.  * @param {boolean} [params.include_yes_decisions=false] - OpenSearch makes a series of yes or no decisions when trying to allocate a shard to a node. If this parameter is true, OpenSearch includes the (generally more numerous) “yes” decisions in its response.
  113.  * @param {boolean} [params.include_disk_info=false] - Whether to include information about disk usage in the response.
  114.  * @param {Object} [params.body]
  115.  * @param {string} [params.body.current_node] - If you only want an explanation if the shard happens to be on a particular node, specify that node name here.
  116.  * @param {string} [params.body.index] - The name of the shard’s index.
  117.  * @param {boolean} [params.body.primary] - Whether to provide an explanation for the primary shard (true) or its first replica (false), which share the same shard ID.
  118.  * @param {number} [params.body.shard] - The shard ID that you want an explanation for.
  119.  *
  120.  * @param {Object} options - Options for {@link Transport#request}
  121.  * @param {function} callback - Callback that handles errors and response
  122.  *
  123.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*} {@link https://opensearch.org/docs/latest/api-reference/cluster-allocation/#response Cluster allocation explain Response}
  124.  */
  125. ClusterApi.prototype.allocationExplain = function clusterAllocationExplainApi(
  126.   params,
  127.   options,
  128.   callback
  129. ) {
  130.   [params, options, callback] = normalizeArguments(params, options, callback);
  132.   let { method, body, ...querystring } = params;
  133.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  135.   let path = '';
  136.   if (method == null) method = body == null ? 'GET' : 'POST';
  137.   path = '/' + '_cluster' + '/' + 'allocation' + '/' + 'explain';
  139.   // build request object
  140.   const request = {
  141.     method,
  142.     path,
  143.     body: body || '',
  144.     querystring,
  145.   };
  147.   return this.transport.request(request, options, callback);
  148. };
  150. /**
  151.  * Delete Component Template(s)
  152.  *
  153.  * @memberOf API-Cluster
  154.  *
  155.  * @param {Object} params
  156.  * @param {string} [params.name] The name of the component template to be deleted.
  157.  *
  158.  * @param {Object} options - Options for {@link Transport#request}
  159.  * @param {function} callback - Callback that handles errors and response
  160.  *
  161.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  162.  */
  163. ClusterApi.prototype.deleteComponentTemplate = function clusterDeleteComponentTemplateApi(
  164.   params,
  165.   options,
  166.   callback
  167. ) {
  168.   [params, options, callback] = normalizeArguments(params, options, callback);
  170.   // check required parameters
  171.   if (params.name == null) {
  172.     const err = new this[kConfigurationError]('Missing required parameter: name');
  173.     return handleError(err, callback);
  174.   }
  176.   let { method, body, name, ...querystring } = params;
  177.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  179.   let path = '';
  180.   if (method == null) method = 'DELETE';
  181.   path = '/' + '_component_template' + '/' + encodeURIComponent(name);
  183.   // build request object
  184.   const request = {
  185.     method,
  186.     path,
  187.     body: body || '',
  188.     querystring,
  189.   };
  191.   return this.transport.request(request, options, callback);
  192. };
  194. /**
  195.  * Clears cluster voting config exclusions.
  196.  *
  197.  * @memberOf API-Cluster
  198.  *
  199.  * @param {Object} params
  200.  * @param {boolean} [params.wait_for_removal] Specifies whether to wait for all excluded nodes to be removed from the cluster before clearing the voting configuration exclusions list.
  201.  *
  202.  * @param {Object} options - Options for {@link Transport#request}
  203.  * @param {function} callback - Callback that handles errors and response
  204.  *
  205.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  206.  */
  207. ClusterApi.prototype.deleteVotingConfigExclusions = function clusterDeleteVotingConfigExclusionsApi(
  208.   params,
  209.   options,
  210.   callback
  211. ) {
  212.   [params, options, callback] = normalizeArguments(params, options, callback);
  214.   let { method, body, ...querystring } = params;
  215.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  217.   let path = '';
  218.   if (method == null) method = 'DELETE';
  219.   path = '/' + '_cluster' + '/' + 'voting_config_exclusions';
  221.   // build request object
  222.   const request = {
  223.     method,
  224.     path,
  225.     body: body || '',
  226.     querystring,
  227.   };
  229.   return this.transport.request(request, options, callback);
  230. };
  232. /**
  233.  * Information about whether a particular component template exist
  234.  *
  235.  * @memberOf API-Cluster
  236.  *
  237.  * @param {Object} params
  238.  * @param {boolean} [params.name] Name of the template
  239.  *
  240.  * @param {Object} options - Options for {@link Transport#request}
  241.  * @param {function} callback - Callback that handles errors and response
  242.  *
  243.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  244.  */
  245. ClusterApi.prototype.existsComponentTemplate = function clusterExistsComponentTemplateApi(
  246.   params,
  247.   options,
  248.   callback
  249. ) {
  250.   [params, options, callback] = normalizeArguments(params, options, callback);
  252.   // check required parameters
  253.   if (params.name == null) {
  254.     const err = new this[kConfigurationError]('Missing required parameter: name');
  255.     return handleError(err, callback);
  256.   }
  258.   let { method, body, name, ...querystring } = params;
  259.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  261.   let path = '';
  262.   if (method == null) method = 'HEAD';
  263.   path = '/' + '_component_template' + '/' + encodeURIComponent(name);
  265.   // build request object
  266.   const request = {
  267.     method,
  268.     path,
  269.     body: null,
  270.     querystring,
  271.   };
  273.   return this.transport.request(request, options, callback);
  274. };
  276. /**
  277.  * Returns one or more component templates
  278.  *
  279.  * @memberOf API-Cluster
  280.  *
  281.  * @param {Object} params
  282.  * @param {string | string[]} [params.name] Name(s) of the template(s)
  283.  *
  284.  * @param {Object} options - Options for {@link Transport#request}
  285.  * @param {function} callback - Callback that handles errors and response
  286.  *
  287.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  288.  */
  289. ClusterApi.prototype.getComponentTemplate = function clusterGetComponentTemplateApi(
  290.   params,
  291.   options,
  292.   callback
  293. ) {
  294.   [params, options, callback] = normalizeArguments(params, options, callback);
  296.   let { method, body, name, ...querystring } = params;
  297.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  299.   let path = '';
  300.   if (name != null) {
  301.     if (method == null) method = 'GET';
  302.     path = '/' + '_component_template' + '/' + encodeURIComponent(name);
  303.   } else {
  304.     if (method == null) method = 'GET';
  305.     path = '/' + '_component_template';
  306.   }
  308.   // build request object
  309.   const request = {
  310.     method,
  311.     path,
  312.     body: null,
  313.     querystring,
  314.   };
  316.   return this.transport.request(request, options, callback);
  317. };
  319. /**
  320.  * Get Cluster Settings
  321.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/cluster-settings/ OpenSearch - Cluster Settings}
  322.  * @memberOf API-Cluster
  323.  *
  324.  * @param {Object} params
  325.  * ç
  326.  * @param {boolean} [params.include_defaults] Whether to include default settings as part of the response. This parameter is useful for identifying the names and current values of settings you want to update.
  327.  * @param {string} [params.cluster_manager_timeout=30s] - The amount of time to wait for a connection to the cluster manager node.
  328.  *
  329.  * @param {Object} options - Options for {@link Transport#request}
  330.  * @param {function} callback - Callback that handles errors and response
  331.  *
  332.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  333.  */
  334. ClusterApi.prototype.getSettings = function clusterGetSettingsApi(params, options, callback) {
  335.   [params, options, callback] = normalizeArguments(params, options, callback);
  337.   let { method, body, ...querystring } = params;
  338.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  340.   let path = '';
  341.   if (method == null) method = 'GET';
  342.   path = '/' + '_cluster' + '/' + 'settings';
  344.   // build request object
  345.   const request = {
  346.     method,
  347.     path,
  348.     body: null,
  349.     querystring,
  350.   };
  352.   return this.transport.request(request, options, callback);
  353. };
  355. /**
  356.  * The most basic cluster health request returns a simple status of the health of your cluster. OpenSearch expresses cluster health in three colors: green, yellow, and red. A green status means all primary shards and their replicas are allocated to nodes. A yellow status means all primary shards are allocated to nodes, but some replicas aren’t. A red status means at least one primary shard is not allocated to any node.
  357.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/cluster-health/ OpenSearch - Cluster Health}
  358.  * @memberOf API-Cluster
  359.  *
  360.  * @param {Object} params
  361.  * @param {} [params.index] - To get the status of a specific index, provide the index name.
  362.  * @param {string} [params.expand_wildcards=open] - Expands wildcard expressions to concrete indices. Combine multiple values with commas. Supported values are 'all', 'open', 'closed', 'hidden', and 'none'.
  363.  * @param {string} [params.level=cluster] - The level of detail for returned health information. Supported values are 'cluster', 'indices', and 'shards'.
  364.  * @param {boolean} [params.local=false] - Whether to return information from the local node only instead of from the cluster manager node.
  365.  * @param {string} [params.cluster_manager_timeout=30s] - The amount of time to wait for a connection to the cluster manager node.
  366.  * @param {string} [params.timeout=30s] - The amount of time to wait for a response from the cluster.
  367.  * @param {string} [params.wait_for_active_shards=0] - Wait until the specified number of shards is active before returning a response. 'all' for all shards
  368.  * @param {string} [params.wait_for_nodes] - Wait for N number of nodes. Use 12 for exact match, >12 and <12 for range.
  369.  * @param {string} [params.wait_for_events] - Wait until all currently queued events with the given priority are processed. Supported values are 'immediate', 'urgent', 'high', 'normal', 'low', and 'languid'.
  370.  * @param {boolean} [params.wait_for_no_relocating_shards=false] - Whether to wait until there are no relocating shards in the cluster.
  371.  * @param {boolean} [params.wait_for_no_initializing_shards=false] - Whether to wait until there are no initializing shards in the cluster.
  372.  * @param {string} [params.wait_for_status] - Wait until the cluster health reaches the specified status or better. Supported values are 'green', 'yellow', and 'red'.
  373.  *
  374.  * @param {Object} options - Options for {@link Transport#request}
  375.  * @param {function} callback - Callback that handles errors and response
  376.  *
  377.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*} {@link https://opensearch.org/docs/latest/api-reference/cluster-health/#response Cluster Health Response}
  378.  */
  379. ClusterApi.prototype.health = function clusterHealthApi(params, options, callback) {
  380.   [params, options, callback] = normalizeArguments(params, options, callback);
  382.   let { method, body, index, ...querystring } = params;
  383.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  385.   let path = '';
  386.   if (index != null) {
  387.     if (method == null) method = 'GET';
  388.     path = '/' + '_cluster' + '/' + 'health' + '/' + encodeURIComponent(index);
  389.   } else {
  390.     if (method == null) method = 'GET';
  391.     path = '/' + '_cluster' + '/' + 'health';
  392.   }
  394.   // build request object
  395.   const request = {
  396.     method,
  397.     path,
  398.     body: null,
  399.     querystring,
  400.   };
  402.   return this.transport.request(request, options, callback);
  403. };
  405. /**
  406.  * Get a list of any cluster-level changes
  407.  * @memberOf API-Cluster
  408.  *
  409.  * @param {Object} params
  410.  * @param {boolean} [params.local=false] - Whether to return information from the local node only instead of from the cluster manager node.
  411.  * @param {string} [params.cluster_manager_timeout=30s] - The amount of time to wait for a connection to the cluster manager node.
  412.  *
  413.  * @param {Object} options - Options for {@link Transport#request}
  414.  * @param {function} callback - Callback that handles errors and response
  415.  *
  416.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  417.  */
  418. ClusterApi.prototype.pendingTasks = function clusterPendingTasksApi(params, options, callback) {
  419.   [params, options, callback] = normalizeArguments(params, options, callback);
  421.   let { method, body, ...querystring } = params;
  422.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  424.   let path = '';
  425.   if (method == null) method = 'GET';
  426.   path = '/' + '_cluster' + '/' + 'pending_tasks';
  428.   // build request object
  429.   const request = {
  430.     method,
  431.     path,
  432.     body: null,
  433.     querystring,
  434.   };
  436.   return this.transport.request(request, options, callback);
  437. };
  439. /**
  440.  * Updates the cluster voting config exclusions by node ids or node names.
  441.  * @memberOf API-Cluster
  442.  *
  443.  * @param {Object} params
  444.  * @param {string} [params.node_names] - A comma-separated list of the persistent ids of the nodes to exclude from the voting configuration. If specified, you may not also specify node_names.
  445.  * @param {string} [params.node_ids] - A comma-separated list of the names of the nodes to exclude from the voting configuration. If specified, you may not also specify node_ids.
  446.  *
  447.  * @param {Object} options - Options for {@link Transport#request}
  448.  * @param {function} callback - Callback that handles errors and response
  449.  *
  450.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  451.  */
  452. ClusterApi.prototype.postVotingConfigExclusions = function clusterPostVotingConfigExclusionsApi(
  453.   params,
  454.   options,
  455.   callback
  456. ) {
  457.   [params, options, callback] = normalizeArguments(params, options, callback);
  459.   let { method, body, ...querystring } = params;
  460.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  462.   let path = '';
  463.   if (method == null) method = 'POST';
  464.   path = '/' + '_cluster' + '/' + 'voting_config_exclusions';
  466.   // build request object
  467.   const request = {
  468.     method,
  469.     path,
  470.     body: body || '',
  471.     querystring,
  472.   };
  474.   return this.transport.request(request, options, callback);
  475. };
  477. /**
  478.  * Creates or updates a component template
  479.  *
  480.  * @memberOf API-Cluster
  481.  *
  482.  * @param {Object} params
  483.  * @param {string} params.name - The name of the component template.
  484.  * @param {object} params.body - The template definition.
  485.  * @param {string} [params.cluster_manager_timeout=30s] - The amount of time to wait for a connection to the cluster manager node.
  486.  * @param {boolean} [params.create=false] - Whether the index template should only be added if new or can also replace an existing one.
  487.  *
  488.  * @param {Object} options - Options for {@link Transport#request}
  489.  * @param {function} callback - Callback that handles errors and response
  490.  *
  491.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  492.  */
  493. ClusterApi.prototype.putComponentTemplate = function clusterPutComponentTemplateApi(
  494.   params,
  495.   options,
  496.   callback
  497. ) {
  498.   [params, options, callback] = normalizeArguments(params, options, callback);
  500.   // check required parameters
  501.   if (params.name == null) {
  502.     const err = new this[kConfigurationError]('Missing required parameter: name');
  503.     return handleError(err, callback);
  504.   }
  505.   if (params.body == null) {
  506.     const err = new this[kConfigurationError]('Missing required parameter: body');
  507.     return handleError(err, callback);
  508.   }
  510.   let { method, body, name, ...querystring } = params;
  511.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  513.   let path = '';
  514.   if (method == null) method = 'PUT';
  515.   path = '/' + '_component_template' + '/' + encodeURIComponent(name);
  517.   // build request object
  518.   const request = {
  519.     method,
  520.     path,
  521.     body: body || '',
  522.     querystring,
  523.   };
  525.   return this.transport.request(request, options, callback);
  526. };
  528. /**
  529.  * Updates the cluster settings.
  530.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/cluster-settings/ OpenSearch - Cluster Settings}
  531.  * @memberOf API-Cluster
  532.  *
  533.  * @param {Object} params
  534.  * @param {boolean} [params.flat_settings] Whether to return settings in the flat form, which can improve readability, especially for heavily nested settings.
  535.  * @param {string} [params.cluster_manager_timeout=30s] - The amount of time to wait for a connection to the cluster manager node.
  536.  * @param {string} [params.timeout=30s] - The amount of time to wait for a response from the cluster.
  537.  * @param {object} params.body - The settings to be updated. Can be either 'transient' or 'persistent' (survives cluster restart).
  538.  *
  539.  * @param {Object} options - Options for {@link Transport#request}
  540.  * @param {function} callback - Callback that handles errors and response
  541.  *
  542.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  543.  */
  544. ClusterApi.prototype.putSettings = function clusterPutSettingsApi(params, options, callback) {
  545.   [params, options, callback] = normalizeArguments(params, options, callback);
  547.   // check required parameters
  548.   if (params.body == null) {
  549.     const err = new this[kConfigurationError]('Missing required parameter: body');
  550.     return handleError(err, callback);
  551.   }
  553.   let { method, body, ...querystring } = params;
  554.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  556.   let path = '';
  557.   if (method == null) method = 'PUT';
  558.   path = '/' + '_cluster' + '/' + 'settings';
  560.   // build request object
  561.   const request = {
  562.     method,
  563.     path,
  564.     body: body || '',
  565.     querystring,
  566.   };
  568.   return this.transport.request(request, options, callback);
  569. };
  571. /**
  572.  * This operation provides connection information for any remote OpenSearch clusters that you’ve configured for the local cluster, such as the remote cluster alias, connection mode (sniff or proxy), IP addresses for seed nodes, and timeout settings.
  573.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/remote-info/ OpenSearch - Remote cluster information}
  574.  * @memberOf API-Cluster
  575.  *
  576.  * @param {Object} params - (Unused)
  577.  * @param {Object} options - Options for {@link Transport#request}
  578.  * @param {function} callback - Callback that handles errors and response
  579.  *
  580.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*} {@link https://opensearch.org/docs/latest/api-reference/remote-info/#response Remote cluster information }
  581.  */
  582. ClusterApi.prototype.remoteInfo = function clusterRemoteInfoApi(params, options, callback) {
  583.   [params, options, callback] = normalizeArguments(params, options, callback);
  585.   let { method, body, ...querystring } = params;
  586.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  588.   let path = '';
  589.   if (method == null) method = 'GET';
  590.   path = '/' + '_remote' + '/' + 'info';
  592.   // build request object
  593.   const request = {
  594.     method,
  595.     path,
  596.     body: null,
  597.     querystring,
  598.   };
  600.   return this.transport.request(request, options, callback);
  601. };
  603. /**
  604.  * Allows to manually change the allocation of individual shards in the cluster.
  605.  *
  606.  * @memberOf API-Cluster
  607.  *
  608.  * @param {Object} params
  609.  * @param {object} [params.body] - The definition of 'commands' to perform ('move', 'cancel', 'allocate')
  610.  * @param {boolean} [params.dry_run] - Simulate the operation only and return the resulting state
  611.  * @param {boolean} [params.explain] - Return an explanation of why the commands can or cannot be executed
  612.  * @param {boolean} [params.retry_failed] - Retries allocation of shards that are blocked due to too many subsequent allocation failures
  613.  * @param {string | string[]} [params.metric] - Limit the information returned to the specified metrics. Defaults to all but metadata (options: _all, blocks, metadata, nodes, routing_table, cluster_manager_node, version)
  614.  *
  615.  * @param {Object} options - Options for {@link Transport#request}
  616.  * @param {function} callback - Callback that handles errors and response
  617.  *
  618.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  619.  */
  620. ClusterApi.prototype.reroute = function clusterRerouteApi(params, options, callback) {
  621.   [params, options, callback] = normalizeArguments(params, options, callback);
  623.   let { method, body, ...querystring } = params;
  624.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  626.   let path = '';
  627.   if (method == null) method = 'POST';
  628.   path = '/' + '_cluster' + '/' + 'reroute';
  630.   // build request object
  631.   const request = {
  632.     method,
  633.     path,
  634.     body: body || '',
  635.     querystring,
  636.   };
  638.   return this.transport.request(request, options, callback);
  639. };
  641. /**
  642.  * Get comprehensive information about the state of the cluster.
  643.  *
  644.  * @memberOf API-Cluster
  645.  *
  646.  * @param {Object} params
  647.  * @param {string | string[]} [params.metric] - Limit the information returned to the specified metrics. Defaults to all but metadata (options: _all, blocks, metadata, nodes, routing_table, cluster_manager_node, version).
  648.  * @param {string | string[]} [params.index] - List of index names; use '_all' or empty string to perform the operation on all indices.
  649.  * @param {boolean} [params.local=false] - Whether to return information from the local node only instead of from the cluster manager node.
  650.  * @param {string} [params.cluster_manager_timeout=30s] - The amount of time to wait for a connection to the cluster manager node.
  651.  * @param {boolean} [params.flat_settings=false] - Whether to return settings in the flat form, which can improve readability, especially for heavily nested settings.
  652.  * @param {number} [params.wait_for_metadata_version] - Wait for the metadata version to be equal or greater than the specified metadata version.
  653.  * @param {string} [params.wait_for_timeout=30s] - The maximum time to wait for wait_for_metadata_version before timing out
  654.  * @param {boolean} [params.ignore_unavailable] - Whether specified concrete indices should be ignored when unavailable (missing or closed)
  655.  * @param {boolean} [params.allow_no_indices] - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
  656.  * @param {string} [params.expand_wildcards=open] - Expands wildcard expressions to concrete indices. Combine multiple values with commas. Supported values are 'all', 'open', 'closed', 'hidden', and 'none'. Default is 'open'.
  657.  *
  658.  * @param {Object} options - Options for {@link Transport#request}
  659.  * @param {function} callback - Callback that handles errors and response
  660.  *
  661.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  662.  */
  663. ClusterApi.prototype.state = function clusterStateApi(params, options, callback) {
  664.   [params, options, callback] = normalizeArguments(params, options, callback);
  666.   // check required url components
  667.   if (params.index != null && params.metric == null) {
  668.     const err = new this[kConfigurationError]('Missing required parameter of the url: metric');
  669.     return handleError(err, callback);
  670.   }
  672.   let { method, body, metric, index, ...querystring } = params;
  673.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  675.   let path = '';
  676.   if (metric != null && index != null) {
  677.     if (method == null) method = 'GET';
  678.     path =
  679.       '/' +
  680.       '_cluster' +
  681.       '/' +
  682.       'state' +
  683.       '/' +
  684.       encodeURIComponent(metric) +
  685.       '/' +
  686.       encodeURIComponent(index);
  687.   } else if (metric != null) {
  688.     if (method == null) method = 'GET';
  689.     path = '/' + '_cluster' + '/' + 'state' + '/' + encodeURIComponent(metric);
  690.   } else {
  691.     if (method == null) method = 'GET';
  692.     path = '/' + '_cluster' + '/' + 'state';
  693.   }
  695.   // build request object
  696.   const request = {
  697.     method,
  698.     path,
  699.     body: null,
  700.     querystring,
  701.   };
  703.   return this.transport.request(request, options, callback);
  704. };
  706. /**
  707.  * The CAT aliases operation lists the mapping of aliases to indices, plus routing and filtering information.
  708.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/cluster-stats/ OpenSearch - Cluster stats}
  709.  *
  710.  * @memberOf API-Cluster
  711.  *
  712.  * @param {Object} params
  713.  * @param {string | string[]} [params.node_id] - A comma-separated list of node IDs or names to limit the returned information; use '_local' to return information from the node you're connecting to, leave empty to get information from all nodes.
  714.  *
  715.  *
  716.  * @param {Object} [options] - Options for {@link Transport#request}
  717.  * @param {function} [callback] - Callback that handles errors and response
  718.  *
  719.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*} {@link https://opensearch.org/docs/latest/api-reference/cluster-stats/#response Cluster stats Response}
  720.  */
  722. ClusterApi.prototype.stats = function clusterStatsApi(params, options, callback) {
  723.   [params, options, callback] = normalizeArguments(params, options, callback);
  725.   let { method, body, nodeId, node_id, ...querystring } = params;
  726.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  728.   let path = '';
  729.   if ((node_id || nodeId) != null) {
  730.     if (method == null) method = 'GET';
  731.     path =
  732.       '/' +
  733.       '_cluster' +
  734.       '/' +
  735.       'stats' +
  736.       '/' +
  737.       'nodes' +
  738.       '/' +
  739.       encodeURIComponent(node_id || nodeId);
  740.   } else {
  741.     if (method == null) method = 'GET';
  742.     path = '/' + '_cluster' + '/' + 'stats';
  743.   }
  745.   // build request object
  746.   const request = {
  747.     method,
  748.     path,
  749.     body: null,
  750.     querystring,
  751.   };
  753.   return this.transport.request(request, options, callback);
  754. };
  756. Object.defineProperties(ClusterApi.prototype, {
  757.   allocation_explain: {
  758.     get() {
  759.       return this.allocationExplain;
  760.     },
  761.   },
  762.   delete_component_template: {
  763.     get() {
  764.       return this.deleteComponentTemplate;
  765.     },
  766.   },
  767.   delete_voting_config_exclusions: {
  768.     get() {
  769.       return this.deleteVotingConfigExclusions;
  770.     },
  771.   },
  772.   exists_component_template: {
  773.     get() {
  774.       return this.existsComponentTemplate;
  775.     },
  776.   },
  777.   get_component_template: {
  778.     get() {
  779.       return this.getComponentTemplate;
  780.     },
  781.   },
  782.   get_settings: {
  783.     get() {
  784.       return this.getSettings;
  785.     },
  786.   },
  787.   pending_tasks: {
  788.     get() {
  789.       return this.pendingTasks;
  790.     },
  791.   },
  792.   post_voting_config_exclusions: {
  793.     get() {
  794.       return this.postVotingConfigExclusions;
  795.     },
  796.   },
  797.   put_component_template: {
  798.     get() {
  799.       return this.putComponentTemplate;
  800.     },
  801.   },
  802.   put_settings: {
  803.     get() {
  804.       return this.putSettings;
  805.     },
  806.   },
  807.   remote_info: {
  808.     get() {
  809.       return this.remoteInfo;
  810.     },
  811.   },
  812. });
  814. module.exports = ClusterApi;