Java Version类代码示例

import org.elasticsearch.Version; //导入依赖的package包/类
public void testClusterStateSerialization() throws Exception {
    MetaData metaData = MetaData.builder()
            .put(IndexMetaData.builder("test").settings(settings(Version.CURRENT)).numberOfShards(10).numberOfReplicas(1))
            .build();

    RoutingTable routingTable = RoutingTable.builder()
            .addAsNew(metaData.index("test"))
            .build();

    DiscoveryNodes nodes = DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")).localNodeId("node1").masterNodeId("node2").build();

    ClusterState clusterState = ClusterState.builder(new ClusterName("clusterName1")).nodes(nodes).metaData(metaData).routingTable(routingTable).build();

    AllocationService strategy = createAllocationService();
    clusterState = ClusterState.builder(clusterState).routingTable(strategy.reroute(clusterState, "reroute").routingTable()).build();

    ClusterState serializedClusterState = ClusterState.Builder.fromBytes(ClusterState.Builder.toBytes(clusterState), newNode("node1"),
        new NamedWriteableRegistry(ClusterModule.getNamedWriteables()));

    assertThat(serializedClusterState.getClusterName().value(), equalTo(clusterState.getClusterName().value()));

    assertThat(serializedClusterState.routingTable().toString(), equalTo(clusterState.routingTable().toString()));
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
@Override
protected void doWriteTo(StreamOutput out) throws IOException {
    out.writeString(field);
    out.writeString(documentType);
    out.writeOptionalString(indexedDocumentIndex);
    out.writeOptionalString(indexedDocumentType);
    out.writeOptionalString(indexedDocumentId);
    out.writeOptionalString(indexedDocumentRouting);
    out.writeOptionalString(indexedDocumentPreference);
    if (indexedDocumentVersion != null) {
        out.writeBoolean(true);
        out.writeVLong(indexedDocumentVersion);
    } else {
        out.writeBoolean(false);
    }
    out.writeOptionalBytesReference(document);
    if (document != null && out.getVersion().onOrAfter(Version.V_5_3_0_UNRELEASED)) {
        documentXContentType.writeTo(out);
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    super.readFrom(in);
    searchRequest = new SearchRequest();
    searchRequest.readFrom(in);
    abortOnVersionConflict = in.readBoolean();
    size = in.readVInt();
    refresh = in.readBoolean();
    timeout = new TimeValue(in);
    activeShardCount = ActiveShardCount.readFrom(in);
    retryBackoffInitialTime = new TimeValue(in);
    maxRetries = in.readVInt();
    requestsPerSecond = in.readFloat();
    if (in.getVersion().onOrAfter(Version.V_5_1_1_UNRELEASED)) {
        slices = in.readVInt();
    } else {
        slices = 1;
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
public void testBackwardsCompatibilityEdgeNgramTokenFilter() throws Exception {
    int iters = scaledRandomIntBetween(20, 100);
    for (int i = 0; i < iters; i++) {
        final Index index = new Index("test", "_na_");
        final String name = "ngr";
        Version v = randomVersion(random());
        Builder builder = newAnalysisSettingsBuilder().put("min_gram", 2).put("max_gram", 3);
        boolean reverse = random().nextBoolean();
        if (reverse) {
            builder.put("side", "back");
        }
        Settings settings = builder.build();
        Settings indexSettings = newAnalysisSettingsBuilder().put(IndexMetaData.SETTING_VERSION_CREATED, v.id).build();
        Tokenizer tokenizer = new MockTokenizer();
        tokenizer.setReader(new StringReader("foo bar"));
        TokenStream edgeNGramTokenFilter = new EdgeNGramTokenFilterFactory(IndexSettingsModule.newIndexSettings(index, indexSettings), null, name, settings).create(tokenizer);
        if (reverse) {
            assertThat(edgeNGramTokenFilter, instanceOf(ReverseStringFilter.class));
        } else {
            assertThat(edgeNGramTokenFilter, instanceOf(EdgeNGramTokenFilter.class));
        }
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
@Override
protected ShardUpgradeStatus shardOperation(UpgradeStatusRequest request, ShardRouting shardRouting) {
    IndexService indexService = indicesService.indexServiceSafe(shardRouting.shardId().getIndex());
    IndexShard indexShard = indexService.shardSafe(shardRouting.shardId().id());
    List<Segment> segments = indexShard.engine().segments(false);
    long total_bytes = 0;
    long to_upgrade_bytes = 0;
    long to_upgrade_bytes_ancient = 0;
    for (Segment seg : segments) {
        total_bytes += seg.sizeInBytes;
        if (seg.version.major != Version.CURRENT.luceneVersion.major) {
            to_upgrade_bytes_ancient += seg.sizeInBytes;
            to_upgrade_bytes += seg.sizeInBytes;
        } else if (seg.version.minor != Version.CURRENT.luceneVersion.minor) {
            // TODO: this comparison is bogus! it would cause us to upgrade even with the same format
            // instead, we should check if the codec has changed
            to_upgrade_bytes += seg.sizeInBytes;
        }
    }

    return new ShardUpgradeStatus(indexShard.routingEntry(), total_bytes, to_upgrade_bytes, to_upgrade_bytes_ancient);
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    if (out.getVersion().before(Version.V_6_0_0_alpha1_UNRELEASED)) {
        // legacy version
        out.writeLong(-1L);
    }
    out.writeOptionalString(allocationId);
    out.writeBoolean(primary);
    if (storeException != null) {
        out.writeBoolean(true);
        out.writeException(storeException);
    } else {
        out.writeBoolean(false);
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
List<ClusterState> randomStates(int count, String... masters) {
    ArrayList<ClusterState> states = new ArrayList<>(count);
    ClusterState[] lastClusterStatePerMaster = new ClusterState[masters.length];
    for (; count > 0; count--) {
        int masterIndex = randomInt(masters.length - 1);
        ClusterState state = lastClusterStatePerMaster[masterIndex];
        if (state == null) {
            state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY)).nodes(DiscoveryNodes.builder()
                            .add(new DiscoveryNode(masters[masterIndex], buildNewFakeTransportAddress(),
                                    emptyMap(), emptySet(),Version.CURRENT)).masterNodeId(masters[masterIndex]).build()
            ).build();
        } else {
            state = ClusterState.builder(state).incrementVersion().build();
        }
        states.add(state);
        lastClusterStatePerMaster[masterIndex] = state;
    }
    return states;
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
/**
 * Read from a stream.
 */
public FsInfo(StreamInput in) throws IOException {
    timestamp = in.readVLong();
    ioStats = in.readOptionalWriteable(IoStats::new);
    paths = new Path[in.readVInt()];
    for (int i = 0; i < paths.length; i++) {
        paths[i] = new Path(in);
    }
    this.total = total();
    if (in.getVersion().onOrAfter(Version.V_6_0_0_alpha1_UNRELEASED)) {
        this.leastDiskEstimate = in.readOptionalWriteable(DiskUsage::new);
        this.mostDiskEstimate = in.readOptionalWriteable(DiskUsage::new);
    } else {
        this.leastDiskEstimate = null;
        this.mostDiskEstimate = null;
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
public void testShardActiveDuringInternalRecovery() throws IOException {
    IndexShard shard = newStartedShard(true);
    indexDoc(shard, "type", "0");
    shard = reinitShard(shard);
    DiscoveryNode localNode = new DiscoveryNode("foo", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
    shard.markAsRecovering("for testing", new RecoveryState(shard.routingEntry(), localNode, null));
    // Shard is still inactive since we haven't started recovering yet
    assertFalse(shard.isActive());
    shard.prepareForIndexRecovery();
    // Shard is still inactive since we haven't started recovering yet
    assertFalse(shard.isActive());
    shard.performTranslogRecovery(true);
    // Shard should now be active since we did recover:
    assertTrue(shard.isActive());
    closeShards(shard);
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
private static TestAnalysis createTestAnalysis() throws IOException {
    InputStream empty_dict = KuromojiAnalysisTests.class.getResourceAsStream("empty_user_dict.txt");
    InputStream dict = KuromojiAnalysisTests.class.getResourceAsStream("user_dict.txt");
    Path home = createTempDir();
    Path config = home.resolve("config");
    Files.createDirectory(config);
    Files.copy(empty_dict, config.resolve("empty_user_dict.txt"));
    Files.copy(dict, config.resolve("user_dict.txt"));
    String json = "/org/elasticsearch/index/analysis/kuromoji_analysis.json";

    Settings settings = Settings.builder()
        .loadFromStream(json, KuromojiAnalysisTests.class.getResourceAsStream(json))
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT)
        .build();
    Settings nodeSettings = Settings.builder().put(Environment.PATH_HOME_SETTING.getKey(), home).build();
    return createTestAnalysis(new Index("test", "_na_"), nodeSettings, settings, new AnalysisKuromojiPlugin());
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
/**
 * Throws an IAE if a pre 0.19 state is detected
 */
private void ensureNoPre019State() throws Exception {
    for (Path dataLocation : nodeEnv.nodeDataPaths()) {
        final Path stateLocation = dataLocation.resolve(MetaDataStateFormat.STATE_DIR_NAME);
        if (!Files.exists(stateLocation)) {
            continue;
        }
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(stateLocation)) {
            for (Path stateFile : stream) {
                if (logger.isTraceEnabled()) {
                    logger.trace("[upgrade]: processing [" + stateFile.getFileName() + "]");
                }
                final String name = stateFile.getFileName().toString();
                if (name.startsWith("metadata-")) {
                    throw new IllegalStateException("Detected pre 0.19 metadata file please upgrade to a version before "
                            + Version.CURRENT.minimumCompatibilityVersion()
                            + " first to upgrade state structures - metadata found: [" + stateFile.getParent().toAbsolutePath());
                }
            }
        }
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
public void testUpgradeIndices() throws IOException {
    final Settings nodeSettings = Settings.builder()
        .put(NodeEnvironment.ADD_NODE_LOCK_ID_TO_CUSTOM_PATH.getKey(), randomBoolean()).build();
    try (NodeEnvironment nodeEnv = newNodeEnvironment(nodeSettings)) {
        Map<IndexSettings, Tuple<Integer, Integer>>  indexSettingsMap = new HashMap<>();
        for (int i = 0; i < randomIntBetween(2, 5); i++) {
            final Index index = new Index(randomAsciiOfLength(10), UUIDs.randomBase64UUID());
            Settings settings = Settings.builder()
                .put(nodeSettings)
                .put(IndexMetaData.SETTING_INDEX_UUID, index.getUUID())
                .put(IndexMetaData.SETTING_VERSION_CREATED, Version.V_2_0_0)
                .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, randomIntBetween(1, 5))
                .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)
                .build();
            IndexMetaData indexState = IndexMetaData.builder(index.getName()).settings(settings).build();
            Tuple<Integer, Integer> fileCounts = new Tuple<>(randomIntBetween(1, 5), randomIntBetween(1, 5));
            IndexSettings indexSettings = new IndexSettings(indexState, nodeSettings);
            indexSettingsMap.put(indexSettings, fileCounts);
            writeIndex(nodeEnv, indexSettings, fileCounts.v1(), fileCounts.v2());
        }
        IndexFolderUpgrader.upgradeIndicesIfNeeded(nodeSettings, nodeEnv);
        for (Map.Entry<IndexSettings, Tuple<Integer, Integer>> entry : indexSettingsMap.entrySet()) {
            checkIndex(nodeEnv, entry.getKey(), entry.getValue().v1(), entry.getValue().v2());
        }
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
public void testSerialization() throws Exception {
    int iterations = randomIntBetween(5, 20);
    for (int i = 0; i < iterations; i++) {

        IndicesOptions indicesOptions = IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean());
        ClusterStateRequest clusterStateRequest = new ClusterStateRequest().routingTable(randomBoolean()).metaData(randomBoolean())
                .nodes(randomBoolean()).blocks(randomBoolean()).indices("testindex", "testindex2").indicesOptions(indicesOptions);

        Version testVersion = VersionUtils.randomVersionBetween(random(), Version.CURRENT.minimumCompatibilityVersion(), Version.CURRENT);
        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(testVersion);
        clusterStateRequest.writeTo(output);

        StreamInput streamInput = output.bytes().streamInput();
        streamInput.setVersion(testVersion);
        ClusterStateRequest deserializedCSRequest = new ClusterStateRequest();
        deserializedCSRequest.readFrom(streamInput);

        assertThat(deserializedCSRequest.routingTable(), equalTo(clusterStateRequest.routingTable()));
        assertThat(deserializedCSRequest.metaData(), equalTo(clusterStateRequest.metaData()));
        assertThat(deserializedCSRequest.nodes(), equalTo(clusterStateRequest.nodes()));
        assertThat(deserializedCSRequest.blocks(), equalTo(clusterStateRequest.blocks()));
        assertThat(deserializedCSRequest.indices(), equalTo(clusterStateRequest.indices()));
        assertOptionsMatch(deserializedCSRequest.indicesOptions(), clusterStateRequest.indicesOptions());
    }
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    indexCount = in.readVLong();
    indexTimeInMillis = in.readVLong();
    indexCurrent = in.readVLong();

    if(in.getVersion().onOrAfter(Version.V_2_1_0)){
        indexFailedCount = in.readVLong();
    }

    deleteCount = in.readVLong();
    deleteTimeInMillis = in.readVLong();
    deleteCurrent = in.readVLong();
    noopUpdateCount = in.readVLong();
    isThrottled = in.readBoolean();
    throttleTimeInMillis = in.readLong();
}
 

import org.elasticsearch.Version; //导入依赖的package包/类
void handlePost(final RestRequest request, RestChannel channel, Client client) {
    UpgradeRequest upgradeReq = new UpgradeRequest(Strings.splitStringByCommaToArray(request.param("index")));
    upgradeReq.upgradeOnlyAncientSegments(request.paramAsBoolean("only_ancient_segments", false));
    client.admin().indices().upgrade(upgradeReq, new RestBuilderListener<UpgradeResponse>(channel) {
        @Override
        public RestResponse buildResponse(UpgradeResponse response, XContentBuilder builder) throws Exception {
            builder.startObject();
            buildBroadcastShardsHeader(builder, request, response);
            builder.startObject("upgraded_indices");
            for (Map.Entry<String, Tuple<Version, String>> entry : response.versions().entrySet()) {
                builder.startObject(entry.getKey(), XContentBuilder.FieldCaseConversion.NONE);
                builder.field("upgrade_version", entry.getValue().v1());
                builder.field("oldest_lucene_segment_version", entry.getValue().v2());
                builder.endObject();
            }
            builder.endObject();
            builder.endObject();
            return new BytesRestResponse(OK, builder);
        }
    });
}