Examples with RepositoryShardId org.opensearch.repositories.RepositoryShardId used on opensource projects

Example 1 with RepositoryShardId

use of org.opensearch.repositories.RepositoryShardId in project OpenSearch by opensearch-project.

the class SnapshotsService method startCloning.

/**
 * Determine the number of shards in each index of a clone operation and update the cluster state accordingly.
 *
 * @param repository     repository to run operation on
 * @param cloneEntry     clone operation in the cluster state
 */
private void startCloning(Repository repository, SnapshotsInProgress.Entry cloneEntry) {
    final List<IndexId> indices = cloneEntry.indices();
    final SnapshotId sourceSnapshot = cloneEntry.source();
    final Snapshot targetSnapshot = cloneEntry.snapshot();
    final Executor executor = threadPool.executor(ThreadPool.Names.SNAPSHOT);
    // Exception handler for IO exceptions with loading index and repo metadata
    final Consumer<Exception> onFailure = e -> {
        initializingClones.remove(targetSnapshot);
        logger.info(() -> new ParameterizedMessage("Failed to start snapshot clone [{}]", cloneEntry), e);
        removeFailedSnapshotFromClusterState(targetSnapshot, e, null, null);
    };
    // 1. step, load SnapshotInfo to make sure that source snapshot was successful for the indices we want to clone
    // TODO: we could skip this step for snapshots with state SUCCESS
    final StepListener<SnapshotInfo> snapshotInfoListener = new StepListener<>();
    executor.execute(ActionRunnable.supply(snapshotInfoListener, () -> repository.getSnapshotInfo(sourceSnapshot)));
    final StepListener<Collection<Tuple<IndexId, Integer>>> allShardCountsListener = new StepListener<>();
    final GroupedActionListener<Tuple<IndexId, Integer>> shardCountListener = new GroupedActionListener<>(allShardCountsListener, indices.size());
    snapshotInfoListener.whenComplete(snapshotInfo -> {
        for (IndexId indexId : indices) {
            if (RestoreService.failed(snapshotInfo, indexId.getName())) {
                throw new SnapshotException(targetSnapshot, "Can't clone index [" + indexId + "] because its snapshot was not successful.");
            }
        }
        // 2. step, load the number of shards we have in each index to be cloned from the index metadata.
        repository.getRepositoryData(ActionListener.wrap(repositoryData -> {
            for (IndexId index : indices) {
                executor.execute(ActionRunnable.supply(shardCountListener, () -> {
                    final IndexMetadata metadata = repository.getSnapshotIndexMetaData(repositoryData, sourceSnapshot, index);
                    return Tuple.tuple(index, metadata.getNumberOfShards());
                }));
            }
        }, onFailure));
    }, onFailure);
    // 3. step, we have all the shard counts, now update the cluster state to have clone jobs in the snap entry
    allShardCountsListener.whenComplete(counts -> repository.executeConsistentStateUpdate(repoData -> new ClusterStateUpdateTask() {

        private SnapshotsInProgress.Entry updatedEntry;

        @Override
        public ClusterState execute(ClusterState currentState) {
            final SnapshotsInProgress snapshotsInProgress = currentState.custom(SnapshotsInProgress.TYPE, SnapshotsInProgress.EMPTY);
            final List<SnapshotsInProgress.Entry> updatedEntries = new ArrayList<>(snapshotsInProgress.entries());
            boolean changed = false;
            final String localNodeId = currentState.nodes().getLocalNodeId();
            final String repoName = cloneEntry.repository();
            final ShardGenerations shardGenerations = repoData.shardGenerations();
            for (int i = 0; i < updatedEntries.size(); i++) {
                if (cloneEntry.snapshot().equals(updatedEntries.get(i).snapshot())) {
                    final ImmutableOpenMap.Builder<RepositoryShardId, ShardSnapshotStatus> clonesBuilder = ImmutableOpenMap.builder();
                    final InFlightShardSnapshotStates inFlightShardStates = InFlightShardSnapshotStates.forRepo(repoName, snapshotsInProgress.entries());
                    for (Tuple<IndexId, Integer> count : counts) {
                        for (int shardId = 0; shardId < count.v2(); shardId++) {
                            final RepositoryShardId repoShardId = new RepositoryShardId(count.v1(), shardId);
                            final String indexName = repoShardId.indexName();
                            if (inFlightShardStates.isActive(indexName, shardId)) {
                                clonesBuilder.put(repoShardId, ShardSnapshotStatus.UNASSIGNED_QUEUED);
                            } else {
                                clonesBuilder.put(repoShardId, new ShardSnapshotStatus(localNodeId, inFlightShardStates.generationForShard(repoShardId.index(), shardId, shardGenerations)));
                            }
                        }
                    }
                    updatedEntry = cloneEntry.withClones(clonesBuilder.build());
                    updatedEntries.set(i, updatedEntry);
                    changed = true;
                    break;
                }
            }
            return updateWithSnapshots(currentState, changed ? SnapshotsInProgress.of(updatedEntries) : null, null);
        }

        @Override
        public void onFailure(String source, Exception e) {
            initializingClones.remove(targetSnapshot);
            logger.info(() -> new ParameterizedMessage("Failed to start snapshot clone [{}]", cloneEntry), e);
            failAllListenersOnMasterFailOver(e);
        }

        @Override
        public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
            initializingClones.remove(targetSnapshot);
            if (updatedEntry != null) {
                final Snapshot target = updatedEntry.snapshot();
                final SnapshotId sourceSnapshot = updatedEntry.source();
                for (ObjectObjectCursor<RepositoryShardId, ShardSnapshotStatus> indexClone : updatedEntry.clones()) {
                    final ShardSnapshotStatus shardStatusBefore = indexClone.value;
                    if (shardStatusBefore.state() != ShardState.INIT) {
                        continue;
                    }
                    final RepositoryShardId repoShardId = indexClone.key;
                    runReadyClone(target, sourceSnapshot, shardStatusBefore, repoShardId, repository);
                }
            } else {
                // Extremely unlikely corner case of master failing over between between starting the clone and
                // starting shard clones.
                logger.warn("Did not find expected entry [{}] in the cluster state", cloneEntry);
            }
        }
    }, "start snapshot clone", onFailure), onFailure);
}

