Examples with Index org.elasticsearch.index.Index used on opensource projects

Example 46 with Index

use of org.elasticsearch.index.Index in project elasticsearch by elastic.

the class GatewayMetaState method applyClusterState.

@Override
public void applyClusterState(ClusterChangedEvent event) {
    final ClusterState state = event.state();
    if (state.blocks().disableStatePersistence()) {
        // reset the current metadata, we need to start fresh...
        this.previousMetaData = null;
        previouslyWrittenIndices = emptySet();
        return;
    }
    MetaData newMetaData = state.metaData();
    // we don't check if metaData changed, since we might be called several times and we need to check dangling...
    Set<Index> relevantIndices = Collections.emptySet();
    boolean success = true;
    // write the state if this node is a master eligible node or if it is a data node and has shards allocated on it
    if (state.nodes().getLocalNode().isMasterNode() || state.nodes().getLocalNode().isDataNode()) {
        if (previousMetaData == null) {
            try {
                // we therefore have to check here if we have shards on disk and add their indices to the previouslyWrittenIndices list
                if (isDataOnlyNode(state)) {
                    Set<Index> newPreviouslyWrittenIndices = new HashSet<>(previouslyWrittenIndices.size());
                    for (IndexMetaData indexMetaData : newMetaData) {
                        IndexMetaData indexMetaDataOnDisk = null;
                        if (indexMetaData.getState().equals(IndexMetaData.State.CLOSE)) {
                            indexMetaDataOnDisk = metaStateService.loadIndexState(indexMetaData.getIndex());
                        }
                        if (indexMetaDataOnDisk != null) {
                            newPreviouslyWrittenIndices.add(indexMetaDataOnDisk.getIndex());
                        }
                    }
                    newPreviouslyWrittenIndices.addAll(previouslyWrittenIndices);
                    previouslyWrittenIndices = unmodifiableSet(newPreviouslyWrittenIndices);
                }
            } catch (Exception e) {
                success = false;
            }
        }
        // check if the global state changed?
        if (previousMetaData == null || !MetaData.isGlobalStateEquals(previousMetaData, newMetaData)) {
            try {
                metaStateService.writeGlobalState("changed", newMetaData);
            } catch (Exception e) {
                success = false;
            }
        }
        relevantIndices = getRelevantIndices(event.state(), event.previousState(), previouslyWrittenIndices);
        final Iterable<IndexMetaWriteInfo> writeInfo = resolveStatesToBeWritten(previouslyWrittenIndices, relevantIndices, previousMetaData, event.state().metaData());
        // check and write changes in indices
        for (IndexMetaWriteInfo indexMetaWrite : writeInfo) {
            try {
                metaStateService.writeIndex(indexMetaWrite.reason, indexMetaWrite.newMetaData);
            } catch (Exception e) {
                success = false;
            }
        }
    }
    if (success) {
        previousMetaData = newMetaData;
        previouslyWrittenIndices = unmodifiableSet(relevantIndices);
    }
}

Example 47 with Index

use of org.elasticsearch.index.Index in project elasticsearch by elastic.

the class GatewayMetaState method getRelevantIndicesOnDataOnlyNode.

public static Set<Index> getRelevantIndicesOnDataOnlyNode(ClusterState state, ClusterState previousState, Set<Index> previouslyWrittenIndices) {
    RoutingNode newRoutingNode = state.getRoutingNodes().node(state.nodes().getLocalNodeId());
    if (newRoutingNode == null) {
        throw new IllegalStateException("cluster state does not contain this node - cannot write index meta state");
    }
    Set<Index> indices = new HashSet<>();
    for (ShardRouting routing : newRoutingNode) {
        indices.add(routing.index());
    }
    // we have to check the meta data also: closed indices will not appear in the routing table, but we must still write the state if we have it written on disk previously
    for (IndexMetaData indexMetaData : state.metaData()) {
        boolean isOrWasClosed = indexMetaData.getState().equals(IndexMetaData.State.CLOSE);
        // if the index is open we might still have to write the state if it just transitioned from closed to open
        // so we have to check for that as well.
        IndexMetaData previousMetaData = previousState.metaData().index(indexMetaData.getIndex());
        if (previousMetaData != null) {
            isOrWasClosed = isOrWasClosed || previousMetaData.getState().equals(IndexMetaData.State.CLOSE);
        }
        if (previouslyWrittenIndices.contains(indexMetaData.getIndex()) && isOrWasClosed) {
            indices.add(indexMetaData.getIndex());
        }
    }
    return indices;
}

