diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java index f4de3d32bad8..a2b4dd0aafd1 100644 --- a/client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java @@ -264,6 +264,7 @@ public class RestHighLevelClient implements Closeable { private final EqlClient eqlClient = new EqlClient(this); private final AsyncSearchClient asyncSearchClient = new AsyncSearchClient(this); private final TextStructureClient textStructureClient = new TextStructureClient(this); + private final SearchableSnapshotsClient searchableSnapshotsClient = new SearchableSnapshotsClient(this); /** * Creates a {@link RestHighLevelClient} given the low level {@link RestClientBuilder} that allows to build the @@ -454,6 +455,16 @@ public class RestHighLevelClient implements Closeable { return textStructureClient; } + /** + * A wrapper for the {@link RestHighLevelClient} that provides methods for accessing the Searchable Snapshots APIs. + *

+ * See the Searchable Snapshots + * APIs on elastic.co for more information. + */ + public SearchableSnapshotsClient searchableSnapshots() { + return searchableSnapshotsClient; + } + /** * Provides methods for accessing the Elastic Licensed Migration APIs that * are shipped with the default distribution of Elasticsearch. All of diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/SearchableSnapshotsClient.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/SearchableSnapshotsClient.java new file mode 100644 index 000000000000..66ef048e9ab1 --- /dev/null +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/SearchableSnapshotsClient.java @@ -0,0 +1,77 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +package org.elasticsearch.client; + +import org.elasticsearch.action.ActionListener; +import org.elasticsearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse; +import org.elasticsearch.client.searchable_snapshots.MountSnapshotRequest; + +import java.io.IOException; +import java.util.Collections; +import java.util.Objects; + +/** + * A wrapper for the {@link RestHighLevelClient} that provides methods for accessing searchable snapshots APIs. + * + * See the Searchable Snapshots + * APIs on elastic.co for more information. + */ +public class SearchableSnapshotsClient { + + private RestHighLevelClient restHighLevelClient; + + public SearchableSnapshotsClient(final RestHighLevelClient restHighLevelClient) { + this.restHighLevelClient = Objects.requireNonNull(restHighLevelClient); + } + + /** + * Executes the mount snapshot API, which mounts a snapshot as a searchable snapshot. + * + * See the + * docs for more information. + * + * @param request the request + * @param options the request options + * @return the response + * @throws IOException if an I/O exception occurred sending the request, or receiving or parsing the response + */ + public RestoreSnapshotResponse mountSnapshot(final MountSnapshotRequest request, final RequestOptions options) throws IOException { + return restHighLevelClient.performRequestAndParseEntity( + request, + SearchableSnapshotsRequestConverters::mountSnapshot, + options, + RestoreSnapshotResponse::fromXContent, + Collections.emptySet() + ); + } + + /** + * Asynchronously executes the mount snapshot API, which mounts a snapshot as a searchable snapshot. + * + * @param request the request + * @param options the request options + * @param listener the listener to be notified upon request completion + * @return cancellable that may be used to cancel the request + */ + public Cancellable mountSnapshotAsync( + final MountSnapshotRequest request, + final RequestOptions options, + final ActionListener listener) + { + return restHighLevelClient.performRequestAsyncAndParseEntity( + request, + SearchableSnapshotsRequestConverters::mountSnapshot, + options, + RestoreSnapshotResponse::fromXContent, + listener, + Collections.emptySet() + ); + } + +} diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/SearchableSnapshotsRequestConverters.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/SearchableSnapshotsRequestConverters.java new file mode 100644 index 000000000000..3b90495f42e1 --- /dev/null +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/SearchableSnapshotsRequestConverters.java @@ -0,0 +1,44 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +package org.elasticsearch.client; + +import org.apache.http.client.methods.HttpPost; +import org.elasticsearch.client.searchable_snapshots.MountSnapshotRequest; + +import java.io.IOException; + +import static org.elasticsearch.client.RequestConverters.REQUEST_BODY_CONTENT_TYPE; +import static org.elasticsearch.client.RequestConverters.createEntity; + +final class SearchableSnapshotsRequestConverters { + + static Request mountSnapshot(final MountSnapshotRequest mountSnapshotRequest) throws IOException { + final String endpoint = new RequestConverters.EndpointBuilder() + .addPathPartAsIs("_snapshot") + .addPathPart(mountSnapshotRequest.getRepository()) + .addPathPart(mountSnapshotRequest.getSnapshot()) + .addPathPartAsIs("_mount") + .build(); + final Request request = new Request(HttpPost.METHOD_NAME, endpoint); + final RequestConverters.Params parameters = new RequestConverters.Params(); + if (mountSnapshotRequest.getMasterTimeout() != null) { + parameters.withMasterTimeout(mountSnapshotRequest.getMasterTimeout()); + } + if (mountSnapshotRequest.getWaitForCompletion() != null) { + parameters.withWaitForCompletion(mountSnapshotRequest.getWaitForCompletion()); + } + if (mountSnapshotRequest.getStorage() != null) { + parameters.putParam("storage", mountSnapshotRequest.getStorage().storageName()); + } + request.addParameters(parameters.asMap()); + request.setEntity(createEntity(mountSnapshotRequest, REQUEST_BODY_CONTENT_TYPE)); + return request; + } + +} diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/searchable_snapshots/MountSnapshotRequest.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/searchable_snapshots/MountSnapshotRequest.java new file mode 100644 index 000000000000..9abd35065878 --- /dev/null +++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/searchable_snapshots/MountSnapshotRequest.java @@ -0,0 +1,156 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +package org.elasticsearch.client.searchable_snapshots; + +import org.elasticsearch.client.Validatable; +import org.elasticsearch.common.settings.Settings; +import org.elasticsearch.common.unit.TimeValue; +import org.elasticsearch.common.xcontent.ToXContentObject; +import org.elasticsearch.common.xcontent.XContentBuilder; + +import java.io.IOException; +import java.util.Objects; + +public class MountSnapshotRequest implements ToXContentObject, Validatable { + + private final String repository; + + public String getRepository() { + return repository; + } + + private final String snapshot; + + public String getSnapshot() { + return snapshot; + } + + private final String index; + + public String getIndex() { + return index; + } + + public MountSnapshotRequest(final String repository, final String snapshot, final String index) { + this.repository = Objects.requireNonNull(repository); + this.snapshot = Objects.requireNonNull(snapshot); + this.index = Objects.requireNonNull(index); + } + + private TimeValue masterTimeout; + + public TimeValue getMasterTimeout() { + return masterTimeout; + } + + public MountSnapshotRequest masterTimeout(final TimeValue masterTimeout) { + this.masterTimeout = masterTimeout; + return this; + } + + private Boolean waitForCompletion; + + public Boolean getWaitForCompletion() { + return waitForCompletion; + } + + public MountSnapshotRequest waitForCompletion(final boolean waitForCompletion) { + this.waitForCompletion = waitForCompletion; + return this; + } + + public enum Storage { + + FULL_COPY("full_copy"), + SHARED_CACHE("shared_cache"); + + private final String storageName; + + public String storageName() { + return storageName; + } + + Storage(final String storageName) { + this.storageName = storageName; + } + + } + + private Storage storage; + + public Storage getStorage() { + return storage; + } + + public MountSnapshotRequest storage(final Storage storage) { + this.storage = storage; + return this; + } + + private String renamedIndex; + + public String getRenamedIndex() { + return renamedIndex; + } + + public MountSnapshotRequest renamedIndex(final String renamedIndex) { + this.renamedIndex = renamedIndex; + return this; + } + + private Settings indexSettings; + + public Settings getIndexSettings() { + return indexSettings; + } + + public MountSnapshotRequest indexSettings(final Settings indexSettings) { + this.indexSettings = indexSettings; + return this; + } + + private String[] ignoredIndexSettings; + + public String[] getIgnoredIndexSettings() { + return ignoredIndexSettings; + } + + public MountSnapshotRequest ignoredIndexSettings(final String[] ignoredIndexSettings) { + if (ignoredIndexSettings != null) { + for (final String ignoredIndexSetting : ignoredIndexSettings) { + Objects.requireNonNull(ignoredIndexSetting); + } + } + this.ignoredIndexSettings = ignoredIndexSettings; + return this; + } + + @Override + public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException { + builder.startObject(); + { + builder.field("index", index); + if (renamedIndex != null) { + builder.field("renamed_index", renamedIndex); + } + if (indexSettings != null) { + builder.startObject("index_settings"); { + indexSettings.toXContent(builder, params); + } + builder.endObject(); + } + if (ignoredIndexSettings != null) { + builder.array("ignored_index_settings", ignoredIndexSettings); + } + } + builder.endObject(); + return builder; + } + +} diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/RestHighLevelClientTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/RestHighLevelClientTests.java index 5ede2016c2e4..cb321e0329cf 100644 --- a/client/rest-high-level/src/test/java/org/elasticsearch/client/RestHighLevelClientTests.java +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/RestHighLevelClientTests.java @@ -918,6 +918,7 @@ public class RestHighLevelClientTests extends ESTestCase { apiName.startsWith("enrich.") == false && apiName.startsWith("transform.") == false && apiName.startsWith("text_structure.") == false && + apiName.startsWith("searchable_snapshots.") == false && apiName.startsWith("eql.") == false && apiName.endsWith("freeze") == false && apiName.endsWith("reload_analyzers") == false && diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/SearchableSnapshotsIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/SearchableSnapshotsIT.java new file mode 100644 index 000000000000..028abd9cc8ef --- /dev/null +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/SearchableSnapshotsIT.java @@ -0,0 +1,82 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +package org.elasticsearch.client; + +import org.elasticsearch.action.admin.cluster.repositories.put.PutRepositoryRequest; +import org.elasticsearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest; +import org.elasticsearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse; +import org.elasticsearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse; +import org.elasticsearch.action.index.IndexRequest; +import org.elasticsearch.action.index.IndexResponse; +import org.elasticsearch.action.search.SearchRequest; +import org.elasticsearch.action.search.SearchResponse; +import org.elasticsearch.action.support.WriteRequest; +import org.elasticsearch.action.support.master.AcknowledgedResponse; +import org.elasticsearch.client.indices.CreateIndexRequest; +import org.elasticsearch.client.indices.CreateIndexResponse; +import org.elasticsearch.client.searchable_snapshots.MountSnapshotRequest; +import org.elasticsearch.common.xcontent.XContentType; +import org.elasticsearch.repositories.fs.FsRepository; +import org.elasticsearch.rest.RestStatus; + +import java.io.IOException; + +import static org.hamcrest.Matchers.anEmptyMap; +import static org.hamcrest.Matchers.is; + +public class SearchableSnapshotsIT extends ESRestHighLevelClientTestCase { + + public void testMountSnapshot() throws IOException { + { + final CreateIndexRequest request = new CreateIndexRequest("index"); + final CreateIndexResponse response = highLevelClient().indices().create(request, RequestOptions.DEFAULT); + assertThat(response.isAcknowledged(), is(true)); + } + + { + final IndexRequest request = new IndexRequest("index") + .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE) + .source("{}", XContentType.JSON); + final IndexResponse response = highLevelClient().index(request, RequestOptions.DEFAULT); + assertThat(response.status(), is(RestStatus.CREATED)); + } + + { + final PutRepositoryRequest request = new PutRepositoryRequest("repository"); + request.settings("{\"location\": \".\"}", XContentType.JSON); + request.type(FsRepository.TYPE); + final AcknowledgedResponse response = highLevelClient().snapshot().createRepository(request, RequestOptions.DEFAULT); + assertThat(response.isAcknowledged(), is(true)); + } + + { + final CreateSnapshotRequest request = + new CreateSnapshotRequest("repository", "snapshot").waitForCompletion(true); + final CreateSnapshotResponse response = highLevelClient().snapshot().create(request, RequestOptions.DEFAULT); + assertThat(response.getSnapshotInfo().status(), is(RestStatus.OK)); + } + + { + final MountSnapshotRequest request = new MountSnapshotRequest("repository", "snapshot", "index") + .waitForCompletion(true) + .renamedIndex("renamed_index"); + final SearchableSnapshotsClient client = new SearchableSnapshotsClient(highLevelClient()); + final RestoreSnapshotResponse response = execute(request, client::mountSnapshot, client::mountSnapshotAsync); + assertThat(response.getRestoreInfo().successfulShards(), is(1)); + } + + { + final SearchRequest request = new SearchRequest("renamed_index"); + final SearchResponse response = highLevelClient().search(request, RequestOptions.DEFAULT); + assertThat(response.getHits().getTotalHits().value, is(1L)); + assertThat(response.getHits().getHits()[0].getSourceAsMap(), anEmptyMap()); + } + } + +} diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/SearchableSnapshotsRequestConvertersTests.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/SearchableSnapshotsRequestConvertersTests.java new file mode 100644 index 000000000000..10f6d9df5445 --- /dev/null +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/SearchableSnapshotsRequestConvertersTests.java @@ -0,0 +1,58 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +package org.elasticsearch.client; + +import org.apache.http.client.methods.HttpPost; +import org.elasticsearch.client.searchable_snapshots.MountSnapshotRequest; +import org.elasticsearch.common.unit.TimeValue; +import org.elasticsearch.test.ESTestCase; + +import java.io.IOException; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.nullValue; + +public class SearchableSnapshotsRequestConvertersTests extends ESTestCase { + + public void testMountSnapshot() throws IOException { + final MountSnapshotRequest request = + new MountSnapshotRequest(randomAlphaOfLength(8), randomAlphaOfLength(8), randomAlphaOfLength(8)); + if (randomBoolean()) { + request.masterTimeout(TimeValue.parseTimeValue(randomTimeValue(), "master_timeout")); + } + if (randomBoolean()) { + request.waitForCompletion(randomBoolean()); + } + if (randomBoolean()) { + request.storage(randomFrom(MountSnapshotRequest.Storage.FULL_COPY, MountSnapshotRequest.Storage.SHARED_CACHE)); + } + final Request result = SearchableSnapshotsRequestConverters.mountSnapshot(request); + assertThat(result.getMethod(), equalTo(HttpPost.METHOD_NAME)); + assertThat(result.getEndpoint(), equalTo("/_snapshot/" + request.getRepository() + "/" + request.getSnapshot() + "/_mount")); + if (request.getMasterTimeout() != null) { + final TimeValue expectedValue = request.getMasterTimeout(); + assertThat(result.getParameters().get("master_timeout"), is(expectedValue.getStringRep())); + } else { + assertThat(result.getParameters().get("master_timeout"), nullValue()); + } + if (request.getWaitForCompletion() != null) { + assertThat(result.getParameters().get("wait_for_completion"), is(Boolean.toString(request.getWaitForCompletion()))); + } else { + assertThat(result.getParameters().get("wait_for_completion"), nullValue()); + } + if (request.getStorage() != null) { + assertThat(result.getParameters().get("storage"), is(request.getStorage().storageName())); + } else { + assertThat(result.getParameters().get("storage"), nullValue()); + } + RequestConvertersTests.assertToXContentBody(request, result.getEntity()); + } + +} diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/SearchableSnapshotsDocumentationIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/SearchableSnapshotsDocumentationIT.java new file mode 100644 index 000000000000..52added4b33b --- /dev/null +++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/SearchableSnapshotsDocumentationIT.java @@ -0,0 +1,133 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +package org.elasticsearch.client.documentation; + +import org.elasticsearch.action.ActionListener; +import org.elasticsearch.action.LatchedActionListener; +import org.elasticsearch.action.admin.cluster.repositories.put.PutRepositoryRequest; +import org.elasticsearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest; +import org.elasticsearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse; +import org.elasticsearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse; +import org.elasticsearch.action.index.IndexRequest; +import org.elasticsearch.action.index.IndexResponse; +import org.elasticsearch.action.support.WriteRequest; +import org.elasticsearch.action.support.master.AcknowledgedResponse; +import org.elasticsearch.client.ESRestHighLevelClientTestCase; +import org.elasticsearch.client.RequestOptions; +import org.elasticsearch.client.RestHighLevelClient; +import org.elasticsearch.client.indices.CreateIndexRequest; +import org.elasticsearch.client.indices.CreateIndexResponse; +import org.elasticsearch.client.searchable_snapshots.MountSnapshotRequest; +import org.elasticsearch.common.settings.Settings; +import org.elasticsearch.common.unit.TimeValue; +import org.elasticsearch.common.xcontent.XContentType; +import org.elasticsearch.repositories.fs.FsRepository; +import org.elasticsearch.rest.RestStatus; +import org.elasticsearch.snapshots.RestoreInfo; + +import java.io.IOException; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +import static org.hamcrest.Matchers.is; + +public class SearchableSnapshotsDocumentationIT extends ESRestHighLevelClientTestCase { + + public void testMountSnapshot() throws IOException, InterruptedException { + final RestHighLevelClient client = highLevelClient(); + { + final CreateIndexRequest request = new CreateIndexRequest("index"); + final CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT); + assertTrue(response.isAcknowledged()); + } + + { + final IndexRequest request = new IndexRequest("index") + .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE) + .source("{}", XContentType.JSON); + final IndexResponse response = client.index(request, RequestOptions.DEFAULT); + assertThat(response.status(), is(RestStatus.CREATED)); + } + + { + final PutRepositoryRequest request = new PutRepositoryRequest("repository"); + request.settings("{\"location\": \".\"}", XContentType.JSON); + request.type(FsRepository.TYPE); + final AcknowledgedResponse response = client.snapshot().createRepository(request, RequestOptions.DEFAULT); + assertTrue(response.isAcknowledged()); + } + + { + final CreateSnapshotRequest request = + new CreateSnapshotRequest("repository", "snapshot").waitForCompletion(true); + final CreateSnapshotResponse response = client.snapshot().create(request, RequestOptions.DEFAULT); + assertThat(response.getSnapshotInfo().status(), is(RestStatus.OK)); + } + + // tag::searchable-snapshots-mount-snapshot-request + final MountSnapshotRequest request = new MountSnapshotRequest( + "repository", // <1> + "snapshot", // <2> + "index" // <3> + ); + request.masterTimeout(TimeValue.timeValueSeconds(30)); // <4> + request.waitForCompletion(true); // <5> + request.storage(MountSnapshotRequest.Storage.FULL_COPY); // <6> + request.renamedIndex("renamed_index"); // <7> + final Settings indexSettings = Settings.builder() + .put("index.number_of_replicas", 0) + .build(); + request.indexSettings(indexSettings); // <8> + request.ignoredIndexSettings( + new String[]{"index.refresh_interval"}); // <9> + // end::searchable-snapshots-mount-snapshot-request + + // tag::searchable-snapshots-mount-snapshot-execute + final RestoreSnapshotResponse response = client + .searchableSnapshots() + .mountSnapshot(request, RequestOptions.DEFAULT); + // end::searchable-snapshots-mount-snapshot-execute + + // tag::searchable-snapshots-mount-snapshot-response + final RestoreInfo restoreInfo = response.getRestoreInfo(); // <1> + // end::searchable-snapshots-mount-snapshot-response + + // tag::searchable-snapshots-mount-snapshot-execute-listener + ActionListener listener = + new ActionListener() { + + @Override + public void onResponse( + final RestoreSnapshotResponse response) { // <1> + final RestoreInfo restoreInfo = response.getRestoreInfo(); + } + + @Override + public void onFailure(final Exception e) { + // <2> + } + + }; + // end::searchable-snapshots-mount-snapshot-execute-listener + + final CountDownLatch latch = new CountDownLatch(1); + listener = new LatchedActionListener<>(listener, latch); + + // tag::searchable-snapshots-mount-snapshot-execute-async + client.searchableSnapshots().mountSnapshotAsync( + request, + RequestOptions.DEFAULT, + listener // <1> + ); + // end::searchable-snapshots-mount-snapshot-execute-async + + assertTrue(latch.await(30L, TimeUnit.SECONDS)); + } + +} diff --git a/docs/java-rest/high-level/searchable_snapshots/mount_snapshot.asciidoc b/docs/java-rest/high-level/searchable_snapshots/mount_snapshot.asciidoc new file mode 100644 index 000000000000..888c50d59686 --- /dev/null +++ b/docs/java-rest/high-level/searchable_snapshots/mount_snapshot.asciidoc @@ -0,0 +1,40 @@ +-- +:api: searchable-snapshots-mount-snapshot +:request: MountSnapshotRequest +:response: MountSnapshotResponse +-- +[role="xpack"] +[id="{upid}-{api}"] +=== Mount Snapshot API + +[id="{upid}-{api}-request"] +==== Request + +The Mount Snapshot API mounts a snapshot as a searchable snapshot. + +["source","java",subs="attributes,callouts,macros"] +-------------------------------------------------- +include-tagged::{doc-tests-file}[{api}-request] +-------------------------------------------------- +<1> The name of the repository. +<2> The name of the snapshot. +<3> The name of the index in the snapshot to mount. +<4> (optional) The period to wait for a connection to the master node. +<5> (optional) If true, the request blocks until the operation is complete. +<6> (optional) The type of local storage to use for the mounted snapshot. +<7> (optional) The name of the index that will be created. +<8> (optional) Settings that should be added to the mounted index. +<9> (optional) Names of settings that should be unset when the index is mounted. + +[id="{upid}-{api}-response"] +==== Response + +The returned +{response}+ indicates if the mounted snapshot was restored. + +["source","java",subs="attributes,callouts,macros"] +-------------------------------------------------- +include-tagged::{doc-tests-file}[{api}-response] +-------------------------------------------------- +<1> The restore info of the mounted snapshot. + +include::../execution.asciidoc[]