Example 2 with RepositoryShardId

use of org.opensearch.repositories.RepositoryShardId in project OpenSearch by opensearch-project.

the class SnapshotsServiceTests method testCompletedCloneStartsNextClone.

public void testCompletedCloneStartsNextClone() throws Exception {
    final String repoName = "test-repo";
    final Snapshot sourceSnapshot = snapshot(repoName, "source-snapshot");
    final Snapshot targetSnapshot = snapshot(repoName, "target-snapshot");
    final String indexName1 = "index-1";
    final IndexId indexId1 = indexId(indexName1);
    final RepositoryShardId shardId1 = new RepositoryShardId(indexId1, 0);
    final String masterNodeId = uuid();
    final SnapshotsInProgress.Entry cloneSingleShard = cloneEntry(targetSnapshot, sourceSnapshot.getSnapshotId(), clonesMap(shardId1, initShardStatus(masterNodeId)));
    final Snapshot queuedTargetSnapshot = snapshot(repoName, "test-snapshot");
    final SnapshotsInProgress.Entry queuedClone = cloneEntry(queuedTargetSnapshot, sourceSnapshot.getSnapshotId(), clonesMap(shardId1, SnapshotsInProgress.ShardSnapshotStatus.UNASSIGNED_QUEUED));
    assertThat(cloneSingleShard.state(), is(SnapshotsInProgress.State.STARTED));
    final ClusterState stateWithUnassignedRoutingShard = stateWithSnapshots(ClusterState.builder(ClusterState.EMPTY_STATE).nodes(discoveryNodes(masterNodeId)).build(), cloneSingleShard, queuedClone);
    final SnapshotsService.ShardSnapshotUpdate completeShardClone = successUpdate(targetSnapshot, shardId1, masterNodeId);
    final ClusterState updatedClusterState = applyUpdates(stateWithUnassignedRoutingShard, completeShardClone);
    final SnapshotsInProgress snapshotsInProgress = updatedClusterState.custom(SnapshotsInProgress.TYPE);
    final SnapshotsInProgress.Entry completedClone = snapshotsInProgress.entries().get(0);
    assertThat(completedClone.state(), is(SnapshotsInProgress.State.SUCCESS));
    final SnapshotsInProgress.Entry startedSnapshot = snapshotsInProgress.entries().get(1);
    assertThat(startedSnapshot.state(), is(SnapshotsInProgress.State.STARTED));
    assertThat(startedSnapshot.clones().get(shardId1).state(), is(SnapshotsInProgress.ShardState.INIT));
    assertIsNoop(updatedClusterState, completeShardClone);
}

