Java BytesStreamOutput类代码示例

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testCompareParsingTokens() throws IOException {
    BytesStreamOutput xsonOs = new BytesStreamOutput();
    XContentGenerator xsonGen = XContentFactory.xContent(XContentType.CBOR).createGenerator(xsonOs);

    BytesStreamOutput jsonOs = new BytesStreamOutput();
    XContentGenerator jsonGen = XContentFactory.xContent(XContentType.JSON).createGenerator(jsonOs);

    xsonGen.writeStartObject();
    jsonGen.writeStartObject();

    xsonGen.writeStringField("test", "value");
    jsonGen.writeStringField("test", "value");

    xsonGen.writeFieldName("arr");
    xsonGen.writeStartArray();
    jsonGen.writeFieldName("arr");
    jsonGen.writeStartArray();
    xsonGen.writeNumber(1);
    jsonGen.writeNumber(1);
    xsonGen.writeNull();
    jsonGen.writeNull();
    xsonGen.writeEndArray();
    jsonGen.writeEndArray();

    xsonGen.writeEndObject();
    jsonGen.writeEndObject();

    xsonGen.close();
    jsonGen.close();

    verifySameTokens(createParser(JsonXContent.jsonXContent, jsonOs.bytes()), createParser(CborXContent.cborXContent, xsonOs.bytes()));
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testSerializationBwc() throws IOException {
    final byte[] data = Base64.getDecoder().decode("ADwDAANmb28APAMBB215X3R5cGULeyJ0eXBlIjp7fX0AAAD////+AA==");
    final Version version = randomFrom(Version.V_5_0_0, Version.V_5_0_1, Version.V_5_0_2,
        Version.V_5_0_3_UNRELEASED, Version.V_5_1_1_UNRELEASED, Version.V_5_1_2_UNRELEASED, Version.V_5_2_0_UNRELEASED);
    try (StreamInput in = StreamInput.wrap(data)) {
        in.setVersion(version);
        CreateIndexRequest serialized = new CreateIndexRequest();
        serialized.readFrom(in);
        assertEquals("foo", serialized.index());
        BytesReference bytesReference = JsonXContent.contentBuilder().startObject().startObject("type").endObject().endObject().bytes();
        assertEquals(bytesReference.utf8ToString(), serialized.mappings().get("my_type"));

        try (BytesStreamOutput out = new BytesStreamOutput()) {
            out.setVersion(version);
            serialized.writeTo(out);
            out.flush();
            assertArrayEquals(data, out.bytes().toBytesRef().bytes);
        }
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
@Override
public Object run() {
    final BytesStreamOutput result = new BytesStreamOutput();
    try (UTF8StreamWriter writer = utf8StreamWriter().setOutput(result)) {
        // crazy reflection here
        SpecialPermission.check();
        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
            ((Mustache) template.compiled()).execute(writer, vars);
            return null;
        });
    } catch (Exception e) {
        logger.error((Supplier<?>) () -> new ParameterizedMessage("Error running {}", template), e);
        throw new GeneralScriptException("Error running " + template, e);
    }
    return result.bytes();
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testDiscoveryNodeSerializationKeepsHost() 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.CURRENT);
    node.writeTo(streamOutput);

    StreamInput in = StreamInput.wrap(streamOutput.bytes().toBytesRef().bytes);
    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());
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testSerialization() throws IOException {
    SimulatePipelineRequest request = new SimulatePipelineRequest(new BytesArray(""), XContentType.JSON);
    // Sometimes we set an id
    if (randomBoolean()) {
        request.setId(randomAsciiOfLengthBetween(1, 10));
    }

    // Sometimes we explicitly set a boolean (with whatever value)
    if (randomBoolean()) {
        request.setVerbose(randomBoolean());
    }

    BytesStreamOutput out = new BytesStreamOutput();
    request.writeTo(out);
    StreamInput streamInput = out.bytes().streamInput();
    SimulatePipelineRequest otherRequest = new SimulatePipelineRequest();
    otherRequest.readFrom(streamInput);

    assertThat(otherRequest.getId(), equalTo(request.getId()));
    assertThat(otherRequest.isVerbose(), equalTo(request.isVerbose()));
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
/**
 * Cache something calculated at the shard level.
 * @param shard the shard this item is part of
 * @param reader a reader for this shard. Used to invalidate the cache when there are changes.
 * @param cacheKey key for the thing being cached within this shard
 * @param loader loads the data into the cache if needed
 * @return the contents of the cache or the result of calling the loader
 */
private BytesReference cacheShardLevelResult(IndexShard shard, DirectoryReader reader, BytesReference cacheKey, Consumer<StreamOutput> loader)
        throws Exception {
    IndexShardCacheEntity cacheEntity = new IndexShardCacheEntity(shard);
    Supplier<BytesReference> supplier = () -> {
        /* BytesStreamOutput allows to pass the expected size but by default uses
         * BigArrays.PAGE_SIZE_IN_BYTES which is 16k. A common cached result ie.
         * a date histogram with 3 buckets is ~100byte so 16k might be very wasteful
         * since we don't shrink to the actual size once we are done serializing.
         * By passing 512 as the expected size we will resize the byte array in the stream
         * slowly until we hit the page size and don't waste too much memory for small query
         * results.*/
        final int expectedSizeInBytes = 512;
        try (BytesStreamOutput out = new BytesStreamOutput(expectedSizeInBytes)) {
            loader.accept(out);
            // for now, keep the paged data structure, which might have unused bytes to fill a page, but better to keep
            // the memory properly paged instead of having varied sized bytes
            return out.bytes();
        }
    };
    return indicesRequestCache.getOrCompute(cacheEntity, supplier, reader, cacheKey);
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testSerialization() throws IOException {
    Map<String, Map<String, Map<String, FieldMappingMetaData>>> mappings = new HashMap<>();
    FieldMappingMetaData fieldMappingMetaData = new FieldMappingMetaData("my field", new BytesArray("{}"));
    mappings.put("index", Collections.singletonMap("type", Collections.singletonMap("field", fieldMappingMetaData)));
    GetFieldMappingsResponse response = new GetFieldMappingsResponse(mappings);

    try (BytesStreamOutput out = new BytesStreamOutput()) {
        response.writeTo(out);
        GetFieldMappingsResponse serialized = new GetFieldMappingsResponse();
        try (StreamInput in = StreamInput.wrap(out.bytes().toBytesRef().bytes)) {
            serialized.readFrom(in);
            FieldMappingMetaData metaData = serialized.fieldMappings("index", "type", "field");
            assertNotNull(metaData);
            assertEquals(new BytesArray("{}"), metaData.getSource());
        }
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
/**
 * Marks this store as corrupted. This method writes a <tt>corrupted_${uuid}</tt> file containing the given exception
 * message. If a store contains a <tt>corrupted_${uuid}</tt> file {@link #isMarkedCorrupted()} will return <code>true</code>.
 */
public void markStoreCorrupted(IOException exception) throws IOException {
    ensureOpen();
    if (!isMarkedCorrupted()) {
        String uuid = CORRUPTED + UUIDs.randomBase64UUID();
        try (IndexOutput output = this.directory().createOutput(uuid, IOContext.DEFAULT)) {
            CodecUtil.writeHeader(output, CODEC, VERSION);
            BytesStreamOutput out = new BytesStreamOutput();
            out.writeException(exception);
            BytesReference bytes = out.bytes();
            output.writeVInt(bytes.length());
            BytesRef ref = bytes.toBytesRef();
            output.writeBytes(ref.bytes, ref.offset, ref.length);
            CodecUtil.writeFooter(output);
        } catch (IOException ex) {
            logger.warn("Can't mark store as corrupted", ex);
        }
        directory().sync(Collections.singleton(uuid));
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
@Override
public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
    boolean helpWanted = request.paramAsBoolean("help", false);
    if (helpWanted) {
        return channel -> {
            Table table = getTableWithHeader(request);
            int[] width = buildHelpWidths(table, request);
            BytesStreamOutput bytesOutput = channel.bytesOutput();
            UTF8StreamWriter out = new UTF8StreamWriter().setOutput(bytesOutput);
            for (Table.Cell cell : table.getHeaders()) {
                // need to do left-align always, so create new cells
                pad(new Table.Cell(cell.value), width[0], request, out);
                out.append(" | ");
                pad(new Table.Cell(cell.attr.containsKey("alias") ? cell.attr.get("alias") : ""), width[1], request, out);
                out.append(" | ");
                pad(new Table.Cell(cell.attr.containsKey("desc") ? cell.attr.get("desc") : "not available"), width[2], request, out);
                out.append("\n");
            }
            out.close();
            channel.sendResponse(new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, bytesOutput.bytes()));
        };
    } else {
        return doCatRequest(request, client);
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
/**
 * Sends back an error response to the caller via the given channel
 * @param nodeVersion the caller node version
 * @param channel the channel to send the response to
 * @param error the error to return
 * @param requestId the request ID this response replies to
 * @param action the action this response replies to
 */
public void sendErrorResponse(Version nodeVersion, Channel channel, final Exception error, final long requestId,
                              final String action) throws IOException {
    try (BytesStreamOutput stream = new BytesStreamOutput()) {
        stream.setVersion(nodeVersion);
        RemoteTransportException tx = new RemoteTransportException(
            nodeName(), new TransportAddress(getLocalAddress(channel)), action, error);
        threadPool.getThreadContext().writeTo(stream);
        stream.writeException(tx);
        byte status = 0;
        status = TransportStatus.setResponse(status);
        status = TransportStatus.setError(status);
        final BytesReference bytes = stream.bytes();
        final BytesReference header = buildHeader(requestId, status, nodeVersion, bytes.length());
        Runnable onRequestSent = () -> transportServiceAdapter.onResponseSent(requestId, action, error);
        sendMessage(channel, new CompositeBytesReference(header, bytes), onRequestSent);
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testSerialization() throws IOException {
    CreateIndexRequest request = new CreateIndexRequest("foo");
    String mapping = JsonXContent.contentBuilder().startObject().startObject("type").endObject().endObject().string();
    request.mapping("my_type", mapping, XContentType.JSON);

    try (BytesStreamOutput output = new BytesStreamOutput()) {
        request.writeTo(output);

        try (StreamInput in = output.bytes().streamInput()) {
            CreateIndexRequest serialized = new CreateIndexRequest();
            serialized.readFrom(in);
            assertEquals(request.index(), serialized.index());
            assertEquals(mapping, serialized.mappings().get("my_type"));
        }
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
/**
 * Create a {@link CompressedXContent} out of a serialized {@link ToXContent}
 * that may already be compressed.
 */
public CompressedXContent(BytesReference data) throws IOException {
    Compressor compressor = CompressorFactory.compressor(data);
    if (compressor != null) {
        // already compressed...
        this.bytes = BytesReference.toBytes(data);
        this.crc32 = crc32(new BytesArray(uncompressed()));
    } else {
        BytesStreamOutput out = new BytesStreamOutput();
        try (OutputStream compressedOutput = CompressorFactory.COMPRESSOR.streamOutput(out)) {
            data.writeTo(compressedOutput);
        }
        this.bytes = BytesReference.toBytes(out.bytes());
        this.crc32 = crc32(data);
    }
    assertConsistent();
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的package包/类
public void testSerializeInDifferentContextNoDefaults() throws IOException {
    BytesStreamOutput out = new BytesStreamOutput();
    {
        ThreadContext threadContext = new ThreadContext(Settings.EMPTY);
        threadContext.putHeader("foo", "bar");
        threadContext.putTransient("ctx.foo", 1);

        assertEquals("bar", threadContext.getHeader("foo"));
        assertNotNull(threadContext.getTransient("ctx.foo"));
        assertNull(threadContext.getHeader("default"));
        threadContext.writeTo(out);
    }
    {
        Settings otherSettings = Settings.builder().put("request.headers.default", "5").build();
        ThreadContext otherhreadContext = new ThreadContext(otherSettings);
        otherhreadContext.readHeaders(out.bytes().streamInput());

        assertEquals("bar", otherhreadContext.getHeader("foo"));
        assertNull(otherhreadContext.getTransient("ctx.foo"));
        assertEquals("5", otherhreadContext.getHeader("default"));
    }
}
 

import org.elasticsearch.common.io.stream.BytesStreamOutput; //导入依赖的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.BytesStreamOutput; //导入依赖的package包/类
public void testSerialization() throws IOException {
    boolean isFailure = randomBoolean();
    SimulateDocumentBaseResult simulateDocumentBaseResult;
    if (isFailure) {
        simulateDocumentBaseResult = new SimulateDocumentBaseResult(new IllegalArgumentException("test"));
    } else {
        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
        simulateDocumentBaseResult = new SimulateDocumentBaseResult(ingestDocument);
    }

    BytesStreamOutput out = new BytesStreamOutput();
    simulateDocumentBaseResult.writeTo(out);
    StreamInput streamInput = out.bytes().streamInput();
    SimulateDocumentBaseResult otherSimulateDocumentBaseResult = new SimulateDocumentBaseResult(streamInput);

    if (isFailure) {
        assertThat(otherSimulateDocumentBaseResult.getIngestDocument(), equalTo(simulateDocumentBaseResult.getIngestDocument()));
        assertThat(otherSimulateDocumentBaseResult.getFailure(), instanceOf(IllegalArgumentException.class));
        IllegalArgumentException e = (IllegalArgumentException) otherSimulateDocumentBaseResult.getFailure();
        assertThat(e.getMessage(), equalTo("test"));
    } else {
        assertIngestDocument(otherSimulateDocumentBaseResult.getIngestDocument(), simulateDocumentBaseResult.getIngestDocument());
    }
}