Java Code Examples for org.elasticsearch.Version#indexCreated()

/**
 * Updates the settings and index metadata and notifies all registered settings consumers with the new settings iff at least one setting has changed.
 *
 * @return <code>true</code> iff any setting has been updated otherwise <code>false</code>.
 */
public synchronized boolean updateIndexMetaData(IndexMetaData indexMetaData) {
    final Settings newSettings = indexMetaData.getSettings();
    if (version.equals(Version.indexCreated(newSettings)) == false) {
        throw new IllegalArgumentException("version mismatch on settings update expected: " + version + " but was: " + Version.indexCreated(newSettings));
    }
    final String newUUID = newSettings.get(IndexMetaData.SETTING_INDEX_UUID, IndexMetaData.INDEX_UUID_NA_VALUE);
    if (newUUID.equals(getUUID()) == false) {
        throw new IllegalArgumentException("uuid mismatch on settings update expected: " + getUUID() + " but was: " + newUUID);
    }
    this.indexMetaData = indexMetaData;
    final Settings newIndexSettings = Settings.builder().put(nodeSettings).put(newSettings).build();
    if (same(this.settings, newIndexSettings)) {
        // nothing to update, same settings
        return false;
    }
    scopedSettings.applySettings(newSettings);
    this.settings = newIndexSettings;
    return true;
}
 

public StandardAnalyzerProvider(Index index, Settings indexSettings, Environment env, String name, Settings settings) {
    super(index, indexSettings, name, settings);
    this.esVersion = Version.indexCreated(indexSettings);
    final CharArraySet defaultStopwords;
    if (esVersion.onOrAfter(Version.V_1_0_0_Beta1)) {
        defaultStopwords = CharArraySet.EMPTY_SET;
    } else {
        defaultStopwords = StopAnalyzer.ENGLISH_STOP_WORDS_SET;
    }

    CharArraySet stopWords = Analysis.parseStopWords(env, settings, defaultStopwords);
    int maxTokenLength = settings.getAsInt("max_token_length", StandardAnalyzer.DEFAULT_MAX_TOKEN_LENGTH);
    standardAnalyzer = new StandardAnalyzer(stopWords);
    standardAnalyzer.setVersion(version);
    standardAnalyzer.setMaxTokenLength(maxTokenLength);
}
 

@Inject
public PatternAnalyzerProvider(Index index, IndexSettingsService indexSettingsService, Environment env, @Assisted String name, @Assisted Settings settings) {
    super(index, indexSettingsService.getSettings(), name, settings);

    Version esVersion = Version.indexCreated(indexSettingsService.getSettings());
    final CharArraySet defaultStopwords;
    if (esVersion.onOrAfter(Version.V_1_0_0_RC1)) {
        defaultStopwords = CharArraySet.EMPTY_SET;
    } else {
        defaultStopwords = StopAnalyzer.ENGLISH_STOP_WORDS_SET;
    }
    boolean lowercase = settings.getAsBoolean("lowercase", true);
    CharArraySet stopWords = Analysis.parseStopWords(env, settings, defaultStopwords);

    String sPattern = settings.get("pattern", "\\W+" /*PatternAnalyzer.NON_WORD_PATTERN*/);
    if (sPattern == null) {
        throw new IllegalArgumentException("Analyzer [" + name + "] of type pattern must have a `pattern` set");
    }
    Pattern pattern = Regex.compile(sPattern, settings.get("flags"));

    analyzer = new PatternAnalyzer(pattern, lowercase, stopWords);
}
 

@Override
public TokenFilterFactory create(String name, Settings settings) {
    Version indexVersion = Version.indexCreated(settings);
    if (!Version.CURRENT.equals(indexVersion)) {
        PreBuiltTokenFilters preBuiltTokenFilters = PreBuiltTokenFilters.getOrDefault(name, null);
        if (preBuiltTokenFilters != null) {
            return preBuiltTokenFilters.getTokenFilterFactory(indexVersion);
        }
    }
    return tokenFilterFactory;
}
 

@Override
public T get(IndexSettings indexSettings, Environment environment, String name, Settings settings) throws IOException {
    Version versionCreated = Version.indexCreated(settings);
    synchronized (this) {
        T factory = cache.get(versionCreated);
        if (factory == null) {
            factory = create(versionCreated);
            cache.put(versionCreated, factory);
        }
        return factory;
    }
}
 

@Override
public AnalyzerProvider<?> get(IndexSettings indexSettings,
                               Environment environment,
                               String name,
                               Settings settings) throws IOException {
    Version versionCreated = Version.indexCreated(settings);
    if (Version.CURRENT.equals(versionCreated) == false) {
        return super.get(indexSettings, environment, name, settings);
    } else {
        return current;
    }
}
 

private Version getVersion(MetaData metaData, String concreteIndex) {
    // this can go away in 3.0 but is here now for easy backporting - since in 2.x we need the version on the timestamp stuff
    final IndexMetaData indexMetaData = metaData.getIndices().get(concreteIndex);
    if (indexMetaData == null) {
        throw new IndexNotFoundException(concreteIndex);
    }
    return Version.indexCreated(indexMetaData.getSettings());
}
 

@Nullable
public Version indexCreatedVersion() {
    if (indexSettings == null) {
        return null;
    }
    return Version.indexCreated(indexSettings);
}
 

private static FormatDateTimeFormatter getDateTimeFormatter(Settings indexSettings) {
    Version indexCreated = Version.indexCreated(indexSettings);
    if (indexCreated.onOrAfter(Version.V_2_0_0_beta1)) {
        return Defaults.DATE_TIME_FORMATTER;
    } else {
        return Defaults.DATE_TIME_FORMATTER_BEFORE_2_0;
    }
}
 

