Source: api/api/nodes.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-Nodes */
  37. const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils');
  38. const acceptedQuerystring = [
  39.   'pretty',
  40.   'human',
  41.   'error_trace',
  42.   'source',
  43.   'filter_path',
  44.   'interval',
  45.   'snapshots',
  46.   'threads',
  47.   'ignore_idle_threads',
  48.   'type',
  49.   'timeout',
  50.   'flat_settings',
  51.   'completion_fields',
  52.   'fielddata_fields',
  53.   'fields',
  54.   'groups',
  55.   'level',
  56.   'types',
  57.   'include_segment_file_sizes',
  58.   'include_unloaded_segments',
  59. ];
  60. const snakeCase = {
  61.   errorTrace: 'error_trace',
  62.   filterPath: 'filter_path',
  63.   ignoreIdleThreads: 'ignore_idle_threads',
  64.   flatSettings: 'flat_settings',
  65.   completionFields: 'completion_fields',
  66.   fielddataFields: 'fielddata_fields',
  67.   includeSegmentFileSizes: 'include_segment_file_sizes',
  68.   includeUnloadedSegments: 'include_unloaded_segments',
  69. };
  71. function NodesApi(transport, ConfigurationError) {
  72.   this.transport = transport;
  73.   this[kConfigurationError] = ConfigurationError;
  74. }
  76. NodesApi.prototype.clearMeteringArchive = function nodesClearMeteringArchiveApi(
  77.   params,
  78.   options,
  79.   callback
  80. ) {
  81.   [params, options, callback] = normalizeArguments(params, options, callback);
  83.   // check required parameters
  84.   if (params.node_id == null && params.nodeId == null) {
  85.     const err = new this[kConfigurationError]('Missing required parameter: node_id or nodeId');
  86.     return handleError(err, callback);
  87.   }
  88.   if (params.max_archive_version == null && params.maxArchiveVersion == null) {
  89.     const err = new this[kConfigurationError](
  90.       'Missing required parameter: max_archive_version or maxArchiveVersion'
  91.     );
  92.     return handleError(err, callback);
  93.   }
  95.   // check required url components
  96.   if (
  97.     (params.max_archive_version != null || params.maxArchiveVersion != null) &&
  98.     params.node_id == null &&
  99.     params.nodeId == null
  100.   ) {
  101.     const err = new this[kConfigurationError]('Missing required parameter of the url: node_id');
  102.     return handleError(err, callback);
  103.   }
  105.   let { method, body, nodeId, node_id, maxArchiveVersion, max_archive_version, ...querystring } =
  106.     params;
  107.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  109.   let path = '';
  110.   if (method == null) method = 'DELETE';
  111.   path =
  112.     '/' +
  113.     '_nodes' +
  114.     '/' +
  115.     encodeURIComponent(node_id || nodeId) +
  116.     '/' +
  117.     '_repositories_metering' +
  118.     '/' +
  119.     encodeURIComponent(max_archive_version || maxArchiveVersion);
  121.   // build request object
  122.   const request = {
  123.     method,
  124.     path,
  125.     body: body || '',
  126.     querystring,
  127.   };
  129.   return this.transport.request(request, options, callback);
  130. };
  132. NodesApi.prototype.getMeteringInfo = function nodesGetMeteringInfoApi(params, options, callback) {
  133.   [params, options, callback] = normalizeArguments(params, options, callback);
  135.   // check required parameters
  136.   if (params.node_id == null && params.nodeId == null) {
  137.     const err = new this[kConfigurationError]('Missing required parameter: node_id or nodeId');
  138.     return handleError(err, callback);
  139.   }
  141.   let { method, body, nodeId, node_id, ...querystring } = params;
  142.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  144.   let path = '';
  145.   if (method == null) method = 'GET';
  146.   path =
  147.     '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId) + '/' + '_repositories_metering';
  149.   // build request object
  150.   const request = {
  151.     method,
  152.     path,
  153.     body: null,
  154.     querystring,
  155.   };
  157.   return this.transport.request(request, options, callback);
  158. };
  160. /**
  161.  * Returns information about hot threads on each node in the cluster.
  162.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-hot-threads/ OpenSearch - Nodes Hot Threads}
  163.  * @memberOf API-Nodes
  164.  *
  165.  * @param {Object} params
  166.  * @param {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
  167.  * @param {string} [params.interval] - The interval for the second sampling of threads
  168.  * @param {number} [params.snapshots] - Number of samples of thread stacktrace (default: 10)
  169.  * @param {number} [params.threads] - Specify the number of threads to provide information for (default: 3)
  170.  * @param {boolean} [params.ignore_idle_threads] - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
  171.  * @param {string} [params.type] - The type to sample (default: cpu) (options: cpu, wait, block)
  172.  * @param {string} [params.timeout] - Explicit operation timeout
  173.  *
  174.  * @param {Object} options - Options for {@link Transport#request}
  175.  * @param {function} callback - Callback that handles errors and response
  176.  *
  177.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  178.  */
  179. NodesApi.prototype.hotThreads = function nodesHotThreadsApi(params, options, callback) {
  180.   [params, options, callback] = normalizeArguments(params, options, callback);
  182.   let { method, body, nodeId, node_id, ...querystring } = params;
  183.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  185.   let path = '';
  186.   if ((node_id || nodeId) != null) {
  187.     if (method == null) method = 'GET';
  188.     path = '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId) + '/' + 'hot_threads';
  189.   } else if ((node_id || nodeId) != null) {
  190.     if (method == null) method = 'GET';
  191.     path =
  192.       '/' +
  193.       '_cluster' +
  194.       '/' +
  195.       'nodes' +
  196.       '/' +
  197.       encodeURIComponent(node_id || nodeId) +
  198.       '/' +
  199.       'hotthreads';
  200.   } else if ((node_id || nodeId) != null) {
  201.     if (method == null) method = 'GET';
  202.     path = '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId) + '/' + 'hotthreads';
  203.   } else if ((node_id || nodeId) != null) {
  204.     if (method == null) method = 'GET';
  205.     path =
  206.       '/' +
  207.       '_cluster' +
  208.       '/' +
  209.       'nodes' +
  210.       '/' +
  211.       encodeURIComponent(node_id || nodeId) +
  212.       '/' +
  213.       'hot_threads';
  214.   } else {
  215.     if (method == null) method = 'GET';
  216.     path = '/' + '_nodes' + '/' + 'hot_threads';
  217.   }
  219.   // build request object
  220.   const request = {
  221.     method,
  222.     path,
  223.     body: null,
  224.     querystring,
  225.   };
  227.   return this.transport.request(request, options, callback);
  228. };
  230. /**
  231.  * Returns information about hot threads on each node in the cluster.
  232.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-info/ OpenSearch - Nodes Info}
  233.  * @memberOf API-Nodes
  234.  *
  235.  * @param {Object} params
  236.  * @param {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
  237.  * @param {string} [params.metric] - A comma-separated list of metrics you wish returned. Leave empty to return all. (options: settings, os, process, jvm, thread_pool, transport, http, plugins, ingest)
  238.  * @param {boolean} [params.flat_settings] - Return settings in flat format (default: false)
  239.  * @param {string} [params.timeout] - Explicit operation timeout
  240.  *
  241.  * @param {Object} options - Options for {@link Transport#request}
  242.  * @param {function} callback - Callback that handles errors and response
  243.  *
  244.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  245.  */
  246. NodesApi.prototype.info = function nodesInfoApi(params, options, callback) {
  247.   [params, options, callback] = normalizeArguments(params, options, callback);
  249.   let { method, body, nodeId, node_id, metric, ...querystring } = params;
  250.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  252.   let path = '';
  253.   if ((node_id || nodeId) != null && metric != null) {
  254.     if (method == null) method = 'GET';
  255.     path =
  256.       '/' +
  257.       '_nodes' +
  258.       '/' +
  259.       encodeURIComponent(node_id || nodeId) +
  260.       '/' +
  261.       encodeURIComponent(metric);
  262.   } else if ((node_id || nodeId) != null) {
  263.     if (method == null) method = 'GET';
  264.     path = '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId);
  265.   } else if (metric != null) {
  266.     if (method == null) method = 'GET';
  267.     path = '/' + '_nodes' + '/' + encodeURIComponent(metric);
  268.   } else {
  269.     if (method == null) method = 'GET';
  270.     path = '/' + '_nodes';
  271.   }
  273.   // build request object
  274.   const request = {
  275.     method,
  276.     path,
  277.     body: null,
  278.     querystring,
  279.   };
  281.   return this.transport.request(request, options, callback);
  282. };
  284. /**
  285.  * Reloads secure settings.
  286.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-reload-secure/ OpenSearch - Nodes Reload Security Settings}
  287.  * @memberOf API-Nodes
  288.  *
  289.  * @param {Object} params
  290.  * @param {string} [params.node_id] - A comma-separated list of node IDs to span the reload/reinit call. Should stay empty because reloading usually involves all cluster nodes.
  291.  * @param {string} [params.timeout] - Explicit operation timeout
  292.  * @param {Object} [params.body] - An object containing the password for the opensearch keystore
  293.  *
  294.  * @param {Object} options - Options for {@link Transport#request}
  295.  * @param {function} callback - Callback that handles errors and response
  296.  *
  297.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  298.  */
  299. NodesApi.prototype.reloadSecureSettings = function nodesReloadSecureSettingsApi(
  300.   params,
  301.   options,
  302.   callback
  303. ) {
  304.   [params, options, callback] = normalizeArguments(params, options, callback);
  306.   let { method, body, nodeId, node_id, ...querystring } = params;
  307.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  309.   let path = '';
  310.   if ((node_id || nodeId) != null) {
  311.     if (method == null) method = 'POST';
  312.     path =
  313.       '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId) + '/' + 'reload_secure_settings';
  314.   } else {
  315.     if (method == null) method = 'POST';
  316.     path = '/' + '_nodes' + '/' + 'reload_secure_settings';
  317.   }
  319.   // build request object
  320.   const request = {
  321.     method,
  322.     path,
  323.     body: body || '',
  324.     querystring,
  325.   };
  327.   return this.transport.request(request, options, callback);
  328. };
  330. /**
  331.  * Returns statistical information about nodes in the cluster.
  332.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-stats/ OpenSearch - Nodes Stats}
  333.  * @memberOf API-Nodes
  334.  *
  335.  * @param {Object} params
  336.  * @param {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
  337.  * @param {string} [params.metric] - Limit the information returned to the specified metrics (options: _all, breaker, fs, http, indices, jvm, os, process, thread_pool, transport, discovery, indexing_pressure)
  338.  * @param {string} [params.index_metric] - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified. (options: _all, completion, docs, fielddata, query_cache, flush, get, indexing, merge, request_cache, refresh, search, segments, store, warmer, suggest)
  339.  * @param {string} [params.completion_fields] - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
  340.  * @param {string} [params.fielddata_fields] - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
  341.  * @param {string} [params.fields] - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
  342.  * @param {boolean} [params.groups] - A comma-separated list of search groups for `search` index metric
  343.  * @param {string} [params.level] - Return indices stats aggregated at index, node or shard level (options: indices, node, shards)
  344.  * @param {string} [params.types] - A comma-separated list of document types for the `indexing` index metric
  345.  * @param {string} [params.timeout] - Explicit operation timeout
  346.  * @param {boolean} [params.include_segment_file_sizes] - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
  347.  * @param {boolean} [params.include_unloaded_segments] - If set to true segment stats will include stats for segments that are not currently loaded into memory
  348.  *
  349.  * @param {Object} options - Options for {@link Transport#request}
  350.  * @param {function} callback - Callback that handles errors and response
  351.  *
  352.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  353.  */
  354. NodesApi.prototype.stats = function nodesStatsApi(params, options, callback) {
  355.   [params, options, callback] = normalizeArguments(params, options, callback);
  357.   let { method, body, nodeId, node_id, metric, indexMetric, index_metric, ...querystring } = params;
  358.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  360.   let path = '';
  361.   if ((node_id || nodeId) != null && metric != null && (index_metric || indexMetric) != null) {
  362.     if (method == null) method = 'GET';
  363.     path =
  364.       '/' +
  365.       '_nodes' +
  366.       '/' +
  367.       encodeURIComponent(node_id || nodeId) +
  368.       '/' +
  369.       'stats' +
  370.       '/' +
  371.       encodeURIComponent(metric) +
  372.       '/' +
  373.       encodeURIComponent(index_metric || indexMetric);
  374.   } else if ((node_id || nodeId) != null && metric != null) {
  375.     if (method == null) method = 'GET';
  376.     path =
  377.       '/' +
  378.       '_nodes' +
  379.       '/' +
  380.       encodeURIComponent(node_id || nodeId) +
  381.       '/' +
  382.       'stats' +
  383.       '/' +
  384.       encodeURIComponent(metric);
  385.   } else if (metric != null && (index_metric || indexMetric) != null) {
  386.     if (method == null) method = 'GET';
  387.     path =
  388.       '/' +
  389.       '_nodes' +
  390.       '/' +
  391.       'stats' +
  392.       '/' +
  393.       encodeURIComponent(metric) +
  394.       '/' +
  395.       encodeURIComponent(index_metric || indexMetric);
  396.   } else if ((node_id || nodeId) != null) {
  397.     if (method == null) method = 'GET';
  398.     path = '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId) + '/' + 'stats';
  399.   } else if (metric != null) {
  400.     if (method == null) method = 'GET';
  401.     path = '/' + '_nodes' + '/' + 'stats' + '/' + encodeURIComponent(metric);
  402.   } else {
  403.     if (method == null) method = 'GET';
  404.     path = '/' + '_nodes' + '/' + 'stats';
  405.   }
  407.   // build request object
  408.   const request = {
  409.     method,
  410.     path,
  411.     body: null,
  412.     querystring,
  413.   };
  415.   return this.transport.request(request, options, callback);
  416. };
  418. /**
  419.  * Returns low-level information about REST actions usage on nodes.
  420.  * <br/> See Also: {@link https://opensearch.org/docs/latest/api-reference/nodes-apis/nodes-usage/ OpenSearch - Nodes Usage}
  421.  * @memberOf API-Nodes
  422.  *
  423.  * @param {Object} params
  424.  * @param {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
  425.  * @param {string} [params.metric] - Limit the information returned to the specified metrics (options: _all, rest_actions)
  426.  * @param {string} [params.timeout] - Explicit operation timeout
  427.  *
  428.  * @param {Object} options - Options for {@link Transport#request}
  429.  * @param {function} callback - Callback that handles errors and response
  430.  *
  431.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  432.  */
  433. NodesApi.prototype.usage = function nodesUsageApi(params, options, callback) {
  434.   [params, options, callback] = normalizeArguments(params, options, callback);
  436.   let { method, body, nodeId, node_id, metric, ...querystring } = params;
  437.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  439.   let path = '';
  440.   if ((node_id || nodeId) != null && metric != null) {
  441.     if (method == null) method = 'GET';
  442.     path =
  443.       '/' +
  444.       '_nodes' +
  445.       '/' +
  446.       encodeURIComponent(node_id || nodeId) +
  447.       '/' +
  448.       'usage' +
  449.       '/' +
  450.       encodeURIComponent(metric);
  451.   } else if ((node_id || nodeId) != null) {
  452.     if (method == null) method = 'GET';
  453.     path = '/' + '_nodes' + '/' + encodeURIComponent(node_id || nodeId) + '/' + 'usage';
  454.   } else if (metric != null) {
  455.     if (method == null) method = 'GET';
  456.     path = '/' + '_nodes' + '/' + 'usage' + '/' + encodeURIComponent(metric);
  457.   } else {
  458.     if (method == null) method = 'GET';
  459.     path = '/' + '_nodes' + '/' + 'usage';
  460.   }
  462.   // build request object
  463.   const request = {
  464.     method,
  465.     path,
  466.     body: null,
  467.     querystring,
  468.   };
  470.   return this.transport.request(request, options, callback);
  471. };
  473. Object.defineProperties(NodesApi.prototype, {
  474.   clear_metering_archive: {
  475.     get() {
  476.       return this.clearMeteringArchive;
  477.     },
  478.   },
  479.   get_metering_info: {
  480.     get() {
  481.       return this.getMeteringInfo;
  482.     },
  483.   },
  484.   hot_threads: {
  485.     get() {
  486.       return this.hotThreads;
  487.     },
  488.   },
  489.   reload_secure_settings: {
  490.     get() {
  491.       return this.reloadSecureSettings;
  492.     },
  493.   },
  494. });
  496. module.exports = NodesApi;