Example 48 with Index

use of org.elasticsearch.index.Index in project elasticsearch by elastic.

the class GatewayMetaState method resolveStatesToBeWritten.

/**
     * Loads the current meta state for each index in the new cluster state and checks if it has to be persisted.
     * Each index state that should be written to disk will be returned. This is only run for data only nodes.
     * It will return only the states for indices that actually have a shard allocated on the current node.
     *
     * @param previouslyWrittenIndices    A list of indices for which the state was already written before
     * @param potentiallyUnwrittenIndices The list of indices for which state should potentially be written
     * @param previousMetaData            The last meta data we know of. meta data for all indices in previouslyWrittenIndices list is persisted now
     * @param newMetaData                 The new metadata
     * @return iterable over all indices states that should be written to disk
     */
public static Iterable<GatewayMetaState.IndexMetaWriteInfo> resolveStatesToBeWritten(Set<Index> previouslyWrittenIndices, Set<Index> potentiallyUnwrittenIndices, MetaData previousMetaData, MetaData newMetaData) {
    List<GatewayMetaState.IndexMetaWriteInfo> indicesToWrite = new ArrayList<>();
    for (Index index : potentiallyUnwrittenIndices) {
        IndexMetaData newIndexMetaData = newMetaData.getIndexSafe(index);
        IndexMetaData previousIndexMetaData = previousMetaData == null ? null : previousMetaData.index(index);
        String writeReason = null;
        if (previouslyWrittenIndices.contains(index) == false || previousIndexMetaData == null) {
            writeReason = "freshly created";
        } else if (previousIndexMetaData.getVersion() != newIndexMetaData.getVersion()) {
            writeReason = "version changed from [" + previousIndexMetaData.getVersion() + "] to [" + newIndexMetaData.getVersion() + "]";
        }
        if (writeReason != null) {
            indicesToWrite.add(new GatewayMetaState.IndexMetaWriteInfo(newIndexMetaData, previousIndexMetaData, writeReason));
        }
    }
    return indicesToWrite;
}

Example 49 with Index

use of org.elasticsearch.index.Index in project elasticsearch by elastic.

the class GatewayMetaState method getRelevantIndicesForMasterEligibleNode.

public static Set<Index> getRelevantIndicesForMasterEligibleNode(ClusterState state) {
    Set<Index> relevantIndices;
    relevantIndices = new HashSet<>();
    // we have to iterate over the metadata to make sure we also capture closed indices
    for (IndexMetaData indexMetaData : state.metaData()) {
        relevantIndices.add(indexMetaData.getIndex());
    }
    return relevantIndices;
}

Example 50 with Index

use of org.elasticsearch.index.Index in project elasticsearch by elastic.

the class AnalysisRegistry method build.

