Java XContent类代码示例

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testFromXContent() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();
    XContentBuilder builder = XContentBuilder.builder(xContent)
                                                .startObject()
                                                    .field("type", "foo")
                                                    .field("reason", "something went wrong")
                                                    .field("stack_trace", "...")
                                                .endObject();

    ElasticsearchException parsed;
    try (XContentParser parser = createParser(xContent, builder.bytes())) {
        assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
        parsed = ElasticsearchException.fromXContent(parser);
        assertEquals(XContentParser.Token.END_OBJECT, parser.currentToken());
        assertNull(parser.nextToken());
    }

    assertNotNull(parsed);
    assertEquals(parsed.getMessage(), "Elasticsearch exception [type=foo, reason=something went wrong, stack_trace=...]");
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testThrowableToAndFromXContent() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();

    final Tuple<Throwable, ElasticsearchException> exceptions = randomExceptions();
    final Throwable throwable = exceptions.v1();

    BytesReference throwableBytes = XContentHelper.toXContent((builder, params) -> {
        ElasticsearchException.generateThrowableXContent(builder, params, throwable);
        return builder;
    }, xContent.type(), randomBoolean());

    ElasticsearchException parsedException;
    try (XContentParser parser = createParser(xContent, throwableBytes)) {
        assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
        parsedException = ElasticsearchException.fromXContent(parser);
        assertEquals(XContentParser.Token.END_OBJECT, parser.currentToken());
        assertNull(parser.nextToken());
    }
    assertDeepEquals(exceptions.v2(), parsedException);
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testUnknownFailureToAndFromXContent() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();

    BytesReference failureBytes = XContentHelper.toXContent((builder, params) -> {
        // Prints a null failure using generateFailureXContent()
        ElasticsearchException.generateFailureXContent(builder, params, null, randomBoolean());
        return builder;
    }, xContent.type(), randomBoolean());

    ElasticsearchException parsedFailure;
    try (XContentParser parser = createParser(xContent, failureBytes)) {
        assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
        assertEquals(XContentParser.Token.FIELD_NAME, parser.nextToken());
        parsedFailure = ElasticsearchException.failureFromXContent(parser);
        assertEquals(XContentParser.Token.END_OBJECT, parser.nextToken());
        assertNull(parser.nextToken());
    }

    // Failure was null, expecting a "unknown" reason
    assertEquals("Elasticsearch exception [type=exception, reason=unknown]", parsedFailure.getMessage());
    assertEquals(0, parsedFailure.getHeaders().size());
    assertEquals(0, parsedFailure.getMetadata().size());
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testTwoAggs() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    XContentBuilder source = JsonXContent.contentBuilder()
            .startObject()
                .startObject("by_date")
                    .startObject("date_histogram")
                        .field("field", "timestamp")
                        .field("interval", "month")
                    .endObject()
                    .startObject("aggs")
                        .startObject("tag_count")
                            .startObject("cardinality")
                                .field("field", "tag")
                            .endObject()
                        .endObject()
                    .endObject()
                    .startObject("aggs") // 2nd "aggs": illegal
                        .startObject("tag_count2")
                            .startObject("cardinality")
                                .field("field", "tag")
                            .endObject()
                        .endObject()
                    .endObject()
                .endObject()
            .endObject();
    XContentParser parser = createParser(source);
    QueryParseContext parseContext = new QueryParseContext(parser);
    assertSame(XContentParser.Token.START_OBJECT, parser.nextToken());
    Exception e = expectThrows(ParsingException.class, () -> AggregatorFactories.parseAggregators(parseContext));
    assertThat(e.toString(), containsString("Found two sub aggregation definitions under [by_date]"));
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testSameAggregationName() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    final String name = randomAsciiOfLengthBetween(1, 10);
    XContentBuilder source = JsonXContent.contentBuilder()
            .startObject()
                .startObject(name)
                    .startObject("terms")
                        .field("field", "a")
                    .endObject()
                .endObject()
                .startObject(name)
                    .startObject("terms")
                        .field("field", "b")
                    .endObject()
                .endObject()
            .endObject();
    XContentParser parser = createParser(source);
    QueryParseContext parseContext = new QueryParseContext(parser);
    assertSame(XContentParser.Token.START_OBJECT, parser.nextToken());
    Exception e = expectThrows(ParsingException.class, () -> AggregatorFactories.parseAggregators(parseContext));
    assertThat(e.toString(), containsString("Two sibling aggregations cannot have the same name: [" + name + "]"));
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testUnknownSuggestionTypeThrows() throws IOException {
    XContent xContent = JsonXContent.jsonXContent;
    String suggestionString =
             "{\"unknownType#suggestionName\":"
                + "[{\"text\":\"entryText\","
                + "\"offset\":42,"
                + "\"length\":313,"
                + "\"options\":[{\"text\":\"someText\","
                            + "\"highlighted\":\"somethingHighlighted\","
                            + "\"score\":1.3,"
                            + "\"collate_match\":true}]"
                        + "}]"
            + "}";
    try (XContentParser parser = xContent.createParser(xContentRegistry(), suggestionString)) {
        ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.nextToken(), parser::getTokenLocation);
        ensureExpectedToken(XContentParser.Token.FIELD_NAME, parser.nextToken(), parser::getTokenLocation);
        ParsingException e = expectThrows(ParsingException.class, () -> Suggestion.fromXContent(parser));
        assertEquals("Unknown Suggestion [unknownType]", e.getMessage());
    }
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testMalformedQueryMultipleQueryElements() throws IOException {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    String json = "{\n" +
            "    \"function_score\":{\n" +
            "        \"query\":{\n" +
            "            \"bool\":{\n" +
            "                \"must\":{\"match\":{\"field\":\"value\"}}" +
            "             }\n" +
            "            },\n" +
            "        \"query\":{\n" +
            "            \"bool\":{\n" +
            "                \"must\":{\"match\":{\"field\":\"value\"}}" +
            "             }\n" +
            "            }\n" +
            "        }\n" +
            "    }\n" +
            "}";
    expectParsingException(json, "[query] is already defined.");
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
/**
 * test that two queries in object throws error
 */
public void testTooManyQueriesInObject() throws IOException {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    String clauseType = randomFrom("must", "should", "must_not", "filter");
    // should also throw error if invalid query is preceded by a valid one
    String query = "{\n" +
            "  \"bool\": {\n" +
            "    \"" + clauseType + "\": {\n" +
            "      \"match\": {\n" +
            "        \"foo\": \"bar\"\n" +
            "      },\n" +
            "      \"match\": {\n" +
            "        \"baz\": \"buzz\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
    ParsingException ex = expectThrows(ParsingException.class, () -> parseQuery(query));
    assertEquals("[match] malformed query, expected [END_OBJECT] but found [FIELD_NAME]", ex.getMessage());
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
private static PercolateQuery.QueryStore createStore(PercolatorFieldMapper.FieldType fieldType,
                                                     QueryShardContext context,
                                                     boolean mapUnmappedFieldsAsString) {
    return ctx -> {
        LeafReader leafReader = ctx.reader();
        BinaryDocValues binaryDocValues = leafReader.getBinaryDocValues(fieldType.queryBuilderField.name());
        if (binaryDocValues == null) {
            return docId -> null;
        }

        Bits bits = leafReader.getDocsWithField(fieldType.queryBuilderField.name());
        return docId -> {
            if (bits.get(docId)) {
                BytesRef qbSource = binaryDocValues.get(docId);
                if (qbSource.length > 0) {
                    XContent xContent = PercolatorFieldMapper.QUERY_BUILDER_CONTENT_TYPE.xContent();
                    try (XContentParser sourceParser = xContent.createParser(context.getXContentRegistry(), qbSource.bytes,
                            qbSource.offset, qbSource.length)) {
                        return parseQuery(context, mapUnmappedFieldsAsString, sourceParser);
                    }
                } else {
                    return null;
                }
            } else {
                return null;
            }
        };
    };
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public static ObjectPath createFromXContent(XContent xContent, BytesReference input) throws IOException {
    try (XContentParser parser = xContent.createParser(NamedXContentRegistry.EMPTY, input)) {
        if (parser.nextToken() == XContentParser.Token.START_ARRAY) {
            return new ObjectPath(parser.listOrderedMap());
        }
        return new ObjectPath(parser.mapOrdered());
    }
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testDuplicateParts() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    parseAndExpectFailure("{\n" +
            "  \"ping\": {" +
            "    \"documentation\": \"http://www.elasticsearch.org/guide/\"," +
            "    \"methods\": [\"PUT\"]," +
            "    \"url\": {" +
            "      \"path\": \"/\"," +
            "      \"paths\": [\"/\"]," +
            "      \"parts\": {" +
            "        \"index\": {" +
            "          \"type\" : \"string\",\n" +
            "          \"description\" : \"index part\"\n" +
            "        }," +
            "        \"type\": {" +
            "          \"type\" : \"string\",\n" +
            "          \"description\" : \"type part\"\n" +
            "        }," +
            "        \"index\": {" +
            "          \"type\" : \"string\",\n" +
            "          \"description\" : \"index parameter part\"\n" +
            "        }" +
            "      }," +
            "      \"params\": {" +
            "        \"type\" : \"boolean\",\n" +
            "        \"description\" : \"Whether specified concrete indices should be ignored when unavailable (missing or closed)\"" +
            "      }" +
            "    }," +
            "    \"body\": null" +
            "  }" +
            "}", "Found duplicate part [index]");
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testDuplicateParams() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    parseAndExpectFailure("{\n" +
            "  \"ping\": {" +
            "    \"documentation\": \"http://www.elasticsearch.org/guide/\"," +
            "    \"methods\": [\"PUT\"]," +
            "    \"url\": {" +
            "      \"path\": \"/\"," +
            "      \"paths\": [\"/\"]," +
            "      \"parts\": {" +
            "      }," +
            "      \"params\": {" +
            "        \"timeout\": {" +
            "          \"type\" : \"string\",\n" +
            "          \"description\" : \"timeout parameter\"\n" +
            "        }," +
            "        \"refresh\": {" +
            "          \"type\" : \"string\",\n" +
            "          \"description\" : \"refresh parameter\"\n" +
            "        }," +
            "        \"timeout\": {" +
            "          \"type\" : \"string\",\n" +
            "          \"description\" : \"timeout parameter again\"\n" +
            "        }" +
            "      }" +
            "    }," +
            "    \"body\": null" +
            "  }" +
            "}", "Found duplicate param [timeout]");
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testParseDoSectionWithJsonMultipleBodiesRepeatedProperty() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());

    String[] bodies = new String[] {
            "{ \"index\": { \"_index\":\"test_index\", \"_type\":\"test_type\", \"_id\":\"test_id\" } }",
            "{ \"f1\":\"v1\", \"f2\":42 }",
    };
    parser = createParser(YamlXContent.yamlXContent,
            "bulk:\n" +
            "    refresh: true\n" +
            "    body: \n" +
            "        " + bodies[0] + "\n" +
            "    body: \n" +
            "        " + bodies[1]
    );

    DoSection doSection = DoSection.parse(parser);
    ApiCallSection apiCallSection = doSection.getApiCallSection();

    assertThat(apiCallSection, notNullValue());
    assertThat(apiCallSection.getApi(), equalTo("bulk"));
    assertThat(apiCallSection.getParams().size(), equalTo(1));
    assertThat(apiCallSection.getParams().get("refresh"), equalTo("true"));
    assertThat(apiCallSection.hasBody(), equalTo(true));
    assertThat(apiCallSection.getBodies().size(), equalTo(bodies.length));
    for (int i = 0; i < bodies.length; i++) {
        assertJsonEquals(apiCallSection.getBodies().get(i), bodies[i]);
    }
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
public void testParseDoSectionWithYamlMultipleBodiesRepeatedProperty() throws Exception {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());

    parser = createParser(YamlXContent.yamlXContent,
            "bulk:\n" +
            "    refresh: true\n" +
            "    body:\n" +
            "        index:\n" +
            "            _index: test_index\n" +
            "            _type:  test_type\n" +
            "            _id:    test_id\n" +
            "    body:\n" +
            "        f1: v1\n" +
            "        f2: 42\n"
    );
    String[] bodies = new String[2];
    bodies[0] = "{\"index\": {\"_index\": \"test_index\", \"_type\":  \"test_type\", \"_id\": \"test_id\"}}";
    bodies[1] = "{ \"f1\":\"v1\", \"f2\": 42 }";

    DoSection doSection = DoSection.parse(parser);
    ApiCallSection apiCallSection = doSection.getApiCallSection();

    assertThat(apiCallSection, notNullValue());
    assertThat(apiCallSection.getApi(), equalTo("bulk"));
    assertThat(apiCallSection.getParams().size(), equalTo(1));
    assertThat(apiCallSection.getParams().get("refresh"), equalTo("true"));
    assertThat(apiCallSection.hasBody(), equalTo(true));
    assertThat(apiCallSection.getBodies().size(), equalTo(bodies.length));

    for (int i = 0; i < bodies.length; i++) {
        assertJsonEquals(apiCallSection.getBodies().get(i), bodies[i]);
    }
}
 

import org.elasticsearch.common.xcontent.XContent; //导入依赖的package包/类
protected void copyRawValue(BytesReference content, XContent xContent) throws IOException {
    // EMPTY is safe here because we never call namedObject
    try (StreamInput input = content.streamInput();
         XContentParser parser = xContent.createParser(NamedXContentRegistry.EMPTY, input)) {
        copyCurrentStructure(parser);
    }
}