Java SnapshotsInProgress.entries方法代码示例

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
private Decision canMove(ShardRouting shardRouting, RoutingAllocation allocation) {
    if (shardRouting.primary()) {
        // Only primary shards are snapshotted

        SnapshotsInProgress snapshotsInProgress = allocation.custom(SnapshotsInProgress.TYPE);
        if (snapshotsInProgress == null) {
            // Snapshots are not running
            return allocation.decision(Decision.YES, NAME, "no snapshots are currently running");
        }

        for (SnapshotsInProgress.Entry snapshot : snapshotsInProgress.entries()) {
            SnapshotsInProgress.ShardSnapshotStatus shardSnapshotStatus = snapshot.shards().get(shardRouting.shardId());
            if (shardSnapshotStatus != null && !shardSnapshotStatus.state().completed() && shardSnapshotStatus.nodeId() != null &&
                    shardSnapshotStatus.nodeId().equals(shardRouting.currentNodeId())) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Preventing snapshotted shard [{}] from being moved away from node [{}]",
                            shardRouting.shardId(), shardSnapshotStatus.nodeId());
                }
                return allocation.decision(Decision.THROTTLE, NAME,
                    "waiting for snapshotting of shard [%s] to complete on this node [%s]",
                    shardRouting.shardId(), shardSnapshotStatus.nodeId());
            }
        }
    }
    return allocation.decision(Decision.YES, NAME, "the shard is not being snapshotted");
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
private boolean waitingShardsStartedOrUnassigned(ClusterChangedEvent event) {
    SnapshotsInProgress curr = event.state().custom(SnapshotsInProgress.TYPE);
    if (curr != null) {
        for (SnapshotsInProgress.Entry entry : curr.entries()) {
            if (entry.state() == State.STARTED && !entry.waitingIndices().isEmpty()) {
                for (ObjectCursor<String> index : entry.waitingIndices().keys()) {
                    if (event.indexRoutingTableChanged(index.value)) {
                        IndexRoutingTable indexShardRoutingTable = event.state().getRoutingTable().index(index.value);
                        for (ShardId shardId : entry.waitingIndices().get(index.value)) {
                            ShardRouting shardRouting = indexShardRoutingTable.shard(shardId.id()).primaryShard();
                            if (shardRouting != null && (shardRouting.started() || shardRouting.unassigned())) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
private boolean removedNodesCleanupNeeded(ClusterChangedEvent event) {
    SnapshotsInProgress snapshotsInProgress = event.state().custom(SnapshotsInProgress.TYPE);
    if (snapshotsInProgress == null) {
        return false;
    }
    // Check if we just became the master
    boolean newMaster = !event.previousState().nodes().isLocalNodeElectedMaster();
    for (SnapshotsInProgress.Entry snapshot : snapshotsInProgress.entries()) {
        if (newMaster && (snapshot.state() == State.SUCCESS || snapshot.state() == State.INIT)) {
            // We just replaced old master and snapshots in intermediate states needs to be cleaned
            return true;
        }
        for (DiscoveryNode node : event.nodesDelta().removedNodes()) {
            for (ObjectCursor<ShardSnapshotStatus> shardStatus : snapshot.shards().values()) {
                if (!shardStatus.value.state().completed() && node.getId().equals(shardStatus.value.nodeId())) {
                    // At least one shard was running on the removed node - we need to fail it
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的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.SnapshotsInProgress; //导入方法依赖的package包/类
@Override
protected Custom makeTestChanges(Custom testInstance) {
    SnapshotsInProgress snapshots = (SnapshotsInProgress) testInstance;
    List<Entry> entries = new ArrayList<>(snapshots.entries());
    if (randomBoolean() && entries.size() > 1) {
        // remove some elements
        int leaveElements = randomIntBetween(0, entries.size() - 1);
        entries = randomSubsetOf(leaveElements, entries.toArray(new Entry[leaveElements]));
    }
    if (randomBoolean()) {
        // add some elements
        int addElements = randomInt(10);
        for (int i = 0; i < addElements; i++) {
            entries.add(randomSnapshot());
        }
    }
    if (randomBoolean()) {
        // modify some elements
        for (int i = 0; i < entries.size(); i++) {
            if (randomBoolean()) {
                entries.set(i, new Entry(entries.get(i), randomFrom(State.values()), entries.get(i).shards()));
            }
        }
    }
    return new SnapshotsInProgress(entries);
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
private Decision canMove(ShardRouting shardRouting, RoutingAllocation allocation) {
    if (!enableRelocation && shardRouting.primary()) {
        // Only primary shards are snapshotted

        SnapshotsInProgress snapshotsInProgress = allocation.routingNodes().custom(SnapshotsInProgress.TYPE);
        if (snapshotsInProgress == null) {
            // Snapshots are not running
            return allocation.decision(Decision.YES, NAME, "no snapshots are currently running");
        }

        for (SnapshotsInProgress.Entry snapshot : snapshotsInProgress.entries()) {
            SnapshotsInProgress.ShardSnapshotStatus shardSnapshotStatus = snapshot.shards().get(shardRouting.shardId());
            if (shardSnapshotStatus != null && !shardSnapshotStatus.state().completed() && shardSnapshotStatus.nodeId() != null && shardSnapshotStatus.nodeId().equals(shardRouting.currentNodeId())) {
                logger.trace("Preventing snapshotted shard [{}] to be moved from node [{}]", shardRouting.shardId(), shardSnapshotStatus.nodeId());
                return allocation.decision(Decision.NO, NAME, "snapshot for shard [%s] is currently running on node [%s]",
                        shardRouting.shardId(), shardSnapshotStatus.nodeId());
            }
        }
    }
    return allocation.decision(Decision.YES, NAME, "shard not primary or relocation disabled");
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
private boolean waitingShardsStartedOrUnassigned(ClusterChangedEvent event) {
    SnapshotsInProgress curr = event.state().custom(SnapshotsInProgress.TYPE);
    if (curr != null) {
        for (SnapshotsInProgress.Entry entry : curr.entries()) {
            if (entry.state() == State.STARTED && !entry.waitingIndices().isEmpty()) {
                for (String index : entry.waitingIndices().keySet()) {
                    if (event.indexRoutingTableChanged(index)) {
                        IndexRoutingTable indexShardRoutingTable = event.state().getRoutingTable().index(index);
                        for (ShardId shardId : entry.waitingIndices().get(index)) {
                            ShardRouting shardRouting = indexShardRoutingTable.shard(shardId.id()).primaryShard();
                            if (shardRouting != null && (shardRouting.started() || shardRouting.unassigned())) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
private boolean removedNodesCleanupNeeded(ClusterChangedEvent event) {
    // Check if we just became the master
    boolean newMaster = !event.previousState().nodes().localNodeMaster();
    SnapshotsInProgress snapshotsInProgress = event.state().custom(SnapshotsInProgress.TYPE);
    if (snapshotsInProgress == null) {
        return false;
    }
    for (SnapshotsInProgress.Entry snapshot : snapshotsInProgress.entries()) {
        if (newMaster && (snapshot.state() == State.SUCCESS || snapshot.state() == State.INIT)) {
            // We just replaced old master and snapshots in intermediate states needs to be cleaned
            return true;
        }
        for (DiscoveryNode node : event.nodesDelta().removedNodes()) {
            for (ShardSnapshotStatus shardStatus : snapshot.shards().values()) {
                if (!shardStatus.state().completed() && node.getId().equals(shardStatus.nodeId())) {
                    // At least one shard was running on the removed node - we need to fail it
                    return true;
                }
            }
        }
    }
    return false;
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
/**
 * Checks if any shards were processed that the new master doesn't know about
 */
private void syncShardStatsOnNewMaster(ClusterChangedEvent event) {
    SnapshotsInProgress snapshotsInProgress = event.state().custom(SnapshotsInProgress.TYPE);
    if (snapshotsInProgress == null) {
        return;
    }
    final String localNodeId = event.state().nodes().getLocalNodeId();
    final DiscoveryNode masterNode = event.state().nodes().getMasterNode();
    for (SnapshotsInProgress.Entry snapshot : snapshotsInProgress.entries()) {
        if (snapshot.state() == State.STARTED || snapshot.state() == State.ABORTED) {
            Map<ShardId, IndexShardSnapshotStatus> localShards = currentSnapshotShards(snapshot.snapshot());
            if (localShards != null) {
                ImmutableOpenMap<ShardId, ShardSnapshotStatus> masterShards = snapshot.shards();
                for(Map.Entry<ShardId, IndexShardSnapshotStatus> localShard : localShards.entrySet()) {
                    ShardId shardId = localShard.getKey();
                    IndexShardSnapshotStatus localShardStatus = localShard.getValue();
                    ShardSnapshotStatus masterShard = masterShards.get(shardId);
                    if (masterShard != null && masterShard.state().completed() == false) {
                        // Master knows about the shard and thinks it has not completed
                        if (localShardStatus.stage() == Stage.DONE) {
                            // but we think the shard is done - we need to make new master know that the shard is done
                            logger.debug("[{}] new master thinks the shard [{}] is not completed but the shard is done locally, updating status on the master", snapshot.snapshot(), shardId);
                            updateIndexShardSnapshotStatus(snapshot.snapshot(), shardId,
                                    new ShardSnapshotStatus(localNodeId, State.SUCCESS), masterNode);
                        } else if (localShard.getValue().stage() == Stage.FAILURE) {
                            // but we think the shard failed - we need to make new master know that the shard failed
                            logger.debug("[{}] new master thinks the shard [{}] is not completed but the shard failed locally, updating status on master", snapshot.snapshot(), shardId);
                            updateIndexShardSnapshotStatus(snapshot.snapshot(), shardId,
                                    new ShardSnapshotStatus(localNodeId, State.FAILED, localShardStatus.failure()), masterNode);

                        }
                    }
                }
            }
        }
    }
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的package包/类
public SnapshotInfo waitForCompletion(String repository, String snapshotName, TimeValue timeout) throws InterruptedException {
    long start = System.currentTimeMillis();
    while (System.currentTimeMillis() - start < timeout.millis()) {
        List<SnapshotInfo> snapshotInfos = client().admin().cluster().prepareGetSnapshots(repository).setSnapshots(snapshotName).get().getSnapshots();
        assertThat(snapshotInfos.size(), equalTo(1));
        if (snapshotInfos.get(0).state().completed()) {
            // Make sure that snapshot clean up operations are finished
            ClusterStateResponse stateResponse = client().admin().cluster().prepareState().get();
            SnapshotsInProgress snapshotsInProgress = stateResponse.getState().custom(SnapshotsInProgress.TYPE);
            if (snapshotsInProgress == null) {
                return snapshotInfos.get(0);
            } else {
                boolean found = false;
                for (SnapshotsInProgress.Entry entry : snapshotsInProgress.entries()) {
                    final Snapshot curr = entry.snapshot();
                    if (curr.getRepository().equals(repository) && curr.getSnapshotId().getName().equals(snapshotName)) {
                        found = true;
                        break;
                    }
                }
                if (found == false) {
                    return snapshotInfos.get(0);
                }
            }
        }
        Thread.sleep(100);
    }
    fail("Timeout!!!");
    return null;
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的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.SnapshotsInProgress; //导入方法依赖的package包/类
/**
 * Checks if any shards were processed that the new master doesn't know about
 */
private void syncShardStatsOnNewMaster(ClusterChangedEvent event) {
    SnapshotsInProgress snapshotsInProgress = event.state().custom(SnapshotsInProgress.TYPE);
    if (snapshotsInProgress == null) {
        return;
    }
    for (SnapshotsInProgress.Entry snapshot : snapshotsInProgress.entries()) {
        if (snapshot.state() == SnapshotsInProgress.State.STARTED || snapshot.state() == SnapshotsInProgress.State.ABORTED) {
            Map<ShardId, IndexShardSnapshotStatus> localShards = currentSnapshotShards(snapshot.snapshotId());
            if (localShards != null) {
                ImmutableMap<ShardId, SnapshotsInProgress.ShardSnapshotStatus> masterShards = snapshot.shards();
                for(Map.Entry<ShardId, IndexShardSnapshotStatus> localShard : localShards.entrySet()) {
                    ShardId shardId = localShard.getKey();
                    IndexShardSnapshotStatus localShardStatus = localShard.getValue();
                    SnapshotsInProgress.ShardSnapshotStatus masterShard = masterShards.get(shardId);
                    if (masterShard != null && masterShard.state().completed() == false) {
                        // Master knows about the shard and thinks it has not completed
                        if (localShardStatus.stage() == IndexShardSnapshotStatus.Stage.DONE) {
                            // but we think the shard is done - we need to make new master know that the shard is done
                            logger.debug("[{}] new master thinks the shard [{}] is not completed but the shard is done locally, updating status on the master", snapshot.snapshotId(), shardId);
                            updateIndexShardSnapshotStatus(snapshot.snapshotId(), shardId,
                                    new SnapshotsInProgress.ShardSnapshotStatus(event.state().nodes().localNodeId(), SnapshotsInProgress.State.SUCCESS));
                        } else if (localShard.getValue().stage() == IndexShardSnapshotStatus.Stage.FAILURE) {
                            // but we think the shard failed - we need to make new master know that the shard failed
                            logger.debug("[{}] new master thinks the shard [{}] is not completed but the shard failed locally, updating status on master", snapshot.snapshotId(), shardId);
                            updateIndexShardSnapshotStatus(snapshot.snapshotId(), shardId,
                                    new SnapshotsInProgress.ShardSnapshotStatus(event.state().nodes().localNodeId(), SnapshotsInProgress.State.FAILED, localShardStatus.failure()));

                        }
                    }
                }
            }
        }
    }
}
 

import org.elasticsearch.cluster.SnapshotsInProgress; //导入方法依赖的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);
}