Java ClusterState.custom方法代码示例

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * Checks if a repository is currently in use by one of the snapshots
 *
 * @param clusterState cluster state
 * @param repository   repository id
 * @return true if repository is currently in use by one of the running snapshots
 */
public static boolean isRepositoryInUse(ClusterState clusterState, String repository) {
    SnapshotsInProgress snapshots = clusterState.custom(SnapshotsInProgress.TYPE);
    if (snapshots != null) {
        for (SnapshotsInProgress.Entry snapshot : snapshots.entries()) {
            if (repository.equals(snapshot.snapshot().getRepository())) {
                return true;
            }
        }
    }
    SnapshotDeletionsInProgress deletionsInProgress = clusterState.custom(SnapshotDeletionsInProgress.TYPE);
    if (deletionsInProgress != null) {
        for (SnapshotDeletionsInProgress.Entry entry : deletionsInProgress.getEntries()) {
            if (entry.getSnapshot().getRepository().equals(repository)) {
                return true;
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * Check if any of the indices to be closed are currently being restored from a snapshot and fail closing if such an index
 * is found as closing an index that is being restored makes the index unusable (it cannot be recovered).
 */
public static void checkIndexClosing(ClusterState currentState, Set<IndexMetaData> indices) {
    RestoreInProgress restore = currentState.custom(RestoreInProgress.TYPE);
    if (restore != null) {
        Set<Index> indicesToFail = null;
        for (RestoreInProgress.Entry entry : restore.entries()) {
            for (ObjectObjectCursor<ShardId, RestoreInProgress.ShardRestoreStatus> shard : entry.shards()) {
                if (!shard.value.state().completed()) {
                    IndexMetaData indexMetaData = currentState.metaData().index(shard.key.getIndex());
                    if (indexMetaData != null && indices.contains(indexMetaData)) {
                        if (indicesToFail == null) {
                            indicesToFail = new HashSet<>();
                        }
                        indicesToFail.add(shard.key.getIndex());
                    }
                }
            }
        }
        if (indicesToFail != null) {
            throw new IllegalArgumentException("Cannot close indices that are being restored: " + indicesToFail);
        }
    }
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * Checks if a repository is currently in use by one of the snapshots
 *
 * @param clusterState cluster state
 * @param repository   repository id
 * @return true if repository is currently in use by one of the running snapshots
 */
public static boolean isRepositoryInUse(ClusterState clusterState, String repository) {
    RestoreInProgress snapshots = clusterState.custom(RestoreInProgress.TYPE);
    if (snapshots != null) {
        for (RestoreInProgress.Entry snapshot : snapshots.entries()) {
            if (repository.equals(snapshot.snapshot().getRepository())) {
                return true;
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
/**
 * Checks if a repository is currently in use by one of the snapshots
 *
 * @param clusterState cluster state
 * @param repository   repository id
 * @return true if repository is currently in use by one of the running snapshots
 */
public static boolean isRepositoryInUse(ClusterState clusterState, String repository) {
    SnapshotsInProgress snapshots = clusterState.custom(SnapshotsInProgress.TYPE);
    if (snapshots != null) {
        for (SnapshotsInProgress.Entry snapshot : snapshots.entries()) {
            if (repository.equals(snapshot.snapshotId().getRepository())) {
                return true;
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.ClusterState; //导入方法依赖的package包/类
@Override
public ClusterTasksResult<UpdateIndexShardSnapshotStatusRequest> execute(ClusterState currentState, List<UpdateIndexShardSnapshotStatusRequest> tasks) throws Exception {
    final SnapshotsInProgress snapshots = currentState.custom(SnapshotsInProgress.TYPE);
    if (snapshots != null) {
        int changedCount = 0;
        final List<SnapshotsInProgress.Entry> entries = new ArrayList<>();
        for (SnapshotsInProgress.Entry entry : snapshots.entries()) {
            ImmutableOpenMap.Builder<ShardId, ShardSnapshotStatus> shards = ImmutableOpenMap.builder();
            boolean updated = false;

            for (UpdateIndexShardSnapshotStatusRequest updateSnapshotState : tasks) {
                if (entry.snapshot().equals(updateSnapshotState.snapshot())) {
                    logger.trace("[{}] Updating shard [{}] with status [{}]", updateSnapshotState.snapshot(), updateSnapshotState.shardId(), updateSnapshotState.status().state());
                    if (updated == false) {
                        shards.putAll(entry.shards());
                        updated = true;
                    }
                    shards.put(updateSnapshotState.shardId(), updateSnapshotState.status());
                    changedCount++;
                }
            }

            if (updated) {
                if (completed(shards.values()) == false) {
                    entries.add(new SnapshotsInProgress.Entry(entry, shards.build()));
                } else {
                    // Snapshot is finished - mark it as done
                    // TODO: Add PARTIAL_SUCCESS status?
                    SnapshotsInProgress.Entry updatedEntry = new SnapshotsInProgress.Entry(entry, State.SUCCESS, shards.build());
                    entries.add(updatedEntry);
                    // Finalize snapshot in the repository
                    snapshotsService.endSnapshot(updatedEntry);
                    logger.info("snapshot [{}] is done", updatedEntry.snapshot());
                }
            } else {
                entries.add(entry);
            }
        }
        if (changedCount > 0) {
            logger.trace("changed cluster state triggered by {} snapshot state updates", changedCount);

            final SnapshotsInProgress updatedSnapshots = new SnapshotsInProgress(entries.toArray(new SnapshotsInProgress.Entry[entries.size()]));
            return ClusterTasksResult.<UpdateIndexShardSnapshotStatusRequest>builder().successes(tasks).build(
                ClusterState.builder(currentState).putCustom(SnapshotsInProgress.TYPE, updatedSnapshots).build());
        }
    }
    return ClusterTasksResult.<UpdateIndexShardSnapshotStatusRequest>builder().successes(tasks).build(currentState);
}