Source: api/api/snapshot.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-Snapshot */
  37. const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils');
  38. const acceptedQuerystring = [
  39.   'cluster_manager_timeout',
  40.   'master_timeout',
  41.   'timeout',
  42.   'pretty',
  43.   'human',
  44.   'error_trace',
  45.   'source',
  46.   'filter_path',
  47.   'wait_for_completion',
  48.   'verify',
  49.   'ignore_unavailable',
  50.   'index_details',
  51.   'include_repository',
  52.   'verbose',
  53.   'local',
  54.   'blob_count',
  55.   'concurrency',
  56.   'read_node_count',
  57.   'early_read_node_count',
  58.   'seed',
  59.   'rare_action_probability',
  60.   'max_blob_size',
  61.   'max_total_data_size',
  62.   'detailed',
  63.   'rarely_abort_writes',
  64. ];
  65. const snakeCase = {
  66.   clusterManagerTimeout: 'cluster_manager_timeout',
  67.   masterTimeout: 'master_timeout',
  68.   errorTrace: 'error_trace',
  69.   filterPath: 'filter_path',
  70.   waitForCompletion: 'wait_for_completion',
  71.   ignoreUnavailable: 'ignore_unavailable',
  72.   indexDetails: 'index_details',
  73.   includeRepository: 'include_repository',
  74.   blobCount: 'blob_count',
  75.   readNodeCount: 'read_node_count',
  76.   earlyReadNodeCount: 'early_read_node_count',
  77.   rareActionProbability: 'rare_action_probability',
  78.   maxBlobSize: 'max_blob_size',
  79.   maxTotalDataSize: 'max_total_data_size',
  80.   rarelyAbortWrites: 'rarely_abort_writes',
  81. };
  83. function SnapshotApi(transport, ConfigurationError) {
  84.   this.transport = transport;
  85.   this[kConfigurationError] = ConfigurationError;
  86. }
  88. /**
  89.  * Removes stale data from repository.
  90.  *
  91.  * @memberOf API-Snapshot
  92.  *
  93.  * @param {Object} params
  94.  * @param {string} params.repository - A repository name
  95.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  96.  * @param {string} [params.timeout] - Explicit operation timeout
  97.  *
  98.  * @param {Object} options - Options for {@link Transport#request}
  99.  * @param {function} callback - Callback that handles errors and response
  100.  *
  101.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  102.  */
  103. SnapshotApi.prototype.cleanupRepository = function snapshotCleanupRepositoryApi(
  104.   params,
  105.   options,
  106.   callback
  107. ) {
  108.   [params, options, callback] = normalizeArguments(params, options, callback);
  110.   // check required parameters
  111.   if (params.repository == null) {
  112.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  113.     return handleError(err, callback);
  114.   }
  116.   let { method, body, repository, ...querystring } = params;
  117.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  119.   let path = '';
  120.   if (method == null) method = 'POST';
  121.   path = '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + '_cleanup';
  123.   // build request object
  124.   const request = {
  125.     method,
  126.     path,
  127.     body: body || '',
  128.     querystring,
  129.   };
  131.   return this.transport.request(request, options, callback);
  132. };
  134. /**
  135.  * Clones indices from one snapshot into another snapshot in the same repository.
  136.  *
  137.  * @memberOf API-Snapshot
  138.  *
  139.  * @param {Object} params
  140.  * @param {string} params.repository - A repository name
  141.  * @param {string} params.snapshot - The name of the snapshot to clone from
  142.  * @param {Object} params.body - The snapshot clone definition
  143.  * @param {string} [params.target_snapshot] - The name of the cloned snapshot to create
  144.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  145.  *
  146.  * @param {Object} options - Options for {@link Transport#request}
  147.  * @param {function} callback - Callback that handles errors and response
  148.  *
  149.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  150.  */
  151. SnapshotApi.prototype.clone = function snapshotCloneApi(params, options, callback) {
  152.   [params, options, callback] = normalizeArguments(params, options, callback);
  154.   // check required parameters
  155.   if (params.repository == null) {
  156.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  157.     return handleError(err, callback);
  158.   }
  159.   if (params.snapshot == null) {
  160.     const err = new this[kConfigurationError]('Missing required parameter: snapshot');
  161.     return handleError(err, callback);
  162.   }
  163.   if (params.target_snapshot == null && params.targetSnapshot == null) {
  164.     const err = new this[kConfigurationError](
  165.       'Missing required parameter: target_snapshot or targetSnapshot'
  166.     );
  167.     return handleError(err, callback);
  168.   }
  169.   if (params.body == null) {
  170.     const err = new this[kConfigurationError]('Missing required parameter: body');
  171.     return handleError(err, callback);
  172.   }
  174.   // check required url components
  175.   if (
  176.     (params.target_snapshot != null || params.targetSnapshot != null) &&
  177.     (params.snapshot == null || params.repository == null)
  178.   ) {
  179.     const err = new this[kConfigurationError](
  180.       'Missing required parameter of the url: snapshot, repository'
  181.     );
  182.     return handleError(err, callback);
  183.   } else if (params.snapshot != null && params.repository == null) {
  184.     const err = new this[kConfigurationError]('Missing required parameter of the url: repository');
  185.     return handleError(err, callback);
  186.   }
  188.   let { method, body, repository, snapshot, targetSnapshot, target_snapshot, ...querystring } =
  189.     params;
  190.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  192.   let path = '';
  193.   if (method == null) method = 'PUT';
  194.   path =
  195.     '/' +
  196.     '_snapshot' +
  197.     '/' +
  198.     encodeURIComponent(repository) +
  199.     '/' +
  200.     encodeURIComponent(snapshot) +
  201.     '/' +
  202.     '_clone' +
  203.     '/' +
  204.     encodeURIComponent(target_snapshot || targetSnapshot);
  206.   // build request object
  207.   const request = {
  208.     method,
  209.     path,
  210.     body: body || '',
  211.     querystring,
  212.   };
  214.   return this.transport.request(request, options, callback);
  215. };
  217. /**
  218.  * Creates a snapshot in a repository.
  219.  *
  220.  * @memberOf API-Snapshot
  221.  *
  222.  * @param {Object} params
  223.  * @param {string} params.repository - A repository name
  224.  * @param {string} params.snapshot - A snapshot name
  225.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  226.  * @param {boolean} [params.wait_for_completion] - Should this request wait until the operation has completed before returning
  227.  * @param {Object} [params.body] - The snapshot definition
  228.  *
  229.  * @param {Object} options - Options for {@link Transport#request}
  230.  * @param {function} callback - Callback that handles errors and response
  231.  *
  232.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  233.  */
  234. SnapshotApi.prototype.create = function snapshotCreateApi(params, options, callback) {
  235.   [params, options, callback] = normalizeArguments(params, options, callback);
  237.   // check required parameters
  238.   if (params.repository == null) {
  239.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  240.     return handleError(err, callback);
  241.   }
  242.   if (params.snapshot == null) {
  243.     const err = new this[kConfigurationError]('Missing required parameter: snapshot');
  244.     return handleError(err, callback);
  245.   }
  247.   // check required url components
  248.   if (params.snapshot != null && params.repository == null) {
  249.     const err = new this[kConfigurationError]('Missing required parameter of the url: repository');
  250.     return handleError(err, callback);
  251.   }
  253.   let { method, body, repository, snapshot, ...querystring } = params;
  254.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  256.   let path = '';
  257.   if (method == null) method = 'PUT';
  258.   path =
  259.     '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + encodeURIComponent(snapshot);
  261.   // build request object
  262.   const request = {
  263.     method,
  264.     path,
  265.     body: body || '',
  266.     querystring,
  267.   };
  269.   return this.transport.request(request, options, callback);
  270. };
  272. /**
  273.  * Creates a repository.
  274.  *
  275.  * @memberOf API-Snapshot
  276.  *
  277.  * @param {Object} params
  278.  * @param {string} params.repository - A repository name
  279.  * @param {Object} params.body - The repository definition
  280.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  281.  * @param {string} [params.timeout] - Explicit operation timeout
  282.  * @param {boolean} [params.verify] - Whether to verify the repository after creation
  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. SnapshotApi.prototype.createRepository = function snapshotCreateRepositoryApi(
  290.   params,
  291.   options,
  292.   callback
  293. ) {
  294.   [params, options, callback] = normalizeArguments(params, options, callback);
  296.   // check required parameters
  297.   if (params.repository == null) {
  298.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  299.     return handleError(err, callback);
  300.   }
  301.   if (params.body == null) {
  302.     const err = new this[kConfigurationError]('Missing required parameter: body');
  303.     return handleError(err, callback);
  304.   }
  306.   let { method, body, repository, ...querystring } = params;
  307.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  309.   let path = '';
  310.   if (method == null) method = 'PUT';
  311.   path = '/' + '_snapshot' + '/' + encodeURIComponent(repository);
  313.   // build request object
  314.   const request = {
  315.     method,
  316.     path,
  317.     body: body || '',
  318.     querystring,
  319.   };
  321.   return this.transport.request(request, options, callback);
  322. };
  324. /**
  325.  * Deletes a snapshot.
  326.  *
  327.  * @memberOf API-Snapshot
  328.  *
  329.  * @param {Object} params
  330.  * @param {string} [params.repository] - A repository name
  331.  * @param {string} [params.snapshot] - A snapshot name
  332.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to master node
  333.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  334.  *
  335.  * @param {Object} options - Options for {@link Transport#request}
  336.  * @param {function} callback - Callback that handles errors and response
  337.  *
  338.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  339.  */
  340. SnapshotApi.prototype.delete = function snapshotDeleteApi(params, options, callback) {
  341.   [params, options, callback] = normalizeArguments(params, options, callback);
  343.   // check required parameters
  344.   if (params.repository == null) {
  345.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  346.     return handleError(err, callback);
  347.   }
  348.   if (params.snapshot == null) {
  349.     const err = new this[kConfigurationError]('Missing required parameter: snapshot');
  350.     return handleError(err, callback);
  351.   }
  353.   // check required url components
  354.   if (params.snapshot != null && params.repository == null) {
  355.     const err = new this[kConfigurationError]('Missing required parameter of the url: repository');
  356.     return handleError(err, callback);
  357.   }
  359.   let { method, body, repository, snapshot, ...querystring } = params;
  360.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  362.   let path = '';
  363.   if (method == null) method = 'DELETE';
  364.   path =
  365.     '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + encodeURIComponent(snapshot);
  367.   // build request object
  368.   const request = {
  369.     method,
  370.     path,
  371.     body: body || '',
  372.     querystring,
  373.   };
  375.   return this.transport.request(request, options, callback);
  376. };
  378. /**
  379.  * Deletes a repository.
  380.  *
  381.  * @memberOf API-Snapshot
  382.  *
  383.  * @param {Object} params
  384.  * @param {string} [params.repository] - Name of the snapshot repository to unregister. Wildcard (`*`) patterns are supported.
  385.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to master node
  386.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  387.  * @param {string} [params.timeout] - Explicit operation timeout
  388.  *
  389.  * @param {Object} options - Options for {@link Transport#request}
  390.  * @param {function} callback - Callback that handles errors and response
  391.  *
  392.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  393.  */
  394. SnapshotApi.prototype.deleteRepository = function snapshotDeleteRepositoryApi(
  395.   params,
  396.   options,
  397.   callback
  398. ) {
  399.   [params, options, callback] = normalizeArguments(params, options, callback);
  401.   // check required parameters
  402.   if (params.repository == null) {
  403.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  404.     return handleError(err, callback);
  405.   }
  407.   let { method, body, repository, ...querystring } = params;
  408.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  410.   let path = '';
  411.   if (method == null) method = 'DELETE';
  412.   path = '/' + '_snapshot' + '/' + encodeURIComponent(repository);
  414.   // build request object
  415.   const request = {
  416.     method,
  417.     path,
  418.     body: body || '',
  419.     querystring,
  420.   };
  422.   return this.transport.request(request, options, callback);
  423. };
  425. /**
  426.  * Returns information about a snapshot.
  427.  *
  428.  * @memberOf API-Snapshot
  429.  *
  430.  * @param {Object} params
  431.  * @param {string} [params.repository] - A repository name
  432.  * @param {string} [params.snapshot] - A comma-separated list of snapshot names
  433.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to master node
  434.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  435.  * @param {boolean} [params.ignore_unavailable] - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
  436.  * @param {boolean} [params.index_details] - Whether to include details of each index in the snapshot, if those details are available. Defaults to false.
  437.  * @param {boolean} [params.include_repository] - Whether to include the repository name in the snapshot info. Defaults to true.
  438.  * @param {boolean} [params.verbose] - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
  439.  *
  440.  * @param {Object} options - Options for {@link Transport#request}
  441.  * @param {function} callback - Callback that handles errors and response
  442.  *
  443.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  444.  */
  445. SnapshotApi.prototype.get = function snapshotGetApi(params, options, callback) {
  446.   [params, options, callback] = normalizeArguments(params, options, callback);
  448.   // check required parameters
  449.   if (params.repository == null) {
  450.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  451.     return handleError(err, callback);
  452.   }
  453.   if (params.snapshot == null) {
  454.     const err = new this[kConfigurationError]('Missing required parameter: snapshot');
  455.     return handleError(err, callback);
  456.   }
  458.   // check required url components
  459.   if (params.snapshot != null && params.repository == null) {
  460.     const err = new this[kConfigurationError]('Missing required parameter of the url: repository');
  461.     return handleError(err, callback);
  462.   }
  464.   let { method, body, repository, snapshot, ...querystring } = params;
  465.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  467.   let path = '';
  468.   if (method == null) method = 'GET';
  469.   path =
  470.     '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + encodeURIComponent(snapshot);
  472.   // build request object
  473.   const request = {
  474.     method,
  475.     path,
  476.     body: null,
  477.     querystring,
  478.   };
  480.   return this.transport.request(request, options, callback);
  481. };
  483. /**
  484.  * Returns information about a snapshot.
  485.  *
  486.  * @memberOf API-Snapshot
  487.  *
  488.  * @param {Object} params
  489.  * @param {string} [params.repository] - A comma-separated list of repository names
  490.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to cluster_manager node
  491.  * @param {boolean} [params.local] - Return local information, do not retrieve the state from cluster_manager node (default: false)
  492.  *
  493.  * @param {Object} options - Options for {@link Transport#request}
  494.  * @param {function} callback - Callback that handles errors and response
  495.  *
  496.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  497.  */
  498. SnapshotApi.prototype.getRepository = function snapshotGetRepositoryApi(params, options, callback) {
  499.   [params, options, callback] = normalizeArguments(params, options, callback);
  501.   let { method, body, repository, ...querystring } = params;
  502.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  504.   let path = '';
  505.   if (repository != null) {
  506.     if (method == null) method = 'GET';
  507.     path = '/' + '_snapshot' + '/' + encodeURIComponent(repository);
  508.   } else {
  509.     if (method == null) method = 'GET';
  510.     path = '/' + '_snapshot';
  511.   }
  513.   // build request object
  514.   const request = {
  515.     method,
  516.     path,
  517.     body: null,
  518.     querystring,
  519.   };
  521.   return this.transport.request(request, options, callback);
  522. };
  524. /**
  525.  * Analyzes a repository for correctness and performance
  526.  *
  527.  * @memberOf API-Snapshot
  528.  *
  529.  * @param {Object} params
  530.  * @param {string} [params.repository] - A repository name
  531.  * @param {number} [params.blob_count] - Number of blobs to create during the test. Defaults to 100.
  532.  * @param {number} [params.concurrency] - Number of operations to run concurrently during the test. Defaults to 10.
  533.  * @param {number} [params.read_node_count] - Number of nodes on which to read a blob after writing. Defaults to 10.
  534.  * @param {number} [params.early_read_node_count] - Number of nodes on which to perform an early read on a blob, i.e. before writing has completed. Early reads are rare actions so the 'rare_action_probability' parameter is also relevant. Defaults to 2.
  535.  * @param {number} [params.seed] - Seed for the random number generator used to create the test workload. Defaults to a random value.
  536.  * @param {number} [params.rare_action_probability] - Probability of taking a rare action such as an early read or an overwrite. Defaults to 0.02.
  537.  * @param {string} [params.max_blob_size] - Maximum size of a blob to create during the test, e.g '1gb' or '100mb'. Defaults to '10mb'.
  538.  * @param {string} [params.max_total_data_size] - Maximum total size of all blobs to create during the test, e.g '1tb' or '100gb'. Defaults to '1gb'.
  539.  * @param {string} [params.timeout] - Explicit operation timeout. Defaults to '30s'.
  540.  * @param {boolean} [params.detailed] - Whether to return detailed results or a summary. Defaults to 'false' so that only the summary is returned.
  541.  * @param {boolean} [params.rarely_abort_writes] - Whether to rarely abort writes before they complete. Defaults to 'true'.
  542.  *
  543.  * @param {Object} options - Options for {@link Transport#request}
  544.  * @param {function} callback - Callback that handles errors and response
  545.  *
  546.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  547.  */
  548. SnapshotApi.prototype.repositoryAnalyze = function snapshotRepositoryAnalyzeApi(
  549.   params,
  550.   options,
  551.   callback
  552. ) {
  553.   [params, options, callback] = normalizeArguments(params, options, callback);
  555.   // check required parameters
  556.   if (params.repository == null) {
  557.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  558.     return handleError(err, callback);
  559.   }
  561.   let { method, body, repository, ...querystring } = params;
  562.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  564.   let path = '';
  565.   if (method == null) method = 'POST';
  566.   path = '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + '_analyze';
  568.   // build request object
  569.   const request = {
  570.     method,
  571.     path,
  572.     body: body || '',
  573.     querystring,
  574.   };
  576.   return this.transport.request(request, options, callback);
  577. };
  579. /**
  580.  * Restores a snapshot.
  581.  *
  582.  * @memberOf API-Snapshot
  583.  *
  584.  * @param {Object} params
  585.  * @param {string} [params.repository] - A repository name
  586.  * @param {string} [params.snapshot] - A snapshot name
  587.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to master node
  588.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  589.  * @param {boolean} [params.wait_for_completion] - Should this request wait until the operation has completed before returning
  590.  * @param {Object} [params.body] - Details of what to restore
  591.  *
  592.  * @param {Object} options - Options for {@link Transport#request}
  593.  * @param {function} callback - Callback that handles errors and response
  594.  *
  595.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  596.  */
  597. SnapshotApi.prototype.restore = function snapshotRestoreApi(params, options, callback) {
  598.   [params, options, callback] = normalizeArguments(params, options, callback);
  600.   // check required parameters
  601.   if (params.repository == null) {
  602.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  603.     return handleError(err, callback);
  604.   }
  605.   if (params.snapshot == null) {
  606.     const err = new this[kConfigurationError]('Missing required parameter: snapshot');
  607.     return handleError(err, callback);
  608.   }
  610.   // check required url components
  611.   if (params.snapshot != null && params.repository == null) {
  612.     const err = new this[kConfigurationError]('Missing required parameter of the url: repository');
  613.     return handleError(err, callback);
  614.   }
  616.   let { method, body, repository, snapshot, ...querystring } = params;
  617.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  619.   let path = '';
  620.   if (method == null) method = 'POST';
  621.   path =
  622.     '/' +
  623.     '_snapshot' +
  624.     '/' +
  625.     encodeURIComponent(repository) +
  626.     '/' +
  627.     encodeURIComponent(snapshot) +
  628.     '/' +
  629.     '_restore';
  631.   // build request object
  632.   const request = {
  633.     method,
  634.     path,
  635.     body: body || '',
  636.     querystring,
  637.   };
  639.   return this.transport.request(request, options, callback);
  640. };
  642. /**
  643.  * Returns information about the status of a snapshot.
  644.  *
  645.  * @memberOf API-Snapshot
  646.  *
  647.  * @param {Object} params
  648.  * @param {string} [params.repository] - A repository name
  649.  * @param {string} [params.snapshot] - A comma-separated list of snapshot names
  650.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to master node
  651.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  652.  * @param {boolean} [params.ignore_unavailable] - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
  653.  *
  654.  * @param {Object} options - Options for {@link Transport#request}
  655.  * @param {function} callback - Callback that handles errors and response
  656.  *
  657.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  658.  */
  659. SnapshotApi.prototype.status = function snapshotStatusApi(params, options, callback) {
  660.   [params, options, callback] = normalizeArguments(params, options, callback);
  662.   // check required url components
  663.   if (params.snapshot != null && params.repository == null) {
  664.     const err = new this[kConfigurationError]('Missing required parameter of the url: repository');
  665.     return handleError(err, callback);
  666.   }
  668.   let { method, body, repository, snapshot, ...querystring } = params;
  669.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  671.   let path = '';
  672.   if (repository != null && snapshot != null) {
  673.     if (method == null) method = 'GET';
  674.     path =
  675.       '/' +
  676.       '_snapshot' +
  677.       '/' +
  678.       encodeURIComponent(repository) +
  679.       '/' +
  680.       encodeURIComponent(snapshot) +
  681.       '/' +
  682.       '_status';
  683.   } else if (repository != null) {
  684.     if (method == null) method = 'GET';
  685.     path = '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + '_status';
  686.   } else {
  687.     if (method == null) method = 'GET';
  688.     path = '/' + '_snapshot' + '/' + '_status';
  689.   }
  691.   // build request object
  692.   const request = {
  693.     method,
  694.     path,
  695.     body: null,
  696.     querystring,
  697.   };
  699.   return this.transport.request(request, options, callback);
  700. };
  702. /**
  703.  * Verifies a repository.
  704.  *
  705.  * @memberOf API-Snapshot
  706.  *
  707.  * @param {Object} params
  708.  * @param {string} [params.repository] - A repository name
  709.  * @param {string} [params.master_timeout] - (DEPRECATED: use cluster_manager_timeout instead) Explicit operation timeout for connection to master node
  710.  * @param {string} [params.cluster_manager_timeout] - Explicit operation timeout for connection to cluster_manager node
  711.  * @param {string} [params.timeout] - Explicit operation timeout
  712.  *
  713.  * @param {Object} options - Options for {@link Transport#request}
  714.  * @param {function} callback - Callback that handles errors and response
  715.  *
  716.  * @returns {{abort: function(), then: function(), catch: function()}|Promise<never>|*}
  717.  */
  718. SnapshotApi.prototype.verifyRepository = function snapshotVerifyRepositoryApi(
  719.   params,
  720.   options,
  721.   callback
  722. ) {
  723.   [params, options, callback] = normalizeArguments(params, options, callback);
  725.   // check required parameters
  726.   if (params.repository == null) {
  727.     const err = new this[kConfigurationError]('Missing required parameter: repository');
  728.     return handleError(err, callback);
  729.   }
  731.   let { method, body, repository, ...querystring } = params;
  732.   querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring);
  734.   let path = '';
  735.   if (method == null) method = 'POST';
  736.   path = '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + '_verify';
  738.   // build request object
  739.   const request = {
  740.     method,
  741.     path,
  742.     body: body || '',
  743.     querystring,
  744.   };
  746.   return this.transport.request(request, options, callback);
  747. };
  749. Object.defineProperties(SnapshotApi.prototype, {
  750.   cleanup_repository: {
  751.     get() {
  752.       return this.cleanupRepository;
  753.     },
  754.   },
  755.   create_repository: {
  756.     get() {
  757.       return this.createRepository;
  758.     },
  759.   },
  760.   delete_repository: {
  761.     get() {
  762.       return this.deleteRepository;
  763.     },
  764.   },
  765.   get_repository: {
  766.     get() {
  767.       return this.getRepository;
  768.     },
  769.   },
  770.   repository_analyze: {
  771.     get() {
  772.       return this.repositoryAnalyze;
  773.     },
  774.   },
  775.   verify_repository: {
  776.     get() {
  777.       return this.verifyRepository;
  778.     },
  779.   },
  780. });
  782. module.exports = SnapshotApi;