Examples with DeleteSnapshotRequest org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest used on opensource projects

Example 6 with DeleteSnapshotRequest

use of org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest in project OpenSearch by opensearch-project.

the class AbstractThirdPartyRepositoryTestCase method testCleanup.

public void testCleanup() throws Exception {
    createIndex("test-idx-1");
    createIndex("test-idx-2");
    createIndex("test-idx-3");
    ensureGreen();
    logger.info("--> indexing some data");
    for (int i = 0; i < 100; i++) {
        client().prepareIndex("test-idx-1").setId(Integer.toString(i)).setSource("foo", "bar" + i).get();
        client().prepareIndex("test-idx-2").setId(Integer.toString(i)).setSource("foo", "bar" + i).get();
        client().prepareIndex("test-idx-3").setId(Integer.toString(i)).setSource("foo", "bar" + i).get();
    }
    client().admin().indices().prepareRefresh().get();
    final String snapshotName = "test-snap-" + System.currentTimeMillis();
    logger.info("--> snapshot");
    CreateSnapshotResponse createSnapshotResponse = client().admin().cluster().prepareCreateSnapshot("test-repo", snapshotName).setWaitForCompletion(true).setIndices("test-idx-*", "-test-idx-3").get();
    assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), greaterThan(0));
    assertThat(createSnapshotResponse.getSnapshotInfo().successfulShards(), equalTo(createSnapshotResponse.getSnapshotInfo().totalShards()));
    assertThat(client().admin().cluster().prepareGetSnapshots("test-repo").setSnapshots(snapshotName).get().getSnapshots().get(0).state(), equalTo(SnapshotState.SUCCESS));
    final BlobStoreRepository repo = (BlobStoreRepository) getInstanceFromNode(RepositoriesService.class).repository("test-repo");
    final Executor genericExec = repo.threadPool().executor(ThreadPool.Names.GENERIC);
    logger.info("--> creating a dangling index folder");
    createDanglingIndex(repo, genericExec);
    logger.info("--> deleting a snapshot to trigger repository cleanup");
    client().admin().cluster().deleteSnapshot(new DeleteSnapshotRequest("test-repo", snapshotName)).actionGet();
    assertConsistentRepository(repo, genericExec);
    logger.info("--> Create dangling index");
    createDanglingIndex(repo, genericExec);
    logger.info("--> Execute repository cleanup");
    final CleanupRepositoryResponse response = client().admin().cluster().prepareCleanupRepository("test-repo").get();
    assertCleanupResponse(response, 3L, 1L);
}

Example 7 with DeleteSnapshotRequest

use of org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest in project OpenSearch by opensearch-project.

the class SnapshotResiliencyTests method testSnapshotPrimaryRelocations.

/**
 * Simulates concurrent restarts of data and cluster-manager nodes as well as relocating a primary shard, while starting and subsequently
 * deleting a snapshot.
 */
