Java StreamInput.setVersion方法代码示例

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
public void testDiscoveryNodeSerializationToOldVersion() throws Exception {
    InetAddress inetAddress = InetAddress.getByAddress("name1", new byte[] { (byte) 192, (byte) 168, (byte) 0, (byte) 1});
    TransportAddress transportAddress = new TransportAddress(inetAddress, randomIntBetween(0, 65535));
    DiscoveryNode node = new DiscoveryNode("name1", "id1", transportAddress, emptyMap(), emptySet(), Version.CURRENT);

    BytesStreamOutput streamOutput = new BytesStreamOutput();
    streamOutput.setVersion(Version.V_5_0_0);
    node.writeTo(streamOutput);

    StreamInput in = StreamInput.wrap(streamOutput.bytes().toBytesRef().bytes);
    in.setVersion(Version.V_5_0_0);
    DiscoveryNode serialized = new DiscoveryNode(in);
    assertEquals(transportAddress.address().getHostString(), serialized.getHostName());
    assertEquals(transportAddress.address().getHostString(), serialized.getAddress().address().getHostString());
    assertEquals(transportAddress.getAddress(), serialized.getHostAddress());
    assertEquals(transportAddress.getAddress(), serialized.getAddress().getAddress());
    assertEquals(transportAddress.getPort(), serialized.getAddress().getPort());
    assertFalse("if the minimum compatibility version moves past 5.0.3, remove the special casing in DiscoverNode(StreamInput) and " +
            "the TransportAddress(StreamInput, String) constructor",
        Version.CURRENT.minimumCompatibilityVersion().onOrAfter(Version.V_5_0_3_UNRELEASED));
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的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.common.io.stream.StreamInput; //导入方法依赖的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(), randomBoolean(), randomBoolean());

        BytesStreamOutput output = new BytesStreamOutput();
        Version outputVersion = randomVersion(random());
        output.setVersion(outputVersion);
        indicesOptions.writeIndicesOptions(output);

        StreamInput streamInput = output.bytes().streamInput();
        streamInput.setVersion(randomVersion(random()));
        IndicesOptions indicesOptions2 = IndicesOptions.readIndicesOptions(streamInput);

        assertThat(indicesOptions2.ignoreUnavailable(), equalTo(indicesOptions.ignoreUnavailable()));
        assertThat(indicesOptions2.allowNoIndices(), equalTo(indicesOptions.allowNoIndices()));
        assertThat(indicesOptions2.expandWildcardsOpen(), equalTo(indicesOptions.expandWildcardsOpen()));
        assertThat(indicesOptions2.expandWildcardsClosed(), equalTo(indicesOptions.expandWildcardsClosed()));

        assertThat(indicesOptions2.forbidClosedIndices(), equalTo(indicesOptions.forbidClosedIndices()));
        assertThat(indicesOptions2.allowAliasesToMultipleIndices(), equalTo(indicesOptions.allowAliasesToMultipleIndices()));
    }
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
public void testOriginalIndicesSerialization() throws IOException {
    int iterations = iterations(10, 30);
    for (int i = 0; i < iterations; i++) {
        OriginalIndices originalIndices = randomOriginalIndices();

        BytesStreamOutput out = new BytesStreamOutput();
        out.setVersion(randomVersion(random()));
        OriginalIndices.writeOriginalIndices(originalIndices, out);

        StreamInput in = out.bytes().streamInput();
        in.setVersion(out.getVersion());
        OriginalIndices originalIndices2 = OriginalIndices.readOriginalIndices(in);

        assertThat(originalIndices2.indices(), equalTo(originalIndices.indices()));
        assertThat(originalIndices2.indicesOptions(), equalTo(originalIndices.indicesOptions()));
    }
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
private void roundTrip(Version version, Streamable example, Streamable empty) throws IOException {
    BytesStreamOutput out = new BytesStreamOutput();
    out.setVersion(version);
    example.writeTo(out);
    StreamInput in = out.bytes().streamInput();
    in.setVersion(version);
    empty.readFrom(in);
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
private void assertSerialization(FieldStats stats, Version version) throws IOException {
    BytesStreamOutput output = new BytesStreamOutput();
    output.setVersion(version);
    stats.writeTo(output);
    output.flush();
    StreamInput input = output.bytes().streamInput();
    input.setVersion(version);
    FieldStats deserializedStats = FieldStats.readFrom(input);
    assertEquals(stats, deserializedStats);
    assertEquals(stats.hashCode(), deserializedStats.hashCode());
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
private <T extends Exception> T serialize(T exception, Version version) throws IOException {
    ElasticsearchAssertions.assertVersionSerializable(version, exception);
    BytesStreamOutput out = new BytesStreamOutput();
    out.setVersion(version);
    out.writeException(exception);

    StreamInput in = out.bytes().streamInput();
    in.setVersion(version);
    return in.readException();
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
public void testSerialization() throws Exception {
    int iterations = randomIntBetween(10, 100);
    for (int i = 0; i < iterations; i++) {
        // Get a random version
        Version version = randomVersion(random());

        // Get a random list of ClusterBlockLevels
        EnumSet<ClusterBlockLevel> levels = EnumSet.noneOf(ClusterBlockLevel.class);
        int nbLevels = randomIntBetween(1, ClusterBlockLevel.values().length);
        for (int j = 0; j < nbLevels; j++) {
            levels.add(randomFrom(ClusterBlockLevel.values()));
        }

        ClusterBlock clusterBlock = new ClusterBlock(randomInt(), "cluster block #" + randomInt(), randomBoolean(),
                randomBoolean(), randomFrom(RestStatus.values()), levels);

        BytesStreamOutput out = new BytesStreamOutput();
        out.setVersion(version);
        clusterBlock.writeTo(out);

        StreamInput in = out.bytes().streamInput();
        in.setVersion(version);
        ClusterBlock result = ClusterBlock.readClusterBlock(in);

        assertThat(result.id(), equalTo(clusterBlock.id()));
        assertThat(result.status(), equalTo(clusterBlock.status()));
        assertThat(result.description(), equalTo(clusterBlock.description()));
        assertThat(result.retryable(), equalTo(clusterBlock.retryable()));
        assertThat(result.disableStatePersistence(), equalTo(clusterBlock.disableStatePersistence()));
        assertArrayEquals(result.levels().toArray(), clusterBlock.levels().toArray());
    }
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
public void testGetIndexedScriptRequestSerialization() throws IOException {
    GetStoredScriptRequest request = new GetStoredScriptRequest("lang", "id");

    BytesStreamOutput out = new BytesStreamOutput();
    out.setVersion(randomVersion(random()));
    request.writeTo(out);

    StreamInput in = out.bytes().streamInput();
    in.setVersion(out.getVersion());
    GetStoredScriptRequest request2 = new GetStoredScriptRequest();
    request2.readFrom(in);

    assertThat(request2.id(), equalTo(request.id()));
    assertThat(request2.lang(), equalTo(request.lang()));
}
 

import org.elasticsearch.common.io.stream.StreamInput; //导入方法依赖的package包/类
public void testFieldStatsBWC() throws Exception {
    int size = randomIntBetween(5, 20);
    Map<String, FieldStats<?> > stats = new HashMap<> ();
    for (int i = 0; i < size; i++) {
        stats.put(Integer.toString(i), FieldStatsTests.randomFieldStats(true));
    }

    FieldStatsShardResponse response = new FieldStatsShardResponse(new ShardId("test", "test", 0), stats);
    for (int i = 0; i < 10; i++) {
        Version version = VersionUtils.randomVersionBetween(random(), Version.V_5_0_0, Version.CURRENT);
        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(version);
        response.writeTo(output);
        output.flush();
        StreamInput input = output.bytes().streamInput();
        input.setVersion(version);
        FieldStatsShardResponse deserialized = new FieldStatsShardResponse();
        deserialized.readFrom(input);
        final Map<String, FieldStats<?>> expected;
        if (version.before(Version.V_5_2_0_UNRELEASED)) {
            expected = deserialized.filterNullMinMax();
        } else {
            expected = deserialized.getFieldStats();
        }
        assertEquals(expected.size(), deserialized.getFieldStats().size());
        assertThat(expected, equalTo(deserialized.getFieldStats()));
    }
}