private static MappedFieldType joinFieldTypeForParentType(String parentType, Settings indexSettings) {
    MappedFieldType parentJoinFieldType = Defaults.JOIN_FIELD_TYPE.clone();
    parentJoinFieldType.setNames(new MappedFieldType.Names(joinField(parentType)));

    Version indexCreated = Version.indexCreated(indexSettings);
    if (indexCreated.before(Version.V_2_0_0_beta1)) {
        parentJoinFieldType.setHasDocValues(false);
        parentJoinFieldType.setDocValuesType(DocValuesType.NONE);
    }
    parentJoinFieldType.freeze();
    return parentJoinFieldType;
}
 

public DocumentMapper build(MapperService mapperService) {
    Objects.requireNonNull(rootObjectMapper, "Mapper builder must have the root object mapper set");
    Mapping mapping = new Mapping(
            Version.indexCreated(mapperService.indexSettings()),
            rootObjectMapper,
            metadataMappers.values().toArray(new MetadataFieldMapper[metadataMappers.values().size()]),
            sourceTransforms.toArray(new SourceTransform[sourceTransforms.size()]),
            meta);
    return new DocumentMapper(mapperService, mapping);
}
 

public DocumentMapperParser(Settings indexSettings, MapperService mapperService, AnalysisService analysisService,
                            SimilarityLookupService similarityLookupService, ScriptService scriptService,
                            MapperRegistry mapperRegistry,
                            @Nullable DynamicArrayFieldMapperBuilderFactory dynamicArrayFieldMapperBuilderFactory) {
    this.dynamicArrayFieldMapperBuilderFactory = dynamicArrayFieldMapperBuilderFactory;
    this.parseFieldMatcher = new ParseFieldMatcher(indexSettings);
    this.scriptService = scriptService;
    this.mapperService = mapperService;
    this.analysisService = analysisService;
    this.similarityLookupService = similarityLookupService;
    this.typeParsers = mapperRegistry.getMapperParsers();
    this.rootTypeParsers = mapperRegistry.getMetadataMapperParsers();
    indexVersionCreated = Version.indexCreated(indexSettings);
}
 

@Override
public CharFilterFactory create(String name, Settings settings) {
    Version indexVersion = Version.indexCreated(settings);
    if (!Version.CURRENT.equals(indexVersion)) {
        PreBuiltCharFilters preBuiltCharFilters = PreBuiltCharFilters.getOrDefault(name, null);
        if (preBuiltCharFilters != null) {
            return preBuiltCharFilters.getCharFilterFactory(indexVersion);
        }
    }

    return charFilterFactory;
}
 

@Override
public AnalyzerProvider create(String name, Settings settings) {
    Version indexVersion = Version.indexCreated(settings);
    if (!Version.CURRENT.equals(indexVersion)) {
        PreBuiltAnalyzers preBuiltAnalyzers = PreBuiltAnalyzers.getOrDefault(name, null);
        if (preBuiltAnalyzers != null) {
            Analyzer analyzer = preBuiltAnalyzers.getAnalyzer(indexVersion);
            return new PreBuiltAnalyzerProvider(name, AnalyzerScope.INDICES, analyzer);
        }
    }

    return analyzerProvider;
}
 

@Override
public TokenizerFactory create(String name, Settings settings) {
    Version indexVersion = Version.indexCreated(settings);
    if (!Version.CURRENT.equals(indexVersion)) {
        PreBuiltTokenizers preBuiltTokenizers = PreBuiltTokenizers.getOrDefault(name, null);
        if (preBuiltTokenizers != null) {
            return preBuiltTokenizers.getTokenizerFactory(indexVersion);
        }
    }

    return tokenizerFactory;
}
 

@Inject
public StandardHtmlStripAnalyzerProvider(Index index, IndexSettingsService indexSettingsService, Environment env,  @Assisted String name, @Assisted Settings settings) {
    super(index, indexSettingsService.getSettings(), name, settings);
    this.esVersion = Version.indexCreated(indexSettingsService.getSettings());
    final CharArraySet defaultStopwords;
    if (esVersion.onOrAfter(Version.V_1_0_0_RC1)) {
        defaultStopwords = CharArraySet.EMPTY_SET;
    } else {
        defaultStopwords = StopAnalyzer.ENGLISH_STOP_WORDS_SET;
    }
    CharArraySet stopWords = Analysis.parseStopWords(env, settings, defaultStopwords);
    analyzer = new StandardHtmlStripAnalyzer(stopWords);
    analyzer.setVersion(version);
}
 

public org.apache.lucene.util.Version minimumCompatibleVersion() {
    org.apache.lucene.util.Version luceneVersion = null;
    for (Segment segment : engine().segments(false)) {
        if (luceneVersion == null || luceneVersion.onOrAfter(segment.getVersion())) {
            luceneVersion = segment.getVersion();
        }
    }
    return luceneVersion == null ? Version.indexCreated(indexSettings).luceneVersion : luceneVersion;
}
 

public Version indexCreatedVersion() {
    return Version.indexCreated(indexSettings);
}
 

public QueryParseContext(Index index, IndexQueryParserService indexQueryParser) {
    this.index = index;
    this.indexVersionCreated = Version.indexCreated(indexQueryParser.indexSettings());
    this.indexQueryParser = indexQueryParser;
}
 

/**
 * @return The lowest node version in the cluster when the index was created or <code>null</code> if that was unknown
 */
public Version getIndexCreatedVersion() {
    return Version.indexCreated(indexSettingsService.getSettings());
}