Java Version.onOrAfter方法代码示例

import org.elasticsearch.Version; //导入方法依赖的package包/类
private void assertRequestEquals(Version version, ReindexRequest request, ReindexRequest tripped) {
    assertRequestEquals((AbstractBulkIndexByScrollRequest<?>) request, (AbstractBulkIndexByScrollRequest<?>) tripped);
    assertEquals(request.getDestination().version(), tripped.getDestination().version());
    assertEquals(request.getDestination().index(), tripped.getDestination().index());
    if (request.getRemoteInfo() == null) {
        assertNull(tripped.getRemoteInfo());
    } else {
        assertNotNull(tripped.getRemoteInfo());
        assertEquals(request.getRemoteInfo().getScheme(), tripped.getRemoteInfo().getScheme());
        assertEquals(request.getRemoteInfo().getHost(), tripped.getRemoteInfo().getHost());
        assertEquals(request.getRemoteInfo().getQuery(), tripped.getRemoteInfo().getQuery());
        assertEquals(request.getRemoteInfo().getUsername(), tripped.getRemoteInfo().getUsername());
        assertEquals(request.getRemoteInfo().getPassword(), tripped.getRemoteInfo().getPassword());
        assertEquals(request.getRemoteInfo().getHeaders(), tripped.getRemoteInfo().getHeaders());
        if (version.onOrAfter(Version.V_5_2_0_UNRELEASED)) {
            assertEquals(request.getRemoteInfo().getSocketTimeout(), tripped.getRemoteInfo().getSocketTimeout());
            assertEquals(request.getRemoteInfo().getConnectTimeout(), tripped.getRemoteInfo().getConnectTimeout());
        } else {
            assertEquals(RemoteInfo.DEFAULT_SOCKET_TIMEOUT, tripped.getRemoteInfo().getSocketTimeout());
            assertEquals(RemoteInfo.DEFAULT_CONNECT_TIMEOUT, tripped.getRemoteInfo().getConnectTimeout());
        }
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
private static Version readVersionsFromInfo(RestClient restClient, int numHosts) throws IOException {
    Version version = null;
    for (int i = 0; i < numHosts; i++) {
        //we don't really use the urls here, we rely on the client doing round-robin to touch all the nodes in the cluster
        Response response = restClient.performRequest("GET", "/");
        ClientYamlTestResponse restTestResponse = new ClientYamlTestResponse(response);
        Object latestVersion = restTestResponse.evaluate("version.number");
        if (latestVersion == null) {
            throw new RuntimeException("elasticsearch version not found in the response");
        }
        final Version currentVersion = Version.fromString(latestVersion.toString());
        if (version == null) {
            version = currentVersion;
        } else if (version.onOrAfter(currentVersion)) {
            version = currentVersion;
        }
    }
    return version;
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
void assertBasicSearchWorks(String indexName) {
    logger.info("--> testing basic search");
    SearchRequestBuilder searchReq = client().prepareSearch(indexName).setQuery(QueryBuilders.matchAllQuery());
    SearchResponse searchRsp = searchReq.get();
    ElasticsearchAssertions.assertNoFailures(searchRsp);
    long numDocs = searchRsp.getHits().getTotalHits();
    logger.info("Found {} in old index", numDocs);

    logger.info("--> testing basic search with sort");
    searchReq.addSort("long_sort", SortOrder.ASC);
    ElasticsearchAssertions.assertNoFailures(searchReq.get());

    logger.info("--> testing exists filter");
    searchReq = client().prepareSearch(indexName).setQuery(QueryBuilders.existsQuery("string"));
    searchRsp = searchReq.get();
    ElasticsearchAssertions.assertNoFailures(searchRsp);
    assertEquals(numDocs, searchRsp.getHits().getTotalHits());
    GetSettingsResponse getSettingsResponse = client().admin().indices().prepareGetSettings(indexName).get();
    Version versionCreated = Version.fromId(Integer.parseInt(getSettingsResponse.getSetting(indexName, "index.version.created")));
    if (versionCreated.onOrAfter(Version.V_2_4_0)) {
        searchReq = client().prepareSearch(indexName).setQuery(QueryBuilders.existsQuery("field.with.dots"));
        searchRsp = searchReq.get();
        ElasticsearchAssertions.assertNoFailures(searchRsp);
        assertEquals(numDocs, searchRsp.getHits().getTotalHits());
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
private MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMapping) {
    if (fieldMapping != null || allowUnmappedFields) {
        return fieldMapping;
    } else if (mapUnmappedFieldAsString){
        StringFieldMapper.Builder builder = MapperBuilders.stringField(name);
        // it would be better to pass the real index settings, but they are not easily accessible from here...
        Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, indexQueryParser.getIndexCreatedVersion()).build();
        return builder.build(new Mapper.BuilderContext(settings, new ContentPath(1))).fieldType();
    } else {
        Version indexCreatedVersion = indexQueryParser.getIndexCreatedVersion();
        if (fieldMapping == null && indexCreatedVersion.onOrAfter(Version.V_1_4_0_Beta1)) {
            throw new QueryParsingException(this, "Strict field resolution and no field mapping can be found for the field with name ["
                    + name + "]");
        } else {
            return fieldMapping;
        }
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
@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);
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
@SuppressForbidden(reason = "Math#abs is trappy")
private int generateShardId(ClusterState clusterState, String index, String type, String id, @Nullable String routing) {
    IndexMetaData indexMetaData = clusterState.metaData().index(index);
    if (indexMetaData == null) {
        throw new IndexNotFoundException(index);
    }
    final Version createdVersion = indexMetaData.getCreationVersion();
    final HashFunction hashFunction = indexMetaData.getRoutingHashFunction();
    final boolean useType = indexMetaData.getRoutingUseType();

    final int hash;
    if (routing == null) {
        if (!useType) {
            hash = hash(hashFunction, id);
        } else {
            hash = hash(hashFunction, type, id);
        }
    } else {
        hash = hash(hashFunction, routing);
    }
    if (createdVersion.onOrAfter(Version.V_2_0_0_beta1)) {
        return MathUtils.mod(hash, indexMetaData.getNumberOfShards());
    } else {
        return Math.abs(hash % indexMetaData.getNumberOfShards());
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public static String parseStringTimestamp(String timestampAsString, FormatDateTimeFormatter dateTimeFormatter,
                                          Version version) throws TimestampParsingException {
    try {
        // no need for unix timestamp parsing in 2.x
        FormatDateTimeFormatter formatter = version.onOrAfter(Version.V_2_0_0_beta1) ? dateTimeFormatter : EPOCH_MILLIS_PARSER;
        return Long.toString(formatter.parser().parseMillis(timestampAsString));
    } catch (RuntimeException e) {
        if (version.before(Version.V_2_0_0_beta1)) {
            try {
                return Long.toString(dateTimeFormatter.parser().parseMillis(timestampAsString));
            } catch (RuntimeException e1) {
                throw new TimestampParsingException(timestampAsString, e1);
            }
        }
        throw new TimestampParsingException(timestampAsString, e);
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
@Override
protected Query doToQuery(QueryShardContext shardContext) throws IOException {
    MappedFieldType fieldType = shardContext.fieldMapper(fieldName);
    if (fieldType == null) {
        if (ignoreUnmapped) {
            return new MatchNoDocsQuery();
        } else {
            throw new QueryShardException(shardContext, "failed to find geo_point field [" + fieldName + "]");
        }
    }

    if (!(fieldType instanceof GeoPointFieldType)) {
        throw new QueryShardException(shardContext, "field [" + fieldName + "] is not a geo_point field");
    }

    final Version indexVersionCreated = shardContext.indexVersionCreated();
    QueryValidationException exception = checkLatLon(shardContext.indexVersionCreated().before(Version.V_2_0_0));
    if (exception != null) {
        throw new QueryShardException(shardContext, "couldn't validate latitude/ longitude values", exception);
    }

    if (indexVersionCreated.onOrAfter(Version.V_2_2_0) || GeoValidationMethod.isCoerce(validationMethod)) {
        GeoUtils.normalizePoint(center, true, true);
    }

    Query query = LatLonPoint.newDistanceQuery(fieldType.name(), center.lat(), center.lon(), this.distance);
    if (fieldType.hasDocValues()) {
        Query dvQuery = LatLonDocValuesField.newDistanceQuery(fieldType.name(), center.lat(), center.lon(), this.distance);
        query = new IndexOrDocValuesQuery(query, dvQuery);
    }
    return query;
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
protected boolean defaultDocValues(Version indexCreated) {
    if (indexCreated.onOrAfter(Version.V_5_0_0_alpha1)) {
        // add doc values by default to keyword (boolean, numerics, etc.) fields
        return fieldType.tokenized() == false;
    } else {
        return fieldType.tokenized() == false && fieldType.indexOptions() != IndexOptions.NONE;
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public void testSerialization() throws Exception {
    final Version targetNodeVersion = randomVersion(random());
    final StartRecoveryRequest outRequest = new StartRecoveryRequest(
            new ShardId("test", "_na_", 0),
            new DiscoveryNode("a", buildNewFakeTransportAddress(), emptyMap(), emptySet(), targetNodeVersion),
            new DiscoveryNode("b", buildNewFakeTransportAddress(), emptyMap(), emptySet(), targetNodeVersion),
            Store.MetadataSnapshot.EMPTY,
            randomBoolean(),
            randomNonNegativeLong(),
            randomBoolean() ? SequenceNumbersService.UNASSIGNED_SEQ_NO : randomNonNegativeLong());

    final ByteArrayOutputStream outBuffer = new ByteArrayOutputStream();
    final OutputStreamStreamOutput out = new OutputStreamStreamOutput(outBuffer);
    out.setVersion(targetNodeVersion);
    outRequest.writeTo(out);

    final ByteArrayInputStream inBuffer = new ByteArrayInputStream(outBuffer.toByteArray());
    InputStreamStreamInput in = new InputStreamStreamInput(inBuffer);
    in.setVersion(targetNodeVersion);
    final StartRecoveryRequest inRequest = new StartRecoveryRequest();
    inRequest.readFrom(in);

    assertThat(outRequest.shardId(), equalTo(inRequest.shardId()));
    assertThat(outRequest.sourceNode(), equalTo(inRequest.sourceNode()));
    assertThat(outRequest.targetNode(), equalTo(inRequest.targetNode()));
    assertThat(outRequest.metadataSnapshot().asMap(), equalTo(inRequest.metadataSnapshot().asMap()));
    assertThat(outRequest.isPrimaryRelocation(), equalTo(inRequest.isPrimaryRelocation()));
    assertThat(outRequest.recoveryId(), equalTo(inRequest.recoveryId()));
    if (targetNodeVersion.onOrAfter(Version.V_6_0_0_alpha1_UNRELEASED)) {
        assertThat(outRequest.startingSeqNo(), equalTo(inRequest.startingSeqNo()));
    } else {
        assertThat(SequenceNumbersService.UNASSIGNED_SEQ_NO, equalTo(inRequest.startingSeqNo()));
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
/**
 * Search on an alias that contains illegal characters that would prevent it from being created after 5.1.0. It should still be
 * search-able though.
 */
void assertAliasWithBadName(String indexName, Version version) throws Exception {
    if (version.onOrAfter(VERSION_5_1_0_UNRELEASED)) {
        return;
    }
    // We can read from the alias just like we can read from the index.
    String aliasName = "#" + indexName;
    long totalDocs = client().prepareSearch(indexName).setSize(0).get().getHits().getTotalHits();
    assertHitCount(client().prepareSearch(aliasName).setSize(0).get(), totalDocs);
    assertThat(totalDocs, greaterThanOrEqualTo(2000L));

    // We can remove the alias.
    assertAcked(client().admin().indices().prepareAliases().removeAlias(indexName, aliasName).get());
    assertFalse(client().admin().indices().prepareAliasesExist(aliasName).get().exists());
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public void testBackwardCompatibility() throws Exception {
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(RoutingBackwardCompatibilityTests.class
        .getResourceAsStream("/org/elasticsearch/cluster/routing/shard_routes.txt"), "UTF-8"))) {
        for (String line = reader.readLine(); line != null; line = reader.readLine()) {
            if (line.startsWith("#")) { // comment
                continue;
            }
            String[] parts = line.split("\t");
            assertEquals(Arrays.toString(parts), 7, parts.length);
            final String index = parts[0];
            final int numberOfShards = Integer.parseInt(parts[1]);
            final String type = parts[2];
            final String id = parts[3];
            final String routing = "null".equals(parts[4]) ? null : parts[4];
            final int pre20ExpectedShardId = Integer.parseInt(parts[5]); // not needed anymore - old hashing is gone
            final int currentExpectedShard = Integer.parseInt(parts[6]);

            OperationRouting operationRouting = new OperationRouting(Settings.EMPTY, new ClusterSettings(Settings.EMPTY,
                ClusterSettings.BUILT_IN_CLUSTER_SETTINGS));
            for (Version version : VersionUtils.allReleasedVersions()) {
                if (version.onOrAfter(Version.V_2_0_0) == false) {
                    // unsupported version, no need to test
                    continue;
                }
                final Settings settings = settings(version).build();
                IndexMetaData indexMetaData = IndexMetaData.builder(index).settings(settings).numberOfShards(numberOfShards)
                    .numberOfReplicas(randomInt(3)).build();
                MetaData.Builder metaData = MetaData.builder().put(indexMetaData, false);
                RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetaData).build();
                ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
                    .metaData(metaData).routingTable(routingTable).build();
                final int shardId = operationRouting.indexShards(clusterState, index, id, routing).shardId().getId();
                assertEquals(currentExpectedShard, shardId);
            }
        }
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
/**
 * Assert that two task statuses are equal after serialization.
 * @param version the version at which expected was serialized
 */
public static void assertTaskStatusEquals(Version version, BulkByScrollTask.Status expected, BulkByScrollTask.Status actual) {
    assertEquals(expected.getTotal(), actual.getTotal());
    assertEquals(expected.getUpdated(), actual.getUpdated());
    assertEquals(expected.getCreated(), actual.getCreated());
    assertEquals(expected.getDeleted(), actual.getDeleted());
    assertEquals(expected.getBatches(), actual.getBatches());
    assertEquals(expected.getVersionConflicts(), actual.getVersionConflicts());
    assertEquals(expected.getNoops(), actual.getNoops());
    assertEquals(expected.getBulkRetries(), actual.getBulkRetries());
    assertEquals(expected.getSearchRetries(), actual.getSearchRetries());
    assertEquals(expected.getThrottled(), actual.getThrottled());
    assertEquals(expected.getRequestsPerSecond(), actual.getRequestsPerSecond(), 0f);
    assertEquals(expected.getReasonCancelled(), actual.getReasonCancelled());
    assertEquals(expected.getThrottledUntil(), actual.getThrottledUntil());
    if (version.onOrAfter(Version.V_5_1_1_UNRELEASED)) {
        assertThat(actual.getSliceStatuses(), hasSize(expected.getSliceStatuses().size()));
        for (int i = 0; i < expected.getSliceStatuses().size(); i++) {
            BulkByScrollTask.StatusOrException sliceStatus = expected.getSliceStatuses().get(i);
            if (sliceStatus == null) {
                assertNull(actual.getSliceStatuses().get(i));
            } else if (sliceStatus.getException() == null) {
                assertNull(actual.getSliceStatuses().get(i).getException());
                assertTaskStatusEquals(version, sliceStatus.getStatus(), actual.getSliceStatuses().get(i).getStatus());
            } else {
                assertNull(actual.getSliceStatuses().get(i).getStatus());
                // Just check the message because we're not testing exception serialization in general here.
                assertEquals(sliceStatus.getException().getMessage(), actual.getSliceStatuses().get(i).getException().getMessage());
            }
        }
    } else {
        assertEquals(emptyList(), actual.getSliceStatuses());
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public static void checkNoRemainingFields(Map<String, Object> fieldNodeMap, Version indexVersionCreated, String message) {
    if (!fieldNodeMap.isEmpty()) {
        if (indexVersionCreated.onOrAfter(Version.V_2_0_0_beta1)) {
            throw new MapperParsingException(message + getRemainingFields(fieldNodeMap));
        } else {
            logger.debug(message + "{}", getRemainingFields(fieldNodeMap));
        }
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
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;
    }
}