Java IndexMetaData.getIndex方法代码示例

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Deletes the index store trying to acquire all shards locks for this index.
 * This method will delete the metadata for the index even if the actual shards can't be locked.
 *
 * Package private for testing
 */
void deleteIndexStore(String reason, IndexMetaData metaData, ClusterState clusterState) throws IOException {
    if (nodeEnv.hasNodeFile()) {
        synchronized (this) {
            Index index = metaData.getIndex();
            if (hasIndex(index)) {
                String localUUid = indexService(index).indexUUID();
                throw new IllegalStateException("Can't delete index store for [" + index.getName() + "] - it's still part of the indices service [" + localUUid + "] [" + metaData.getIndexUUID() + "]");
            }

            if (clusterState.metaData().hasIndex(index.getName()) && (clusterState.nodes().getLocalNode().isMasterNode() == true)) {
                // we do not delete the store if it is a master eligible node and the index is still in the cluster state
                // because we want to keep the meta data for indices around even if no shards are left here
                final IndexMetaData idxMeta = clusterState.metaData().index(index.getName());
                throw new IllegalStateException("Can't delete index store for [" + index.getName() + "] - it's still part of the " +
                                                "cluster state [" + idxMeta.getIndexUUID() + "] [" + metaData.getIndexUUID() + "], " +
                                                "we are master eligible, so will keep the index metadata even if no shards are left.");
            }
        }
        final IndexSettings indexSettings = buildIndexSettings(metaData);
        deleteIndexStore(reason, indexSettings.getIndex(), indexSettings);
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
private void applySettings(ClusterChangedEvent event) {
    if (!event.metaDataChanged()) {
        return;
    }
    for (IndexMetaData indexMetaData : event.state().metaData()) {
        if (!indicesService.hasIndex(indexMetaData.getIndex())) {
            // we only create / update here
            continue;
        }
        // if the index meta data didn't change, no need check for refreshed settings
        if (!event.indexMetaDataChanged(indexMetaData)) {
            continue;
        }
        String index = indexMetaData.getIndex();
        IndexService indexService = indicesService.indexService(index);
        if (indexService == null) {
            // already deleted on us, ignore it
            continue;
        }
        IndexSettingsService indexSettingsService = indexService.injector().getInstance(IndexSettingsService.class);
        indexSettingsService.refreshSettings(indexMetaData.getSettings());
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
private void applyAliases(ClusterChangedEvent event) {
    // check if aliases changed
    if (aliasesChanged(event)) {
        // go over and update aliases
        for (IndexMetaData indexMetaData : event.state().metaData()) {
            String index = indexMetaData.getIndex();
            IndexService indexService = indicesService.indexService(index);
            if (indexService == null) {
                // we only create / update here
                continue;
            }
            IndexAliasesService indexAliasesService = indexService.aliasesService();
            indexAliasesService.setAliases(indexMetaData.getAliases());
        }
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Initializes an index, to be restored from snapshot
 */
private Builder initializeAsRestore(IndexMetaData indexMetaData, RestoreSource restoreSource, IntSet ignoreShards, boolean asNew, UnassignedInfo unassignedInfo) {
    if (!shards.isEmpty()) {
        throw new IllegalStateException("trying to initialize an index with fresh shards, but already has shards created");
    }
    for (int shardId = 0; shardId < indexMetaData.getNumberOfShards(); shardId++) {
        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(new ShardId(indexMetaData.getIndex(), shardId));
        for (int i = 0; i <= indexMetaData.getNumberOfReplicas(); i++) {
            if (asNew && ignoreShards.contains(shardId)) {
                // This shards wasn't completely snapshotted - restore it as new shard
                indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(index, shardId, null, i == 0, unassignedInfo));
            } else {
                indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(index, shardId, i == 0 ? restoreSource : null, i == 0, unassignedInfo));
            }
        }
        shards.put(shardId, indexShardRoutingBuilder.build());
    }
    return this;
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * This creates a new IndexService without registering it
 */
private synchronized IndexService createIndexService(final String reason,
                                                     IndexMetaData indexMetaData, IndicesQueryCache indicesQueryCache,
                                                     IndicesFieldDataCache indicesFieldDataCache,
                                                     List<IndexEventListener> builtInListeners,
                                                     Consumer<ShardId> globalCheckpointSyncer,
                                                     IndexingOperationListener... indexingOperationListeners) throws IOException {
    final Index index = indexMetaData.getIndex();
    final IndexSettings idxSettings = new IndexSettings(indexMetaData, this.settings, indexScopeSetting);
    logger.debug("creating Index [{}], shards [{}]/[{}{}] - reason [{}]",
        indexMetaData.getIndex(),
        idxSettings.getNumberOfShards(),
        idxSettings.getNumberOfReplicas(),
        idxSettings.isShadowReplicaIndex() ? "s" : "", reason);

    final IndexModule indexModule = new IndexModule(idxSettings, analysisRegistry);
    for (IndexingOperationListener operationListener : indexingOperationListeners) {
        indexModule.addIndexOperationListener(operationListener);
    }
    pluginsService.onIndexModule(indexModule);
    for (IndexEventListener listener : builtInListeners) {
        indexModule.addIndexEventListener(listener);
    }
    return indexModule.newIndexService(
        nodeEnv,
        xContentRegistry,
        this,
        circuitBreakerService,
        bigArrays,
        threadPool,
        scriptService,
        clusterService,
        client,
        indicesQueryCache,
        mapperRegistry,
        globalCheckpointSyncer,
        indicesFieldDataCache);
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Ensures that all indices are compatible with the supported index version.
 * @throws IllegalStateException if any index is incompatible with the given version
 */
static void ensureIndexCompatibility(final Version supportedIndexVersion, MetaData metaData) {
    // we ensure that all indices in the cluster we join are compatible with us no matter if they are
    // closed or not we can't read mappings of these indices so we need to reject the join...
    for (IndexMetaData idxMetaData : metaData) {
        if (idxMetaData.getCreationVersion().before(supportedIndexVersion)) {
            throw new IllegalStateException("index " + idxMetaData.getIndex() + " version not supported: "
                + idxMetaData.getCreationVersion() + " minimum compatible index version is: " + supportedIndexVersion);
        }
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Writes the index state.
 *
 * This method is public for testing purposes.
 */
public void writeIndex(String reason, IndexMetaData indexMetaData) throws IOException {
    final Index index = indexMetaData.getIndex();
    logger.trace("[{}] writing state, reason [{}]", index, reason);
    try {
        IndexMetaData.FORMAT.write(indexMetaData,
            nodeEnv.indexPaths(indexMetaData.getIndex()));
    } catch (Exception ex) {
        logger.warn((Supplier<?>) () -> new ParameterizedMessage("[{}]: failed to write index state", index), ex);
        throw new IOException("failed to write state for [" + index + "]", ex);
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
@Override
public RerouteExplanation execute(RoutingAllocation allocation, boolean explain) {
    DiscoveryNode discoNode = allocation.nodes().resolveNode(node);
    ShardRouting shardRouting = null;
    RoutingNodes routingNodes = allocation.routingNodes();
    RoutingNode routingNode = routingNodes.node(discoNode.getId());
    IndexMetaData indexMetaData = null;
    if (routingNode != null) {
        indexMetaData = allocation.metaData().index(index());
        if (indexMetaData == null) {
            throw new IndexNotFoundException(index());
        }
        ShardId shardId = new ShardId(indexMetaData.getIndex(), shardId());
        shardRouting = routingNode.getByShardId(shardId);
    }
    if (shardRouting == null) {
        if (explain) {
            return new RerouteExplanation(this, allocation.decision(Decision.NO, "cancel_allocation_command",
                "can't cancel " + shardId + ", failed to find it on node " + discoNode));
        }
        throw new IllegalArgumentException("[cancel_allocation] can't cancel " + shardId + ", failed to find it on node " + discoNode);
    }
    if (shardRouting.primary() && allowPrimary == false) {
        if ((shardRouting.initializing() && shardRouting.relocatingNodeId() != null) == false) {
            // only allow cancelling initializing shard of primary relocation without allowPrimary flag
            if (explain) {
                return new RerouteExplanation(this, allocation.decision(Decision.NO, "cancel_allocation_command",
                    "can't cancel " + shardId + " on node " + discoNode + ", shard is primary and " +
                        shardRouting.state().name().toLowerCase(Locale.ROOT)));
            }
            throw new IllegalArgumentException("[cancel_allocation] can't cancel " + shardId + " on node " +
                discoNode + ", shard is primary and " + shardRouting.state().name().toLowerCase(Locale.ROOT));
        }
    }
    routingNodes.failShard(Loggers.getLogger(CancelAllocationCommand.class), shardRouting,
        new UnassignedInfo(UnassignedInfo.Reason.REROUTE_CANCELLED, null), indexMetaData, allocation.changes());
    return new RerouteExplanation(this, allocation.decision(Decision.YES, "cancel_allocation_command",
            "shard " + shardId + " on node " + discoNode + " can be cancelled"));
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Renames <code>indexFolderName</code> index folders found in node paths and custom path
 * iff {@link #needsUpgrade(Index, String)} is true.
 * Index folder in custom paths are renamed first followed by index folders in each node path.
 */
void upgrade(final String indexFolderName) throws IOException {
    for (NodeEnvironment.NodePath nodePath : nodeEnv.nodePaths()) {
        final Path indexFolderPath = nodePath.indicesPath.resolve(indexFolderName);
        final IndexMetaData indexMetaData = IndexMetaData.FORMAT.loadLatestState(logger, NamedXContentRegistry.EMPTY, indexFolderPath);
        if (indexMetaData != null) {
            final Index index = indexMetaData.getIndex();
            if (needsUpgrade(index, indexFolderName)) {
                logger.info("{} upgrading [{}] to new naming convention", index, indexFolderPath);
                final IndexSettings indexSettings = new IndexSettings(indexMetaData, settings);
                if (indexSettings.hasCustomDataPath()) {
                    // we rename index folder in custom path before renaming them in any node path
                    // to have the index state under a not-yet-upgraded index folder, which we use to
                    // continue renaming after a incomplete upgrade.
                    final Path customLocationSource = nodeEnv.resolveBaseCustomLocation(indexSettings)
                        .resolve(indexFolderName);
                    final Path customLocationTarget = customLocationSource.resolveSibling(index.getUUID());
                    // we rename the folder in custom path only the first time we encounter a state
                    // in a node path, which needs upgrading, it is a no-op for subsequent node paths
                    if (Files.exists(customLocationSource) // might not exist if no data was written for this index
                        && Files.exists(customLocationTarget) == false) {
                        upgrade(index, customLocationSource, customLocationTarget);
                    } else {
                        logger.info("[{}] no upgrade needed - already upgraded", customLocationTarget);
                    }
                }
                upgrade(index, indexFolderPath, indexFolderPath.resolveSibling(index.getUUID()));
            } else {
                logger.debug("[{}] no upgrade needed - already upgraded", indexFolderPath);
            }
        } else {
            logger.warn("[{}] no index state found - ignoring", indexFolderPath);
        }
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
public void testStartedShardsMatching() {
    AllocationService allocation = createAllocationService();

    logger.info("--> building initial cluster state");
    AllocationId allocationId = AllocationId.newRelocation(AllocationId.newInitializing());
    final IndexMetaData indexMetaData = IndexMetaData.builder("test")
            .settings(settings(Version.CURRENT))
            .numberOfShards(2).numberOfReplicas(0)
            .putInSyncAllocationIds(1, Collections.singleton(allocationId.getId()))
            .build();
    final Index index = indexMetaData.getIndex();
    ClusterState.Builder stateBuilder = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
            .nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")))
            .metaData(MetaData.builder().put(indexMetaData, false));

    final ShardRouting initShard = TestShardRouting.newShardRouting(new ShardId(index, 0), "node1", true, ShardRoutingState.INITIALIZING);
    final ShardRouting relocatingShard = TestShardRouting.newShardRouting(new ShardId(index, 1), "node1", "node2", true, ShardRoutingState.RELOCATING, allocationId);
    stateBuilder.routingTable(RoutingTable.builder().add(IndexRoutingTable.builder(index)
            .addIndexShard(new IndexShardRoutingTable.Builder(initShard.shardId()).addShard(initShard).build())
            .addIndexShard(new IndexShardRoutingTable.Builder(relocatingShard.shardId()).addShard(relocatingShard).build())).build());

    ClusterState state = stateBuilder.build();

    logger.info("--> test starting of shard");

    ClusterState newState = allocation.applyStartedShards(state, Arrays.asList(initShard));
    assertThat("failed to start " + initShard + "\ncurrent routing table:" + newState.routingTable(), newState, not(equalTo(state)));
    assertTrue(initShard + "isn't started \ncurrent routing table:" + newState.routingTable(),
            newState.routingTable().index("test").shard(initShard.id()).allShardsStarted());
    state = newState;

    logger.info("--> testing starting of relocating shards");
    newState = allocation.applyStartedShards(state, Arrays.asList(relocatingShard.getTargetRelocatingShard()));
    assertThat("failed to start " + relocatingShard + "\ncurrent routing table:" + newState.routingTable(),
        newState, not(equalTo(state)));
    ShardRouting shardRouting = newState.routingTable().index("test").shard(relocatingShard.id()).getShards().get(0);
    assertThat(shardRouting.state(), equalTo(ShardRoutingState.STARTED));
    assertThat(shardRouting.currentNodeId(), equalTo("node2"));
    assertThat(shardRouting.relocatingNodeId(), nullValue());
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
private void removeIndexLocationsForDeletedIndices(ClusterChangedEvent event, MetaData currentMetaData) {
    MetaData newMetaData = event.state().metaData();
    for (IndexMetaData current : currentMetaData) {
        String index = current.getIndex();
        if (!newMetaData.hasIndex(index) && isBlobIndex(index)) {
            deleteBlobIndexLocation(current, index);
        }
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
public void deleteClosedIndex(String reason, IndexMetaData metaData, ClusterState clusterState) {
    if (nodeEnv.hasNodeFile()) {
        String indexName = metaData.getIndex();
        try {
            if (clusterState.metaData().hasIndex(indexName)) {
                final IndexMetaData index = clusterState.metaData().index(indexName);
                throw new IllegalStateException("Can't delete closed index store for [" + indexName + "] - it's still part of the cluster state [" + index.getIndexUUID() + "] [" + metaData.getIndexUUID() + "]");
            }
            deleteIndexStore(reason, metaData, clusterState, true);
        } catch (IOException e) {
            logger.warn("[{}] failed to delete closed index", e, metaData.getIndex());
        }
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Writes the index state.
 */
void writeIndex(String reason, IndexMetaData indexMetaData, @Nullable IndexMetaData previousIndexMetaData) throws Exception {
    logger.trace("[{}] writing state, reason [{}]", indexMetaData.getIndex(), reason);
    try {
        indexStateFormat.write(indexMetaData, indexMetaData.getVersion(),
                nodeEnv.indexPaths(new Index(indexMetaData.getIndex())));
    } catch (Throwable ex) {
        logger.warn("[{}]: failed to write index state", ex, indexMetaData.getIndex());
        throw new IOException("failed to write state for [" + indexMetaData.getIndex() + "]", ex);
    }
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
/**
 * Initializes a new empty index, with an option to control if its from an API or not.
 */
private Builder initializeEmpty(IndexMetaData indexMetaData, UnassignedInfo unassignedInfo) {
    if (!shards.isEmpty()) {
        throw new IllegalStateException("trying to initialize an index with fresh shards, but already has shards created");
    }
    for (int shardId = 0; shardId < indexMetaData.getNumberOfShards(); shardId++) {
        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(new ShardId(indexMetaData.getIndex(), shardId));
        for (int i = 0; i <= indexMetaData.getNumberOfReplicas(); i++) {
            indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(index, shardId, null, i == 0, unassignedInfo));
        }
        shards.put(shardId, indexShardRoutingBuilder.build());
    }
    return this;
}
 

import org.elasticsearch.cluster.metadata.IndexMetaData; //导入方法依赖的package包/类
public ClusterIndexHealth(IndexMetaData indexMetaData, IndexRoutingTable indexRoutingTable) {
    this.index = indexMetaData.getIndex();
    this.numberOfShards = indexMetaData.getNumberOfShards();
    this.numberOfReplicas = indexMetaData.getNumberOfReplicas();
    this.validationFailures = indexRoutingTable.validate(indexMetaData);

    for (IndexShardRoutingTable shardRoutingTable : indexRoutingTable) {
        int shardId = shardRoutingTable.shardId().id();
        shards.put(shardId, new ClusterShardHealth(shardId, shardRoutingTable));
    }

    // update the index status
    status = ClusterHealthStatus.GREEN;

    for (ClusterShardHealth shardHealth : shards.values()) {
        if (shardHealth.isPrimaryActive()) {
            activePrimaryShards++;
        }
        activeShards += shardHealth.getActiveShards();
        relocatingShards += shardHealth.getRelocatingShards();
        initializingShards += shardHealth.getInitializingShards();
        unassignedShards += shardHealth.getUnassignedShards();

        if (shardHealth.getStatus() == ClusterHealthStatus.RED) {
            status = ClusterHealthStatus.RED;
        } else if (shardHealth.getStatus() == ClusterHealthStatus.YELLOW && status != ClusterHealthStatus.RED) {
            // do not override an existing red
            status = ClusterHealthStatus.YELLOW;
        }
    }
    if (!validationFailures.isEmpty()) {
        status = ClusterHealthStatus.RED;
    } else if (shards.isEmpty()) { // might be since none has been created yet (two phase index creation)
        status = ClusterHealthStatus.RED;
    }
}