import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Deletes a snapshot from the repository, looking up the {@link Snapshot} reference before deleting.
 * If the snapshot is still running cancels the snapshot first and then deletes it from the repository.
 *
 * @param repositoryName  repositoryName
 * @param snapshotName    snapshotName
 * @param listener        listener
 */
public void deleteSnapshot(final String repositoryName, final String snapshotName, final DeleteSnapshotListener listener,
                           final boolean immediatePriority) {
    // First, look for the snapshot in the repository
    final Repository repository = repositoriesService.repository(repositoryName);
    final RepositoryData repositoryData = repository.getRepositoryData();
    final Optional<SnapshotId> incompatibleSnapshotId =
        repositoryData.getIncompatibleSnapshotIds().stream().filter(s -> snapshotName.equals(s.getName())).findFirst();
    if (incompatibleSnapshotId.isPresent()) {
        throw new SnapshotException(repositoryName, snapshotName, "cannot delete incompatible snapshot");
    }
    Optional<SnapshotId> matchedEntry = repositoryData.getSnapshotIds()
                                            .stream()
                                            .filter(s -> s.getName().equals(snapshotName))
                                            .findFirst();
    // if nothing found by the same name, then look in the cluster state for current in progress snapshots
    if (matchedEntry.isPresent() == false) {
        matchedEntry = currentSnapshots(repositoryName, Collections.emptyList()).stream()
                           .map(e -> e.snapshot().getSnapshotId()).filter(s -> s.getName().equals(snapshotName)).findFirst();
    }
    if (matchedEntry.isPresent() == false) {
        throw new SnapshotMissingException(repositoryName, snapshotName);
    }
    deleteSnapshot(new Snapshot(repositoryName, matchedEntry.get()), listener, repositoryData.getGenId(), immediatePriority);
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Returns a list of snapshots from repository sorted by snapshot creation date
 *
 * @param repositoryName repository name
 * @return list of snapshots
 */
public List<Snapshot> snapshots(String repositoryName, boolean ignoreUnavailable) {
    Set<Snapshot> snapshotSet = newHashSet();
    List<SnapshotsInProgress.Entry> entries = currentSnapshots(repositoryName, null);
    for (SnapshotsInProgress.Entry entry : entries) {
        snapshotSet.add(inProgressSnapshot(entry));
    }
    Repository repository = repositoriesService.repository(repositoryName);
    List<SnapshotId> snapshotIds = repository.snapshots();
    for (SnapshotId snapshotId : snapshotIds) {
        try {
            snapshotSet.add(repository.readSnapshot(snapshotId));
        } catch (Exception ex) {
            if (ignoreUnavailable) {
                logger.warn("failed to get snapshot [{}]", ex, snapshotId);
            } else {
                throw new SnapshotException(snapshotId, "Snapshot could not be read", ex);
            }
        }
    }

    ArrayList<Snapshot> snapshotList = new ArrayList<>(snapshotSet);
    CollectionUtil.timSort(snapshotList);
    return Collections.unmodifiableList(snapshotList);
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void onModule(RepositoriesModule repositoriesModule) {
    if (System.getSecurityManager() != null) {
        Loggers.getLogger(HdfsPlugin.class).warn("The Java Security Manager is enabled however Hadoop is not compatible with it and thus needs to be disabled; see the docs for more information...");
    }

    String baseLib = detectLibFolder();
    List<URL> cp = getHadoopClassLoaderPath(baseLib);

    ClassLoader hadoopCL = URLClassLoader.newInstance(cp.toArray(new URL[cp.size()]), getClass().getClassLoader());

    Class<? extends Repository> repository = null;
    try {
        repository = (Class<? extends Repository>) hadoopCL.loadClass("org.elasticsearch.repositories.hdfs.HdfsRepository");
    } catch (ClassNotFoundException cnfe) {
        throw new IllegalStateException("Cannot load plugin class; is the plugin class setup correctly?", cnfe);
    }

    repositoriesModule.registerRepository("hdfs", repository, BlobStoreIndexShardRepository.class);
    Loggers.getLogger(HdfsPlugin.class).info("Loaded Hadoop [{}] libraries from {}", getHadoopVersion(hadoopCL), baseLib);
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Recovers an index from a given {@link Repository}. This method restores a
 * previously created index snapshot into an existing initializing shard.
 * @param indexShard the index shard instance to recovery the snapshot from
 * @param repository the repository holding the physical files the shard should be recovered from
 * @return <code>true</code> if the shard has been recovered successfully, <code>false</code> if the recovery
 * has been ignored due to a concurrent modification of if the clusters state has changed due to async updates.
 */
boolean recoverFromRepository(final IndexShard indexShard, Repository repository) {
    if (canRecover(indexShard)) {
        RecoverySource.Type recoveryType = indexShard.recoveryState().getRecoverySource().getType();
        assert recoveryType == RecoverySource.Type.SNAPSHOT : "expected snapshot recovery type: " + recoveryType;
        SnapshotRecoverySource recoverySource = (SnapshotRecoverySource) indexShard.recoveryState().getRecoverySource();
        return executeRecovery(indexShard, () -> {
            logger.debug("restoring from {} ...", indexShard.recoveryState().getRecoverySource());
            restore(indexShard, repository, recoverySource);
        });
    }
    return false;

}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Restores shard from {@link SnapshotRecoverySource} associated with this shard in routing table
 */
private void restore(final IndexShard indexShard, final Repository repository, final SnapshotRecoverySource restoreSource) {
    final RecoveryState.Translog translogState = indexShard.recoveryState().getTranslog();
    if (restoreSource == null) {
        throw new IndexShardRestoreFailedException(shardId, "empty restore source");
    }
    if (logger.isTraceEnabled()) {
        logger.trace("[{}] restoring shard [{}]", restoreSource.snapshot(), shardId);
    }
    try {
        translogState.totalOperations(0);
        translogState.totalOperationsOnStart(0);
        indexShard.prepareForIndexRecovery();
        ShardId snapshotShardId = shardId;
        final String indexName = restoreSource.index();
        if (!shardId.getIndexName().equals(indexName)) {
            snapshotShardId = new ShardId(indexName, IndexMetaData.INDEX_UUID_NA_VALUE, shardId.id());
        }
        final IndexId indexId = repository.getRepositoryData().resolveIndexId(indexName);
        repository.restoreShard(indexShard, restoreSource.snapshot().getSnapshotId(), restoreSource.version(), indexId, snapshotShardId, indexShard.recoveryState());
        indexShard.skipTranslogRecovery(IndexRequest.UNSET_AUTO_GENERATED_TIMESTAMP);
        indexShard.finalizeRecovery();
        indexShard.postRecovery("restore done");
    } catch (Exception e) {
        throw new IndexShardRestoreFailedException(shardId, "restore failed", e);
    }
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Returns a list of snapshots from repository sorted by snapshot creation date
 *
 * @param repositoryName repository name
 * @param snapshotIds       snapshots for which to fetch snapshot information
 * @param ignoreUnavailable if true, snapshots that could not be read will only be logged with a warning,
 *                          if false, they will throw an error
 * @return list of snapshots
 */
public List<SnapshotInfo> snapshots(final String repositoryName, List<SnapshotId> snapshotIds, final boolean ignoreUnavailable) {
    final Set<SnapshotInfo> snapshotSet = new HashSet<>();
    final Set<SnapshotId> snapshotIdsToIterate = new HashSet<>(snapshotIds);
    // first, look at the snapshots in progress
    final List<SnapshotsInProgress.Entry> entries =
        currentSnapshots(repositoryName, snapshotIdsToIterate.stream().map(SnapshotId::getName).collect(Collectors.toList()));
    for (SnapshotsInProgress.Entry entry : entries) {
        snapshotSet.add(inProgressSnapshot(entry));
        snapshotIdsToIterate.remove(entry.snapshot().getSnapshotId());
    }
    // then, look in the repository
    final Repository repository = repositoriesService.repository(repositoryName);
    for (SnapshotId snapshotId : snapshotIdsToIterate) {
        try {
            snapshotSet.add(repository.getSnapshotInfo(snapshotId));
        } catch (Exception ex) {
            if (ignoreUnavailable) {
                logger.warn((Supplier<?>) () -> new ParameterizedMessage("failed to get snapshot [{}]", snapshotId), ex);
            } else {
                throw new SnapshotException(repositoryName, snapshotId, "Snapshot could not be read", ex);
            }
        }
    }
    final ArrayList<SnapshotInfo> snapshotList = new ArrayList<>(snapshotSet);
    CollectionUtil.timSort(snapshotList);
    return Collections.unmodifiableList(snapshotList);
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Finalizes the shard in repository and then removes it from cluster state
 * <p>
 * This is non-blocking method that runs on a thread from SNAPSHOT thread pool
 *
 * @param entry   snapshot
 * @param failure failure reason or null if snapshot was successful
 */
private void endSnapshot(final SnapshotsInProgress.Entry entry, final String failure) {
    threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(new Runnable() {
        @Override
        public void run() {
            final Snapshot snapshot = entry.snapshot();
            try {
                final Repository repository = repositoriesService.repository(snapshot.getRepository());
                logger.trace("[{}] finalizing snapshot in repository, state: [{}], failure[{}]", snapshot, entry.state(), failure);
                ArrayList<ShardSearchFailure> failures = new ArrayList<>();
                ArrayList<SnapshotShardFailure> shardFailures = new ArrayList<>();
                for (ObjectObjectCursor<ShardId, ShardSnapshotStatus> shardStatus : entry.shards()) {
                    ShardId shardId = shardStatus.key;
                    ShardSnapshotStatus status = shardStatus.value;
                    if (status.state().failed()) {
                        failures.add(new ShardSearchFailure(status.reason(), new SearchShardTarget(status.nodeId(), shardId)));
                        shardFailures.add(new SnapshotShardFailure(status.nodeId(), shardId, status.reason()));
                    }
                }
                SnapshotInfo snapshotInfo = repository.finalizeSnapshot(
                    snapshot.getSnapshotId(),
                    entry.indices(),
                    entry.startTime(),
                    failure,
                    entry.shards().size(),
                    Collections.unmodifiableList(shardFailures),
                    entry.getRepositoryStateId());
                removeSnapshotFromClusterState(snapshot, snapshotInfo, null);
            } catch (Exception e) {
                logger.warn((Supplier<?>) () -> new ParameterizedMessage("[{}] failed to finalize snapshot", snapshot), e);
                removeSnapshotFromClusterState(snapshot, null, e);
            }
        }
    });
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Deletes snapshot from repository
 *
 * @param snapshot   snapshot
 * @param listener   listener
 * @param repositoryStateId the unique id representing the state of the repository at the time the deletion began
 */
private void deleteSnapshotFromRepository(final Snapshot snapshot, @Nullable final DeleteSnapshotListener listener,
                                          long repositoryStateId) {
    threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(() -> {
        try {
            Repository repository = repositoriesService.repository(snapshot.getRepository());
            repository.deleteSnapshot(snapshot.getSnapshotId(), repositoryStateId);
            removeSnapshotDeletionFromClusterState(snapshot, null, listener);
        } catch (Exception ex) {
            removeSnapshotDeletionFromClusterState(snapshot, ex, listener);
        }
    });
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Finalizes the shard in repository and then removes it from cluster state
 * <p>
 * This is non-blocking method that runs on a thread from SNAPSHOT thread pool
 *
 * @param entry   snapshot
 * @param failure failure reason or null if snapshot was successful
 */
private void endSnapshot(final SnapshotsInProgress.Entry entry, final String failure) {
    threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(new Runnable() {
        @Override
        public void run() {
            SnapshotId snapshotId = entry.snapshotId();
            try {
                final Repository repository = repositoriesService.repository(snapshotId.getRepository());
                logger.trace("[{}] finalizing snapshot in repository, state: [{}], failure[{}]", snapshotId, entry.state(), failure);
                ArrayList<ShardSearchFailure> failures = new ArrayList<>();
                ArrayList<SnapshotShardFailure> shardFailures = new ArrayList<>();
                for (Map.Entry<ShardId, ShardSnapshotStatus> shardStatus : entry.shards().entrySet()) {
                    ShardId shardId = shardStatus.getKey();
                    ShardSnapshotStatus status = shardStatus.getValue();
                    if (status.state().failed()) {
                        failures.add(new ShardSearchFailure(status.reason(), new SearchShardTarget(status.nodeId(), shardId.getIndex(), shardId.id())));
                        shardFailures.add(new SnapshotShardFailure(status.nodeId(), shardId.getIndex(), shardId.id(), status.reason()));
                    }
                }
                Snapshot snapshot = repository.finalizeSnapshot(snapshotId, entry.indices(), entry.startTime(), failure, entry.shards().size(), Collections.unmodifiableList(shardFailures));
                removeSnapshotFromClusterState(snapshotId, new SnapshotInfo(snapshot), null);
            } catch (Throwable t) {
                logger.warn("[{}] failed to finalize snapshot", t, snapshotId);
                removeSnapshotFromClusterState(snapshotId, null, t);
            }
        }
    });
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Deletes snapshot from repository
 *
 * @param snapshotId snapshot id
 * @param listener   listener
 */
private void deleteSnapshotFromRepository(final SnapshotId snapshotId, final DeleteSnapshotListener listener) {
    threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(new Runnable() {
        @Override
        public void run() {
            try {
                Repository repository = repositoriesService.repository(snapshotId.getRepository());
                repository.deleteSnapshot(snapshotId);
                listener.onResponse();
            } catch (Throwable t) {
                listener.onFailure(t);
            }
        }
    });
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * Do the binding.
 */
@Override
protected void configure() {
    bind(Repository.class).to(SwiftRepository.class).asEagerSingleton();
    bind(IndexShardRepository.class).to(BlobStoreIndexShardRepository.class).asEagerSingleton();
    bind(SwiftService.class).asEagerSingleton();
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected void configure() {
    bind(Repository.class).to(SshRepository.class).asEagerSingleton();
    bind(IndexShardRepository.class)
            .to(BlobStoreIndexShardRepository.class).asEagerSingleton();
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public Map<String, Repository.Factory> getRepositories(Environment env, NamedXContentRegistry namedXContentRegistry) {
    return Collections.singletonMap(URLRepository.TYPE, metadata -> new URLRepository(metadata, env, namedXContentRegistry));
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
public boolean restoreFromRepository(Repository repository) {
    assert shardRouting.primary() : "recover from store only makes sense if the shard is a primary shard";
    assert recoveryState.getRecoverySource().getType() == RecoverySource.Type.SNAPSHOT : "invalid recovery type: " + recoveryState.getRecoverySource();
    StoreRecovery storeRecovery = new StoreRecovery(shardId, logger);
    return storeRecovery.recoverFromRepository(this, repository);
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public Map<String, Repository.Factory> getRepositories(Environment env, NamedXContentRegistry namedXContentRegistry) {
    return Collections.singletonMap("mock", (metadata) -> new MockRepository(metadata, env, namedXContentRegistry));
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public Map<String, Repository.Factory> getRepositories(Environment env, NamedXContentRegistry namedXContentRegistry) {
    return Collections.singletonMap(GoogleCloudStorageRepository.TYPE,
        (metadata) -> new GoogleCloudStorageRepository(metadata, env, namedXContentRegistry, createStorageService(env)));
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public Map<String, Repository.Factory> getRepositories(Environment env, NamedXContentRegistry namedXContentRegistry) {
    return Collections.singletonMap(AzureRepository.TYPE,
        (metadata) -> new AzureRepository(metadata, env, namedXContentRegistry, createStorageService(env.settings())));
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public Map<String, Repository.Factory> getRepositories(Environment env, NamedXContentRegistry namedXContentRegistry) {
    return Collections.singletonMap(S3Repository.TYPE,
        (metadata) -> new S3Repository(metadata, env.settings(), namedXContentRegistry, createStorageService(env.settings())));
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public List<String> getSettingsFilter() {
    return Arrays.asList(
        S3Repository.Repository.KEY_SETTING.getKey(),
        S3Repository.Repository.SECRET_SETTING.getKey());
}
 

import org.elasticsearch.repositories.Repository; //导入依赖的package包/类
@Override
public Map<String, Repository.Factory> getRepositories(Environment env, NamedXContentRegistry namedXContentRegistry) {
    return Collections.singletonMap("hdfs", (metadata) -> new HdfsRepository(metadata, env, namedXContentRegistry));
}