public IndexAnalyzers build(IndexSettings indexSettings, Map<String, AnalyzerProvider<?>> analyzerProviders, Map<String, AnalyzerProvider<?>> normalizerProviders, Map<String, TokenizerFactory> tokenizerFactoryFactories, Map<String, CharFilterFactory> charFilterFactoryFactories, Map<String, TokenFilterFactory> tokenFilterFactoryFactories) {
    Index index = indexSettings.getIndex();
    analyzerProviders = new HashMap<>(analyzerProviders);
    Logger logger = Loggers.getLogger(getClass(), indexSettings.getSettings());
    DeprecationLogger deprecationLogger = new DeprecationLogger(logger);
    Map<String, NamedAnalyzer> analyzerAliases = new HashMap<>();
    Map<String, NamedAnalyzer> analyzers = new HashMap<>();
    Map<String, NamedAnalyzer> normalizers = new HashMap<>();
    for (Map.Entry<String, AnalyzerProvider<?>> entry : analyzerProviders.entrySet()) {
        processAnalyzerFactory(deprecationLogger, indexSettings, entry.getKey(), entry.getValue(), analyzerAliases, analyzers, tokenFilterFactoryFactories, charFilterFactoryFactories, tokenizerFactoryFactories);
    }
    for (Map.Entry<String, AnalyzerProvider<?>> entry : normalizerProviders.entrySet()) {
        processNormalizerFactory(deprecationLogger, indexSettings, entry.getKey(), entry.getValue(), normalizers, tokenFilterFactoryFactories, charFilterFactoryFactories);
    }
    for (Map.Entry<String, NamedAnalyzer> entry : analyzerAliases.entrySet()) {
        String key = entry.getKey();
        if (analyzers.containsKey(key) && ("default".equals(key) || "default_search".equals(key) || "default_search_quoted".equals(key)) == false) {
            throw new IllegalStateException("already registered analyzer with name: " + key);
        } else {
            NamedAnalyzer configured = entry.getValue();
            analyzers.put(key, configured);
        }
    }
    if (!analyzers.containsKey("default")) {
        processAnalyzerFactory(deprecationLogger, indexSettings, "default", new StandardAnalyzerProvider(indexSettings, null, "default", Settings.Builder.EMPTY_SETTINGS), analyzerAliases, analyzers, tokenFilterFactoryFactories, charFilterFactoryFactories, tokenizerFactoryFactories);
    }
    if (!analyzers.containsKey("default_search")) {
        analyzers.put("default_search", analyzers.get("default"));
    }
    if (!analyzers.containsKey("default_search_quoted")) {
        analyzers.put("default_search_quoted", analyzers.get("default_search"));
    }
    NamedAnalyzer defaultAnalyzer = analyzers.get("default");
    if (defaultAnalyzer == null) {
        throw new IllegalArgumentException("no default analyzer configured");
    }
    if (analyzers.containsKey("default_index")) {
        final Version createdVersion = indexSettings.getIndexVersionCreated();
        if (createdVersion.onOrAfter(Version.V_5_0_0_alpha1)) {
            throw new IllegalArgumentException("setting [index.analysis.analyzer.default_index] is not supported anymore, use [index.analysis.analyzer.default] instead for index [" + index.getName() + "]");
        } else {
            deprecationLogger.deprecated("setting [index.analysis.analyzer.default_index] is deprecated, use [index.analysis.analyzer.default] instead for index [{}]", index.getName());
        }
    }
    NamedAnalyzer defaultIndexAnalyzer = analyzers.containsKey("default_index") ? analyzers.get("default_index") : defaultAnalyzer;
    NamedAnalyzer defaultSearchAnalyzer = analyzers.containsKey("default_search") ? analyzers.get("default_search") : defaultAnalyzer;
    NamedAnalyzer defaultSearchQuoteAnalyzer = analyzers.containsKey("default_search_quote") ? analyzers.get("default_search_quote") : defaultSearchAnalyzer;
    for (Map.Entry<String, NamedAnalyzer> analyzer : analyzers.entrySet()) {
        if (analyzer.getKey().startsWith("_")) {
            throw new IllegalArgumentException("analyzer name must not start with '_'. got \"" + analyzer.getKey() + "\"");
        }
    }
    return new IndexAnalyzers(indexSettings, defaultIndexAnalyzer, defaultSearchAnalyzer, defaultSearchQuoteAnalyzer, unmodifiableMap(analyzers), unmodifiableMap(normalizers));
}