Example 3 with RepositoryShardId

use of org.opensearch.repositories.RepositoryShardId in project OpenSearch by opensearch-project.

the class SnapshotsServiceTests method testUpdateCloneToSuccess.

public void testUpdateCloneToSuccess() throws Exception {
    final String repoName = "test-repo";
    final Snapshot sourceSnapshot = snapshot(repoName, "source-snapshot");
    final Snapshot targetSnapshot = snapshot(repoName, "target-snapshot");
    final String indexName1 = "index-1";
    final String dataNodeId = uuid();
    final IndexId indexId1 = indexId(indexName1);
    final RepositoryShardId shardId1 = new RepositoryShardId(indexId1, 0);
    final SnapshotsInProgress.Entry cloneSingleShard = cloneEntry(targetSnapshot, sourceSnapshot.getSnapshotId(), clonesMap(shardId1, initShardStatus(dataNodeId)));
    assertThat(cloneSingleShard.state(), is(SnapshotsInProgress.State.STARTED));
    final SnapshotsService.ShardSnapshotUpdate completeShard = successUpdate(targetSnapshot, shardId1, dataNodeId);
    final ClusterState updatedClusterState = applyUpdates(stateWithSnapshots(cloneSingleShard), completeShard);
    final SnapshotsInProgress snapshotsInProgress = updatedClusterState.custom(SnapshotsInProgress.TYPE);
    final SnapshotsInProgress.Entry updatedSnapshot1 = snapshotsInProgress.entries().get(0);
    assertThat(updatedSnapshot1.state(), is(SnapshotsInProgress.State.SUCCESS));
    assertIsNoop(updatedClusterState, completeShard);
}

Example 4 with RepositoryShardId

use of org.opensearch.repositories.RepositoryShardId in project OpenSearch by opensearch-project.

the class CloneSnapshotIT method testShardClone.