public void testSnapshotPrimaryRelocations() {
    final int clusterManagerNodeCount = randomFrom(1, 3, 5);
    setupTestCluster(clusterManagerNodeCount, randomIntBetween(2, 5));
    String repoName = "repo";
    String snapshotName = "snapshot";
    final String index = "test";
    final int shards = randomIntBetween(1, 5);
    final TestClusterNodes.TestClusterNode clusterManagerNode = testClusterNodes.currentClusterManager(testClusterNodes.nodes.values().iterator().next().clusterService.state());
    final AtomicBoolean createdSnapshot = new AtomicBoolean();
    final AdminClient clusterManagerAdminClient = clusterManagerNode.client.admin();
    final StepListener<ClusterStateResponse> clusterStateResponseStepListener = new StepListener<>();
    continueOrDie(createRepoAndIndex(repoName, index, shards), createIndexResponse -> client().admin().cluster().state(new ClusterStateRequest(), clusterStateResponseStepListener));
    continueOrDie(clusterStateResponseStepListener, clusterStateResponse -> {
        final ShardRouting shardToRelocate = clusterStateResponse.getState().routingTable().allShards(index).get(0);
        final TestClusterNodes.TestClusterNode currentPrimaryNode = testClusterNodes.nodeById(shardToRelocate.currentNodeId());
        final TestClusterNodes.TestClusterNode otherNode = testClusterNodes.randomDataNodeSafe(currentPrimaryNode.node.getName());
        scheduleNow(() -> testClusterNodes.stopNode(currentPrimaryNode));
        scheduleNow(new Runnable() {

            @Override
            public void run() {
                final StepListener<ClusterStateResponse> updatedClusterStateResponseStepListener = new StepListener<>();
                clusterManagerAdminClient.cluster().state(new ClusterStateRequest(), updatedClusterStateResponseStepListener);
                continueOrDie(updatedClusterStateResponseStepListener, updatedClusterState -> {
                    final ShardRouting shardRouting = updatedClusterState.getState().routingTable().shardRoutingTable(shardToRelocate.shardId()).primaryShard();
                    if (shardRouting.unassigned() && shardRouting.unassignedInfo().getReason() == UnassignedInfo.Reason.NODE_LEFT) {
                        if (clusterManagerNodeCount > 1) {
                            scheduleNow(() -> testClusterNodes.stopNode(clusterManagerNode));
                        }
                        testClusterNodes.randomDataNodeSafe().client.admin().cluster().prepareCreateSnapshot(repoName, snapshotName).execute(ActionListener.wrap(() -> {
                            createdSnapshot.set(true);
                            testClusterNodes.randomDataNodeSafe().client.admin().cluster().deleteSnapshot(new DeleteSnapshotRequest(repoName, snapshotName), noopListener());
                        }));
                        scheduleNow(() -> testClusterNodes.randomClusterManagerNodeSafe().client.admin().cluster().reroute(new ClusterRerouteRequest().add(new AllocateEmptyPrimaryAllocationCommand(index, shardRouting.shardId().id(), otherNode.node.getName(), true)), noopListener()));
                    } else {
                        scheduleSoon(this);
                    }
                });
            }
        });
    });
    runUntil(() -> testClusterNodes.randomClusterManagerNode().map(clusterManager -> {
        if (createdSnapshot.get() == false) {
            return false;
        }
        return clusterManager.clusterService.state().custom(SnapshotsInProgress.TYPE, SnapshotsInProgress.EMPTY).entries().isEmpty();
    }).orElse(false), TimeUnit.MINUTES.toMillis(1L));
    clearDisruptionsAndAwaitSync();
    assertTrue(createdSnapshot.get());
    assertThat(testClusterNodes.randomDataNodeSafe().clusterService.state().custom(SnapshotsInProgress.TYPE, SnapshotsInProgress.EMPTY).entries(), empty());
    final Repository repository = testClusterNodes.randomClusterManagerNodeSafe().repositoriesService.repository(repoName);
    Collection<SnapshotId> snapshotIds = getRepositoryData(repository).getSnapshotIds();
    assertThat(snapshotIds, either(hasSize(1)).or(hasSize(0)));
}

Example 8 with DeleteSnapshotRequest

use of org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest in project OpenSearch by opensearch-project.

the class SnapshotResiliencyTests method testBulkSnapshotDeleteWithAbort.

