Java Version.fromId方法代码示例

import org.elasticsearch.Version; //导入方法依赖的package包/类
public void testInitialSearchParamsSort() {
    SearchRequest searchRequest = new SearchRequest().source(new SearchSourceBuilder());

    // Test sort:_doc for versions that support it.
    Version remoteVersion = Version.fromId(between(Version.V_2_1_0_ID, Version.CURRENT.id));
    searchRequest.source().sort("_doc");
    assertThat(initialSearchParams(searchRequest, remoteVersion), hasEntry("sort", "_doc:asc"));

    // Test search_type scan for versions that don't support sort:_doc.
    remoteVersion = Version.fromId(between(0, Version.V_2_1_0_ID - 1));
    assertThat(initialSearchParams(searchRequest, remoteVersion), hasEntry("search_type", "scan"));

    // Test sorting by some field. Version doesn't matter.
    remoteVersion = Version.fromId(between(0, Version.CURRENT.id));
    searchRequest.source().sorts().clear();
    searchRequest.source().sort("foo");
    assertThat(initialSearchParams(searchRequest, remoteVersion), hasEntry("sort", "foo:asc"));
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public void testInitialSearchParamsMisc() {
    SearchRequest searchRequest = new SearchRequest().source(new SearchSourceBuilder());
    Version remoteVersion = Version.fromId(between(0, Version.CURRENT.id));

    TimeValue scroll = null;
    if (randomBoolean()) {
        scroll = TimeValue.parseTimeValue(randomPositiveTimeValue(), "test");
        searchRequest.scroll(scroll);
    }
    int size = between(0, Integer.MAX_VALUE);
    searchRequest.source().size(size);
    Boolean fetchVersion = null;
    if (randomBoolean()) {
        fetchVersion = randomBoolean();
        searchRequest.source().version(fetchVersion);
    }

    Map<String, String> params = initialSearchParams(searchRequest, remoteVersion);

    assertThat(params, scroll == null ? not(hasKey("scroll")) : hasEntry("scroll", scroll.toString()));
    assertThat(params, hasEntry("size", Integer.toString(size)));
    assertThat(params, fetchVersion == null || fetchVersion == true ? hasEntry("version", null) : not(hasEntry("version", null)));
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public void testWarnIfPreRelease() {
    final Logger logger = mock(Logger.class);

    final int id = randomIntBetween(1, 9) * 1000000;
    final Version releaseVersion = Version.fromId(id + 99);
    final Version preReleaseVersion = Version.fromId(id + randomIntBetween(0, 98));

    Node.warnIfPreRelease(releaseVersion, false, logger);
    verifyNoMoreInteractions(logger);

    reset(logger);
    Node.warnIfPreRelease(releaseVersion, true, logger);
    verify(logger).warn(
        "version [{}] is a pre-release version of Elasticsearch and is not suitable for production", releaseVersion + "-SNAPSHOT");

    reset(logger);
    final boolean isSnapshot = randomBoolean();
    Node.warnIfPreRelease(preReleaseVersion, isSnapshot, logger);
    verify(logger).warn(
        "version [{}] is a pre-release version of Elasticsearch and is not suitable for production",
        preReleaseVersion + (isSnapshot ? "-SNAPSHOT" : ""));

}
 

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包/类
/**
 * Returns a parsed version.
 */
public Version getAsVersion(String setting, Version defaultVersion) throws SettingsException {
    String sValue = get(setting);
    if (sValue == null) {
        return defaultVersion;
    }
    try {
        return Version.fromId(Integer.parseInt(sValue));
    } catch (Exception e) {
        throw new SettingsException("Failed to parse version setting [" + setting + "] with value [" + sValue + "]", e);
    }
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public Version getBWCVersion() {
    if (isEmpty()) {
        throw new IllegalStateException("no nodes available");
    }
    return Version.fromId(values().stream().map(node -> node.getVersion().id).min(Integer::compareTo).get());
}
 

import org.elasticsearch.Version; //导入方法依赖的package包/类
public static Snapshot fromXContent(XContentParser parser) throws IOException {
    String name = null;
    Version version = Version.CURRENT;
    SnapshotState state = SnapshotState.IN_PROGRESS;
    String reason = null;
    List<String> indices = Collections.emptyList();
    long startTime = 0;
    long endTime = 0;
    int totalShard = 0;
    int successfulShards = 0;
    List<SnapshotShardFailure> shardFailures = NO_FAILURES;
    if (parser.currentToken() == null) { // fresh parser? move to the first token
        parser.nextToken();
    }
    if (parser.currentToken() == XContentParser.Token.START_OBJECT) {  // on a start object move to next token
        parser.nextToken();
    }
    XContentParser.Token token;
    if ((token = parser.nextToken()) == XContentParser.Token.START_OBJECT) {
        String currentFieldName = parser.currentName();
        if ("snapshot".equals(currentFieldName)) {
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                    token = parser.nextToken();
                    if (token.isValue()) {
                        if ("name".equals(currentFieldName)) {
                            name = parser.text();
                        } else if ("state".equals(currentFieldName)) {
                            state = SnapshotState.valueOf(parser.text());
                        } else if ("reason".equals(currentFieldName)) {
                            reason = parser.text();
                        } else if ("start_time".equals(currentFieldName)) {
                            startTime = parser.longValue();
                        } else if ("end_time".equals(currentFieldName)) {
                            endTime = parser.longValue();
                        } else if ("total_shards".equals(currentFieldName)) {
                            totalShard = parser.intValue();
                        } else if ("successful_shards".equals(currentFieldName)) {
                            successfulShards = parser.intValue();
                        } else if ("version_id".equals(currentFieldName)) {
                            version = Version.fromId(parser.intValue());
                        }
                    } else if (token == XContentParser.Token.START_ARRAY) {
                        if ("indices".equals(currentFieldName)) {
                            ArrayList<String> indicesArray = new ArrayList<>();
                            while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                                indicesArray.add(parser.text());
                            }
                            indices = Collections.unmodifiableList(indicesArray);
                        } else if ("failures".equals(currentFieldName)) {
                            ArrayList<SnapshotShardFailure> shardFailureArrayList = new ArrayList<>();
                            while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
                                shardFailureArrayList.add(SnapshotShardFailure.fromXContent(parser));
                            }
                            shardFailures = Collections.unmodifiableList(shardFailureArrayList);
                        } else {
                            // It was probably created by newer version - ignoring
                            parser.skipChildren();
                        }
                    } else if (token == XContentParser.Token.START_OBJECT) {
                        // It was probably created by newer version - ignoring
                        parser.skipChildren();
                    }
                }
            }
        }
    } else {
        throw new ElasticsearchParseException("unexpected token  [" + token + "]");
    }
    return new Snapshot(name, indices, state, reason, version, startTime, endTime, totalShard, successfulShards, shardFailures);
}