public void testShardClone() throws Exception {
    internalCluster().startMasterOnlyNode();
    internalCluster().startDataOnlyNode();
    final String repoName = "repo-name";
    final Path repoPath = randomRepoPath();
    createRepository(repoName, "fs", repoPath);
    final boolean useBwCFormat = randomBoolean();
    if (useBwCFormat) {
        initWithSnapshotVersion(repoName, repoPath, SnapshotsService.OLD_SNAPSHOT_FORMAT);
        // Re-create repo to clear repository data cache
        assertAcked(clusterAdmin().prepareDeleteRepository(repoName).get());
        createRepository(repoName, "fs", repoPath);
    }
    final String indexName = "test-index";
    createIndexWithRandomDocs(indexName, randomIntBetween(5, 10));
    final String sourceSnapshot = "source-snapshot";
    final SnapshotInfo sourceSnapshotInfo = createFullSnapshot(repoName, sourceSnapshot);
    final BlobStoreRepository repository = (BlobStoreRepository) internalCluster().getCurrentMasterNodeInstance(RepositoriesService.class).repository(repoName);
    final RepositoryData repositoryData = getRepositoryData(repoName);
    final IndexId indexId = repositoryData.resolveIndexId(indexName);
    final int shardId = 0;
    final RepositoryShardId repositoryShardId = new RepositoryShardId(indexId, shardId);
    final SnapshotId targetSnapshotId = new SnapshotId("target-snapshot", UUIDs.randomBase64UUID(random()));
    final String currentShardGen;
    if (useBwCFormat) {
        currentShardGen = null;
    } else {
        currentShardGen = repositoryData.shardGenerations().getShardGen(indexId, shardId);
    }
    final String newShardGeneration = PlainActionFuture.get(f -> repository.cloneShardSnapshot(sourceSnapshotInfo.snapshotId(), targetSnapshotId, repositoryShardId, currentShardGen, f));
    if (useBwCFormat) {
        final long gen = Long.parseLong(newShardGeneration);
        // Initial snapshot brought it to 0, clone increments it to 1
        assertEquals(gen, 1L);
    }
    final BlobStoreIndexShardSnapshot targetShardSnapshot = readShardSnapshot(repository, repositoryShardId, targetSnapshotId);
    final BlobStoreIndexShardSnapshot sourceShardSnapshot = readShardSnapshot(repository, repositoryShardId, sourceSnapshotInfo.snapshotId());
    assertThat(targetShardSnapshot.incrementalFileCount(), is(0));
    final List<BlobStoreIndexShardSnapshot.FileInfo> sourceFiles = sourceShardSnapshot.indexFiles();
    final List<BlobStoreIndexShardSnapshot.FileInfo> targetFiles = targetShardSnapshot.indexFiles();
    final int fileCount = sourceFiles.size();
    assertEquals(fileCount, targetFiles.size());
    for (int i = 0; i < fileCount; i++) {
        assertTrue(sourceFiles.get(i).isSame(targetFiles.get(i)));
    }
    final BlobStoreIndexShardSnapshots shardMetadata = readShardGeneration(repository, repositoryShardId, newShardGeneration);
    final List<SnapshotFiles> snapshotFiles = shardMetadata.snapshots();
    assertThat(snapshotFiles, hasSize(2));
    assertTrue(snapshotFiles.get(0).isSame(snapshotFiles.get(1)));
    // verify that repeated cloning is idempotent
    final String newShardGeneration2 = PlainActionFuture.get(f -> repository.cloneShardSnapshot(sourceSnapshotInfo.snapshotId(), targetSnapshotId, repositoryShardId, newShardGeneration, f));
    assertEquals(newShardGeneration, newShardGeneration2);
}

Example 5 with RepositoryShardId

use of org.opensearch.repositories.RepositoryShardId in project OpenSearch by opensearch-project.

the class InFlightShardSnapshotStates method forRepo.

/**
 * Compute information about all shard ids that currently have in-flight state for the given repository.
 *
 * @param repoName  repository name
 * @param snapshots snapshots in progress
 * @return in flight shard states for all snapshot operation running for the given repository name
 */
public static InFlightShardSnapshotStates forRepo(String repoName, List<SnapshotsInProgress.Entry> snapshots) {
    final Map<String, Map<Integer, String>> generations = new HashMap<>();
    final Map<String, Set<Integer>> busyIds = new HashMap<>();
    for (SnapshotsInProgress.Entry runningSnapshot : snapshots) {
        if (runningSnapshot.repository().equals(repoName) == false) {
            continue;
        }
        if (runningSnapshot.isClone()) {
            for (ObjectObjectCursor<RepositoryShardId, SnapshotsInProgress.ShardSnapshotStatus> clone : runningSnapshot.clones()) {
                final RepositoryShardId repoShardId = clone.key;
                addStateInformation(generations, busyIds, clone.value, repoShardId.shardId(), repoShardId.indexName());
            }
        } else {
            for (ObjectObjectCursor<ShardId, SnapshotsInProgress.ShardSnapshotStatus> shard : runningSnapshot.shards()) {
                final ShardId sid = shard.key;
                addStateInformation(generations, busyIds, shard.value, sid.id(), sid.getIndexName());
            }
        }
    }
    return new InFlightShardSnapshotStates(generations, busyIds);
}