public void testBulkSnapshotDeleteWithAbort() {
    setupTestCluster(randomFrom(1, 3, 5), randomIntBetween(2, 10));
    String repoName = "repo";
    String snapshotName = "snapshot";
    final String index = "test";
    final int shards = randomIntBetween(1, 10);
    TestClusterNodes.TestClusterNode clusterManagerNode = testClusterNodes.currentClusterManager(testClusterNodes.nodes.values().iterator().next().clusterService.state());
    final StepListener<CreateSnapshotResponse> createSnapshotResponseStepListener = new StepListener<>();
    continueOrDie(createRepoAndIndex(repoName, index, shards), createIndexResponse -> client().admin().cluster().prepareCreateSnapshot(repoName, snapshotName).setWaitForCompletion(true).execute(createSnapshotResponseStepListener));
    final int inProgressSnapshots = randomIntBetween(1, 5);
    final StepListener<Collection<CreateSnapshotResponse>> createOtherSnapshotResponseStepListener = new StepListener<>();
    final ActionListener<CreateSnapshotResponse> createSnapshotListener = new GroupedActionListener<>(createOtherSnapshotResponseStepListener, inProgressSnapshots);
    continueOrDie(createSnapshotResponseStepListener, createSnapshotResponse -> {
        for (int i = 0; i < inProgressSnapshots; i++) {
            client().admin().cluster().prepareCreateSnapshot(repoName, "other-" + i).execute(createSnapshotListener);
        }
    });
    final StepListener<AcknowledgedResponse> deleteSnapshotStepListener = new StepListener<>();
    continueOrDie(createOtherSnapshotResponseStepListener, createSnapshotResponse -> client().admin().cluster().deleteSnapshot(new DeleteSnapshotRequest(repoName, "*"), deleteSnapshotStepListener));
    deterministicTaskQueue.runAllRunnableTasks();
    SnapshotsInProgress finalSnapshotsInProgress = clusterManagerNode.clusterService.state().custom(SnapshotsInProgress.TYPE);
    assertFalse(finalSnapshotsInProgress.entries().stream().anyMatch(entry -> entry.state().completed() == false));
    final Repository repository = clusterManagerNode.repositoriesService.repository(repoName);
    Collection<SnapshotId> snapshotIds = getRepositoryData(repository).getSnapshotIds();
    // No snapshots should be left in the repository
    assertThat(snapshotIds, empty());
}

Example 9 with DeleteSnapshotRequest

use of org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest in project OpenSearch by opensearch-project.

the class SnapshotClientDocumentationIT method testSnapshotDeleteSnapshot.

public void testSnapshotDeleteSnapshot() throws IOException {
    RestHighLevelClient client = highLevelClient();
    createTestRepositories();
    createTestIndex();
    createTestSnapshots();
    // tag::delete-snapshot-request
    DeleteSnapshotRequest request = new DeleteSnapshotRequest(repositoryName);
    request.snapshots(snapshotName);
    // end::delete-snapshot-request
    // tag::delete-snapshot-request-masterTimeout
    // <1>
    request.masterNodeTimeout(TimeValue.timeValueMinutes(1));
    // <2>
    request.masterNodeTimeout("1m");
    // end::delete-snapshot-request-masterTimeout
    // tag::delete-snapshot-execute
    AcknowledgedResponse response = client.snapshot().delete(request, RequestOptions.DEFAULT);
    // end::delete-snapshot-execute
    // tag::delete-snapshot-response
    // <1>
    boolean acknowledged = response.isAcknowledged();
    // end::delete-snapshot-response
    assertTrue(acknowledged);
}

Example 10 with DeleteSnapshotRequest

use of org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest in project OpenSearch by opensearch-project.

the class SnapshotIT method testDeleteSnapshot.

public void testDeleteSnapshot() throws IOException {
    String repository = "test_repository";
    String snapshot = "test_snapshot";
    AcknowledgedResponse putRepositoryResponse = createTestRepository(repository, FsRepository.TYPE, "{\"location\": \".\"}");
    assertTrue(putRepositoryResponse.isAcknowledged());
    CreateSnapshotRequest createSnapshotRequest = new CreateSnapshotRequest(repository, snapshot);
    createSnapshotRequest.waitForCompletion(true);
    if (randomBoolean()) {
        createSnapshotRequest.userMetadata(randomUserMetadata());
    }
    CreateSnapshotResponse createSnapshotResponse = createTestSnapshot(createSnapshotRequest);
    // check that the request went ok without parsing JSON here. When using the high level client, check acknowledgement instead.
    assertEquals(RestStatus.OK, createSnapshotResponse.status());
    DeleteSnapshotRequest request = new DeleteSnapshotRequest(repository, snapshot);
    AcknowledgedResponse response = execute(request, highLevelClient().snapshot()::delete, highLevelClient().snapshot()::deleteAsync);
    assertTrue(response.isAcknowledged());
}