Java BytesArray.streamInput方法代码示例

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
/**
 * Writes blob in atomic manner without resolving the blobName using using {@link #blobName} method.
 * <p>
 * The blob will be compressed and checksum will be written if required.
 *
 * @param obj           object to be serialized
 * @param blobContainer blob container
 * @param blobName          blob name
 */
protected void writeBlob(T obj, BlobContainer blobContainer, String blobName) throws IOException {
    BytesReference bytes = write(obj);
    try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
        final String resourceDesc = "ChecksumBlobStoreFormat.writeBlob(blob=\"" + blobName + "\")";
        try (OutputStreamIndexOutput indexOutput = new OutputStreamIndexOutput(resourceDesc, blobName, byteArrayOutputStream, BUFFER_SIZE)) {
            CodecUtil.writeHeader(indexOutput, codec, VERSION);
            try (OutputStream indexOutputOutputStream = new IndexOutputOutputStream(indexOutput) {
                @Override
                public void close() throws IOException {
                    // this is important since some of the XContentBuilders write bytes on close.
                    // in order to write the footer we need to prevent closing the actual index input.
                } }) {
                bytes.writeTo(indexOutputOutputStream);
            }
            CodecUtil.writeFooter(indexOutput);
        }
        BytesArray bytesArray = new BytesArray(byteArrayOutputStream.toByteArray());
        try (InputStream stream = bytesArray.streamInput()) {
            blobContainer.writeBlob(blobName, stream, bytesArray.length());
        }
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
@Override
public String startVerification() {
    try {
        if (isReadOnly()) {
            // It's readonly - so there is not much we can do here to verify it
            return null;
        } else {
            String seed = UUIDs.randomBase64UUID();
            byte[] testBytes = Strings.toUTF8Bytes(seed);
            BlobContainer testContainer = blobStore().blobContainer(basePath().add(testBlobPrefix(seed)));
            String blobName = "master.dat";
            BytesArray bytes = new BytesArray(testBytes);
            try (InputStream stream = bytes.streamInput()) {
                testContainer.writeBlob(blobName + "-temp", stream, bytes.length());
            }
            // Make sure that move is supported
            testContainer.move(blobName + "-temp", blobName);
            return seed;
        }
    } catch (IOException exp) {
        throw new RepositoryVerificationException(metadata.name(), "path " + basePath() + " is not accessible on master node", exp);
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
@Override
public void verify(String seed, DiscoveryNode localNode) {
    BlobContainer testBlobContainer = blobStore().blobContainer(basePath().add(testBlobPrefix(seed)));
    if (testBlobContainer.blobExists("master.dat")) {
        try  {
            BytesArray bytes = new BytesArray(seed);
            try (InputStream stream = bytes.streamInput()) {
                testBlobContainer.writeBlob("data-" + localNode.getId() + ".dat", stream, bytes.length());
            }
        } catch (IOException exp) {
            throw new RepositoryVerificationException(metadata.name(), "store location [" + blobStore() + "] is not accessible on the node [" + localNode + "]", exp);
        }
    } else {
        throw new RepositoryVerificationException(metadata.name(), "a file written by master to the store [" + blobStore() + "] cannot be accessed on the node [" + localNode + "]. "
            + "This might indicate that the store [" + blobStore() + "] is not shared between this node and the master node or "
            + "that permissions on the store don't allow reading files written by the master node");
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testSerialize50RequestForIndexBoost() throws IOException {
    BytesArray requestBytes = new BytesArray(Base64.getDecoder()
        // this is a base64 encoded request generated with the same input
        .decode("AAZpbmRleDEWTjEyM2trbHFUT21XZDY1Z2VDYlo5ZwABBAABAAIA/wD/////DwABBmluZGV4MUAAAAAAAAAAAP////8PAAAAAAAAAgAAAA" +
            "AAAPa/q8mOKwIAJg=="));

    try (StreamInput in = new NamedWriteableAwareStreamInput(requestBytes.streamInput(), namedWriteableRegistry)) {
        in.setVersion(Version.V_5_0_0);
        ShardSearchTransportRequest readRequest = new ShardSearchTransportRequest();
        readRequest.readFrom(in);
        assertEquals(0, in.available());
        assertEquals(2.0f, readRequest.indexBoost(), 0);

        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(Version.V_5_0_0);
        readRequest.writeTo(output);
        assertEquals(output.bytes().toBytesRef(), requestBytes.toBytesRef());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
protected void randomCorruption(BlobContainer blobContainer, String blobName) throws IOException {
    byte[] buffer = new byte[(int) blobContainer.listBlobsByPrefix(blobName).get(blobName).length()];
    long originalChecksum = checksum(buffer);
    try (InputStream inputStream = blobContainer.readBlob(blobName)) {
        Streams.readFully(inputStream, buffer);
    }
    do {
        int location = randomIntBetween(0, buffer.length - 1);
        buffer[location] = (byte) (buffer[location] ^ 42);
    } while (originalChecksum == checksum(buffer));
    blobContainer.deleteBlob(blobName); // delete original before writing new blob
    BytesArray bytesArray = new BytesArray(buffer);
    try (StreamInput stream = bytesArray.streamInput()) {
        blobContainer.writeBlob(blobName, stream, bytesArray.length());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testBytesStreamInput() throws IOException {
    byte stuff[] = new byte[] { 0, 1, 2, 3 };
    BytesRef stuffRef = new BytesRef(stuff, 2, 2);
    BytesArray stuffArray = new BytesArray(stuffRef);
    StreamInput input = stuffArray.streamInput();
    assertEquals(2, input.read());
    assertEquals(3, input.read());
    assertEquals(-1, input.read());
    input.close();
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testSerialize50Request() throws IOException {
    ExplainRequest request = new ExplainRequest("index", "type", "id");
    request.fetchSourceContext(new FetchSourceContext(true, new String[]{"field1.*"}, new String[] {"field2.*"}));
    request.filteringAlias(new AliasFilter(QueryBuilders.termQuery("filter_field", "value"), new String[] {"alias0", "alias1"}));
    request.preference("the_preference");
    request.query(QueryBuilders.termQuery("field", "value"));
    request.storedFields(new String[] {"field1", "field2"});
    request.routing("some_routing");
    BytesArray requestBytes = new BytesArray(Base64.getDecoder()
        // this is a base64 encoded request generated with the same input
        .decode("AAABBWluZGV4BHR5cGUCaWQBDHNvbWVfcm91dGluZwEOdGhlX3ByZWZlcmVuY2UEdGVybT" +
            "+AAAAABWZpZWxkFQV2YWx1ZQIGYWxpYXMwBmFsaWFzMQECBmZpZWxkMQZmaWVsZDIBAQEIZmllbGQxLioBCGZpZWxkMi4qAA"));
    try (StreamInput in = new NamedWriteableAwareStreamInput(requestBytes.streamInput(), namedWriteableRegistry)) {
        in.setVersion(Version.V_5_0_0);
        ExplainRequest readRequest = new ExplainRequest();
        readRequest.readFrom(in);
        assertEquals(0, in.available());
        assertArrayEquals(request.filteringAlias().getAliases(), readRequest.filteringAlias().getAliases());
        expectThrows(IllegalStateException.class, () -> readRequest.filteringAlias().getQueryBuilder());
        assertArrayEquals(request.storedFields(), readRequest.storedFields());
        assertEquals(request.preference(), readRequest.preference());
        assertEquals(request.query(), readRequest.query());
        assertEquals(request.routing(), readRequest.routing());
        assertEquals(request.fetchSourceContext(), readRequest.fetchSourceContext());
        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(Version.V_5_0_0);
        readRequest.writeTo(output);
        assertEquals(output.bytes().toBytesRef(), requestBytes.toBytesRef());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testPutIndexTemplateRequest510() throws IOException {
    PutIndexTemplateRequest putRequest = new PutIndexTemplateRequest("test");
    putRequest.patterns(Collections.singletonList("test*"));
    putRequest.order(5);

    PutIndexTemplateRequest multiPatternRequest = new PutIndexTemplateRequest("test");
    multiPatternRequest.patterns(Arrays.asList("test*", "*test2", "*test3*"));
    multiPatternRequest.order(5);

    // These bytes were retrieved by Base64 encoding the result of the above with 5_0_0 code.
    // Note: Instead of a list for the template, in 5_0_0 the element was provided as a string.
    String putRequestBytes = "ADwDAAR0ZXN0BXRlc3QqAAAABQAAAAAAAA==";
    BytesArray bytes = new BytesArray(Base64.getDecoder().decode(putRequestBytes));

    try (StreamInput in = bytes.streamInput()) {
        in.setVersion(Version.V_5_0_0);
        PutIndexTemplateRequest readRequest = new PutIndexTemplateRequest();
        readRequest.readFrom(in);
        assertEquals(putRequest.patterns(), readRequest.patterns());
        assertEquals(putRequest.order(), readRequest.order());

        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(Version.V_5_0_0);
        readRequest.writeTo(output);
        assertEquals(bytes.toBytesRef(), output.bytes().toBytesRef());

        // test that multi templates are reverse-compatible.
        // for the bwc case, if multiple patterns, use only the first pattern seen.
        output.reset();
        multiPatternRequest.writeTo(output);
        assertEquals(bytes.toBytesRef(), output.bytes().toBytesRef());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testSerialize50Request() throws IOException {
    ValidateQueryRequest validateQueryRequest = new ValidateQueryRequest("indices");
    validateQueryRequest.query(QueryBuilders.termQuery("field", "value"));
    validateQueryRequest.rewrite(true);
    validateQueryRequest.explain(false);
    validateQueryRequest.types("type1", "type2");
    ShardValidateQueryRequest request = new ShardValidateQueryRequest(new ShardId("index", "foobar", 1),
        new AliasFilter(QueryBuilders.termQuery("filter_field", "value"), new String[] {"alias0", "alias1"}), validateQueryRequest);
    BytesArray requestBytes = new BytesArray(Base64.getDecoder()
        // this is a base64 encoded request generated with the same input
        .decode("AAVpbmRleAZmb29iYXIBAQdpbmRpY2VzBAR0ZXJtP4AAAAAFZmllbGQVBXZhbHVlAgV0eXBlMQV0eXBlMgIGYWxpYXMwBmFsaWFzMQABAA"));
    try (StreamInput in = new NamedWriteableAwareStreamInput(requestBytes.streamInput(), namedWriteableRegistry)) {
        in.setVersion(Version.V_5_0_0);
        ShardValidateQueryRequest readRequest = new ShardValidateQueryRequest();
        readRequest.readFrom(in);
        assertEquals(0, in.available());
        assertArrayEquals(request.filteringAliases().getAliases(), readRequest.filteringAliases().getAliases());
        expectThrows(IllegalStateException.class, () -> readRequest.filteringAliases().getQueryBuilder());
        assertArrayEquals(request.types(), readRequest.types());
        assertEquals(request.explain(), readRequest.explain());
        assertEquals(request.query(), readRequest.query());
        assertEquals(request.rewrite(), readRequest.rewrite());
        assertEquals(request.shardId(), readRequest.shardId());
        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(Version.V_5_0_0);
        readRequest.writeTo(output);
        assertEquals(output.bytes().toBytesRef(), requestBytes.toBytesRef());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
private static void writeBlob(BlobContainer container, String blobName, BytesArray bytesArray) throws IOException {
    try (InputStream stream = bytesArray.streamInput()) {
        container.writeBlob(blobName, stream, bytesArray.length());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
private void writeBlob(final BlobContainer container, final String blobName, final BytesArray bytesArray) throws IOException {
    try (InputStream stream = bytesArray.streamInput()) {
        container.writeBlob(blobName, stream, bytesArray.length());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testSerialize50Request() throws IOException {
    BytesArray requestBytes = new BytesArray(Base64.getDecoder()
        // this is a base64 encoded request generated with the same input
        .decode("AAh4cXptdEhJcgdnT0d1ZldWyfL/sgQBJAHkDAMBAAIBAQ4TWlljWlZ5TkVmRU5xQnFQVHBjVBRZbUpod2pRV2dDSXVxRXpRaEdGVBRFZWFJY0plT2hn" +
            "UEpISFhmSXR6Qw5XZ1hQcmFidWhWalFSQghuUWNwZ2JjQxBtZldRREJPaGF3UnlQSE56EVhQSUtRa25Iekh3bU5kbGVECWlFT2NIeEh3RgZIYXpMTWgUeGJq" +
            "VU9Tdkdua3RORU5QZkNrb1EOalRyWGh5WXhvZ3plV2UUcWlXZFl2eUFUSXdPVGdMUUtYTHAJU3RKR3JxQkVJEkdEQ01xUHpnWWNaT3N3U3prSRIUeURlVFpM" +
            "Q1lBZERZcWpDb3NOVWIST1NyQlZtdUNrd0F1UXRvdVRjEGp6RlVMd1dqc3VtUVNaTk0JT3N2cnpLQ3ZLBmRpS1J6cgdYbmVhZnBxBUlTUU9pEEJMcm1ERXVs" +
            "eXhESlBoVkgTaWdUUmtVZGh4d0FFc2ZKRm9ZahNrb01XTnFFd2NWSVVDU3pWS2xBC3JVTWV3V2tUUWJUE3VGQU1Hd21CYUFMTmNQZkxobXUIZ3dxWHBxWXcF" +
            "bmNDZUEOTFBSTEpYZVF6Z3d2eE0PV1BucUFacll6WWRxa1hCDGxkbXNMaVRzcUZXbAtSY0NsY3FNdlJQcv8BAP////8PAQAAARQAAQp5THlIcHdQeGtMAAAB" +
            "AQAAAAEDbkVLAQMBCgACAAADAQABAAAAAQhIc25wRGxQbwEBQgABAAACAQMAAAEIAAAJMF9OSG9kSmh2HwABAwljRW5MVWxFbVQFemlxWG8KcXZQTkRUUGJk" +
            "bgECCkpMbXVMT1dtVnkISEdUUHhsd0cBAAEJAAABA2lkcz+rKsUAAAAAAAAAAAECAQYAAgwxX0ZlRWxSQkhzQ07/////DwABAAEDCnRyYXFHR1hjVHkKTERY" +
            "aE1HRWVySghuSWtzbEtXUwABCgEHSlRwQnhwdwAAAQECAgAAAAAAAQcyX3FlYmNDGQEEBklxZU9iUQdTc01Gek5YCWlMd2xuamNRQwNiVncAAUHt61kAAQR0" +
            "ZXJtP4AAAAANbUtDSnpHU3lidm5KUBUMaVpqeG9vcm5QSFlvAAEBLGdtcWxuRWpWTXdvTlhMSHh0RWlFdHBnbEF1cUNmVmhoUVlwRFZxVllnWWV1A2ZvbwEA" +
            "AQhwYWlubGVzc/8AALk4AAAAAAABAAAAAAAAAwpKU09PU0ZmWnhFClVqTGxMa2p3V2gKdUJwZ3R3dXFER5Hg97uT7MOmPgEADw"));
    try (StreamInput in = new NamedWriteableAwareStreamInput(requestBytes.streamInput(), namedWriteableRegistry)) {
        in.setVersion(Version.V_5_0_0);
        ShardSearchTransportRequest readRequest = new ShardSearchTransportRequest();
        readRequest.readFrom(in);
        assertEquals(0, in.available());
        IllegalStateException illegalStateException = expectThrows(IllegalStateException.class, () -> readRequest.filteringAliases());
        assertEquals("alias filter for aliases: [JSOOSFfZxE, UjLlLkjwWh, uBpgtwuqDG] must be rewritten first",
            illegalStateException.getMessage());
        IndexMetaData.Builder indexMetadata = new IndexMetaData.Builder(baseMetaData)
            .putAlias(AliasMetaData.newAliasMetaDataBuilder("JSOOSFfZxE").filter("{\"term\" : {\"foo\" : \"bar\"}}"))
            .putAlias(AliasMetaData.newAliasMetaDataBuilder("UjLlLkjwWh").filter("{\"term\" : {\"foo\" : \"bar1\"}}"))
            .putAlias(AliasMetaData.newAliasMetaDataBuilder("uBpgtwuqDG").filter("{\"term\" : {\"foo\" : \"bar2\"}}"));
        IndexSettings indexSettings = new IndexSettings(indexMetadata.build(), Settings.EMPTY);
        final long nowInMillis = randomNonNegativeLong();
        QueryShardContext context = new QueryShardContext(
            0, indexSettings, null, null, null, null, null, xContentRegistry(), null, null, () -> nowInMillis);
        readRequest.rewrite(context);
        QueryBuilder queryBuilder = readRequest.filteringAliases();
        assertEquals(queryBuilder, QueryBuilders.boolQuery()
            .should(QueryBuilders.termQuery("foo", "bar"))
            .should(QueryBuilders.termQuery("foo", "bar1"))
            .should(QueryBuilders.termQuery("foo", "bar2"))
        );
        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(Version.V_5_0_0);
        readRequest.writeTo(output);
        assertEquals(output.bytes().toBytesRef(), requestBytes.toBytesRef());
    }
}
 

import org.elasticsearch.common.bytes.BytesArray; //导入方法依赖的package包/类
public void testIndexTemplateMetaData510() throws IOException {
    IndexTemplateMetaData metaData = IndexTemplateMetaData.builder("foo")
        .patterns(Collections.singletonList("bar"))
        .order(1)
        .settings(Settings.builder()
            .put("setting1", "value1")
            .put("setting2", "value2"))
        .putAlias(newAliasMetaDataBuilder("alias-bar1")).build();

    IndexTemplateMetaData multiMetaData = IndexTemplateMetaData.builder("foo")
        .patterns(Arrays.asList("bar", "foo"))
        .order(1)
        .settings(Settings.builder()
            .put("setting1", "value1")
            .put("setting2", "value2"))
        .putAlias(newAliasMetaDataBuilder("alias-bar1")).build();

    // These bytes were retrieved by Base64 encoding the result of the above with 5_0_0 code
    String templateBytes = "A2ZvbwAAAAEDYmFyAghzZXR0aW5nMQEGdmFsdWUxCHNldHRpbmcyAQZ2YWx1ZTIAAQphbGlhcy1iYXIxAAAAAAA=";
    BytesArray bytes = new BytesArray(Base64.getDecoder().decode(templateBytes));

    try (StreamInput in = bytes.streamInput()) {
        in.setVersion(Version.V_5_0_0);
        IndexTemplateMetaData readMetaData = IndexTemplateMetaData.readFrom(in);
        assertEquals(0, in.available());
        assertEquals(metaData.getName(), readMetaData.getName());
        assertEquals(metaData.getPatterns(), readMetaData.getPatterns());
        assertTrue(metaData.aliases().containsKey("alias-bar1"));
        assertEquals(1, metaData.aliases().size());

        BytesStreamOutput output = new BytesStreamOutput();
        output.setVersion(Version.V_5_0_0);
        readMetaData.writeTo(output);
        assertEquals(bytes.toBytesRef(), output.bytes().toBytesRef());

        // test that multi templates are reverse-compatible.
        // for the bwc case, if multiple patterns, use only the first pattern seen.
        output.reset();
        multiMetaData.writeTo(output);
        assertEquals(bytes.toBytesRef(), output.bytes().toBytesRef());
    }
}