Java 类org.elasticsearch.common.xcontent.XContent 实例源码

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=...]");
}

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);
}

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());
}

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]"));
}

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 + "]"));
}

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());
    }
}

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.");
}

/**
 * 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());
}

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;
            }
        };
    };
}

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());
    }
}

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]");
}

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]");
}

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]);
    }
}

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]);
    }
}

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);
    }
}

public void testFromXContentWithCause() throws IOException {
    ElasticsearchException e = new ElasticsearchException("foo",
            new ElasticsearchException("bar",
                    new ElasticsearchException("baz",
                            new RoutingMissingException("_test", "_type", "_id"))));

    final XContent xContent = randomFrom(XContentType.values()).xContent();
    XContentBuilder builder = XContentBuilder.builder(xContent).startObject().value(e).endObject();

    ElasticsearchException parsed;
    try (XContentParser parser = createParser(builder)) {
        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=exception, reason=foo]");

    ElasticsearchException cause = (ElasticsearchException) parsed.getCause();
    assertEquals(cause.getMessage(), "Elasticsearch exception [type=exception, reason=bar]");

    cause = (ElasticsearchException) cause.getCause();
    assertEquals(cause.getMessage(), "Elasticsearch exception [type=exception, reason=baz]");

    cause = (ElasticsearchException) cause.getCause();
    assertEquals(cause.getMessage(),
            "Elasticsearch exception [type=routing_missing_exception, reason=routing is required for [_test]/[_type]/[_id]]");
    assertThat(cause.getHeaderKeys(), hasSize(0));
    assertThat(cause.getMetadataKeys(), hasSize(2));
    assertThat(cause.getMetadata("es.index"), hasItem("_test"));
    assertThat(cause.getMetadata("es.index_uuid"), hasItem("_na_"));
}

public void testFailureToAndFromXContentWithNoDetails() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();

    final Exception failure = (Exception) randomExceptions().v1();
    BytesReference failureBytes = XContentHelper.toXContent((builder, params) -> {
        ElasticsearchException.generateFailureXContent(builder, params, failure, false);
        return builder;
    }, xContent.type(), randomBoolean());

    try (XContentParser parser = createParser(xContent, failureBytes)) {
        failureBytes = shuffleXContent(parser, randomBoolean()).bytes();
    }

    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());
    }
    assertNotNull(parsedFailure);

    String reason;
    if (failure instanceof ElasticsearchException) {
        reason = failure.getClass().getSimpleName() + "[" + failure.getMessage() + "]";
    } else {
        reason = "No ElasticsearchException found";
    }
    assertEquals(ElasticsearchException.buildMessage("exception", reason, null), parsedFailure.getMessage());
    assertEquals(0, parsedFailure.getHeaders().size());
    assertEquals(0, parsedFailure.getMetadata().size());
    assertNull(parsedFailure.getCause());
}

/**
 * test that bad xContent throws exception
 */
public void testIllegalXContent() throws IOException {
    // test missing fieldname
    String directGenerator = "{ }";
    assertIllegalXContent(directGenerator, IllegalArgumentException.class,
            "Required [field]");

    // test two fieldnames
    if (XContent.isStrictDuplicateDetectionEnabled()) {
        logger.info("Skipping test as it uses a custom duplicate check that is obsolete when strict duplicate checks are enabled.");
    } else {
        directGenerator = "{ \"field\" : \"f1\", \"field\" : \"f2\" }";
        assertIllegalXContent(directGenerator, ParsingException.class,
            "[direct_generator] failed to parse field [field]");
    }

    // test unknown field
    directGenerator = "{ \"unknown_param\" : \"f1\" }";
    assertIllegalXContent(directGenerator, IllegalArgumentException.class,
            "[direct_generator] unknown field [unknown_param], parser not found");

    // test bad value for field (e.g. size expects an int)
    directGenerator = "{ \"size\" : \"xxl\" }";
    assertIllegalXContent(directGenerator, ParsingException.class,
            "[direct_generator] failed to parse field [size]");

    // test unexpected token
    directGenerator = "{ \"size\" : [ \"xxl\" ] }";
    assertIllegalXContent(directGenerator, IllegalArgumentException.class,
            "[direct_generator] size doesn't support values of type: START_ARRAY");
}

/**
 * test that multiple "filter" elements causes {@link ParsingException}
 */
public void testMultipleFilterElements() throws IOException {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    String queryString = "{ \"" + ConstantScoreQueryBuilder.NAME + "\" : {\n" +
                                "\"filter\" : { \"term\": { \"foo\": \"a\" } },\n" +
                                "\"filter\" : { \"term\": { \"foo\": \"x\" } },\n" +
                        "} }";
    ParsingException e = expectThrows(ParsingException.class, () -> parseQuery(queryString));
    assertThat(e.getMessage(), containsString("accepts only one 'filter' element"));
}

public void testDuplicateKeysThrowsException() {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());
    final String json = "{\"foo\":\"bar\",\"foo\":\"baz\"}";
    final SettingsException e = expectThrows(SettingsException.class,
        () -> Settings.builder().loadFromSource(json, XContentType.JSON).build());
    assertEquals(e.getCause().getClass(), ElasticsearchParseException.class);
    assertThat(
            e.toString(),
            containsString("duplicate settings key [foo] " +
                    "found at line number [1], " +
                    "column number [20], " +
                    "previous value [bar], " +
                    "current value [baz]"));
}

public void testDuplicateKeysThrowsException() {
    assumeFalse("Test only makes sense if XContent parser doesn't have strict duplicate checks enabled",
        XContent.isStrictDuplicateDetectionEnabled());

    String yaml = "foo: bar\nfoo: baz";
    SettingsException e = expectThrows(SettingsException.class, () -> {
        Settings.builder().loadFromSource(yaml, XContentType.YAML);
    });
    assertEquals(e.getCause().getClass(), ElasticsearchParseException.class);
    String msg = e.getCause().getMessage();
    assertTrue(
        msg,
        msg.contains("duplicate settings key [foo] found at line number [2], column number [6], " +
            "previous value [bar], current value [baz]"));
}

protected void assertBinary(XContentBuilder expected, XContentBuilder builder) {
    assertNotNull(builder);
    assertNotNull(expected);

    try {
        XContent xContent = XContentFactory.xContent(builder.contentType());
        XContentParser jsonParser = createParser(xContent, expected.bytes());
        XContentParser testParser = createParser(xContent, builder.bytes());

        while (true) {
            XContentParser.Token token1 = jsonParser.nextToken();
            XContentParser.Token token2 = testParser.nextToken();
            if (token1 == null) {
                assertThat(token2, nullValue());
                return;
            }
            assertThat(token1, equalTo(token2));
            switch (token1) {
                case FIELD_NAME:
                    assertThat(jsonParser.currentName(), equalTo(testParser.currentName()));
                    break;
                case VALUE_STRING:
                    assertThat(jsonParser.text(), equalTo(testParser.text()));
                    break;
                case VALUE_NUMBER:
                    assertThat(jsonParser.numberType(), equalTo(testParser.numberType()));
                    assertThat(jsonParser.numberValue(), equalTo(testParser.numberValue()));
                    break;
            }
        }
    } catch (Exception e) {
        fail("Fail to verify the result of the XContentBuilder: " + e.getMessage());
    }
}

public void testToAndFromXContent() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();

    ShardSearchFailure[] shardSearchFailures = new ShardSearchFailure[randomIntBetween(1, 5)];
    for (int i = 0; i < shardSearchFailures.length; i++) {
        Exception cause = randomFrom(
                new ParsingException(1, 2, "foobar", null),
                new InvalidIndexTemplateException("foo", "bar"),
                new TimestampParsingException("foo", null),
                new NullPointerException()
        );
        shardSearchFailures[i] = new  ShardSearchFailure(cause, new SearchShardTarget("node_" + i, new Index("test", "_na_"), i));
    }

    final String phase = randomFrom("query", "search", "other");
    SearchPhaseExecutionException actual = new SearchPhaseExecutionException(phase, "unexpected failures", shardSearchFailures);

    BytesReference exceptionBytes = XContentHelper.toXContent(actual, xContent.type(), randomBoolean());

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

    assertNotNull(parsedException);
    assertThat(parsedException.getHeaderKeys(), hasSize(0));
    assertThat(parsedException.getMetadataKeys(), hasSize(1));
    assertThat(parsedException.getMetadata("es.phase"), hasItem(phase));
    // SearchPhaseExecutionException has no cause field
    assertNull(parsedException.getCause());
}

protected XContentBuilder buildSource(XContent content, Map<String, Object> map) {
  try {
    // Enforce the content type to be CBOR as it is more efficient for large byte arrays
    return XContentBuilder.builder(XContentType.CBOR.xContent()).map(map);
  }
  catch (IOException e) {
    logger.error("failed to build source", e);
    throw new IllegalStateException("Failed to build source", e);
  }
}

/**
 * Guesses the content (type) based on the provided char sequence.
 */
public static XContent xContent(CharSequence content) {
    XmlXContentType type = xContentType(content);
    if (type == null) {
        throw new ElasticsearchParseException("Failed to derive xcontent from " + content);
    }
    return xContent(type);
}

/**
 * Guesses the content type based on the provided bytes.
 */
public static XContent xContent(byte[] data, int offset, int length) {
    XmlXContentType type = xContentType(data, offset, length);
    if (type == null) {
        throw new ElasticsearchParseException("Failed to derive xcontent from (offset=" + offset + ", length=" + length + "): " + Arrays.toString(data));
    }
    return xContent(type);
}

public static XContent xContent(BytesReference bytes) {
    XmlXContentType type = xContentType(bytes);
    if (type == null) {
        throw new ElasticsearchParseException("Failed to derive xcontent from " + bytes);
    }
    return xContent(type);
}

@Override protected Enumerable<Object> find(String index, List<String> ops,
    List<Map.Entry<String, Class>> fields) {
  final String dbName = index;

  final SearchSourceBuilder searchSourceBuilder;
  if (ops.isEmpty()) {
    searchSourceBuilder = new SearchSourceBuilder();
  } else {
    String queryString = "{" + Util.toString(ops, "", ", ", "") + "}";
    NamedXContentRegistry xContentRegistry = NamedXContentRegistry.EMPTY;
    XContent xContent = JsonXContent.jsonXContent;
    try (XContentParser parser = xContent.createParser(xContentRegistry, queryString)) {
      final QueryParseContext queryParseContext = new QueryParseContext(parser);
      searchSourceBuilder = SearchSourceBuilder.fromXContent(queryParseContext);
    } catch (IOException ex) {
      throw new RuntimeException(ex);
    }
  }
  final Function1<SearchHit, Object> getter = Elasticsearch5Enumerator.getter(fields);

  return new AbstractEnumerable<Object>() {
    public Enumerator<Object> enumerator() {
      final Iterator<SearchHit> cursor = client.prepareSearch(dbName).setTypes(typeName)
          .setSource(searchSourceBuilder)
          .execute().actionGet().getHits().iterator();
      return new Elasticsearch5Enumerator(cursor, getter);
    }
  };
}

/**
 * Create a new {@link XContentParser}.
 */
protected final XContentParser createParser(XContent xContent, String data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Create a new {@link XContentParser}.
 */
protected final XContentParser createParser(XContent xContent, InputStream data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Create a new {@link XContentParser}.
 */
protected final XContentParser createParser(XContent xContent, byte[] data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Create a new {@link XContentParser}.
 */
protected final XContentParser createParser(XContent xContent, BytesReference data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

public void testFromXContentWithHeadersAndMetadata() throws IOException {
    RoutingMissingException routing = new RoutingMissingException("_test", "_type", "_id");
    ElasticsearchException baz = new ElasticsearchException("baz", routing);
    baz.addHeader("baz_0", "baz0");
    baz.addMetadata("es.baz_1", "baz1");
    baz.addHeader("baz_2", "baz2");
    baz.addMetadata("es.baz_3", "baz3");
    ElasticsearchException bar = new ElasticsearchException("bar", baz);
    bar.addMetadata("es.bar_0", "bar0");
    bar.addHeader("bar_1", "bar1");
    bar.addMetadata("es.bar_2", "bar2");
    ElasticsearchException foo = new ElasticsearchException("foo", bar);
    foo.addMetadata("es.foo_0", "foo0");
    foo.addHeader("foo_1", "foo1");

    final XContent xContent = randomFrom(XContentType.values()).xContent();
    XContentBuilder builder = XContentBuilder.builder(xContent).startObject().value(foo).endObject();

    ElasticsearchException parsed;
    try (XContentParser parser = createParser(builder)) {
        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=exception, reason=foo]");
    assertThat(parsed.getHeaderKeys(), hasSize(1));
    assertThat(parsed.getHeader("foo_1"), hasItem("foo1"));
    assertThat(parsed.getMetadataKeys(), hasSize(1));
    assertThat(parsed.getMetadata("es.foo_0"), hasItem("foo0"));

    ElasticsearchException cause = (ElasticsearchException) parsed.getCause();
    assertEquals(cause.getMessage(), "Elasticsearch exception [type=exception, reason=bar]");
    assertThat(cause.getHeaderKeys(), hasSize(1));
    assertThat(cause.getHeader("bar_1"), hasItem("bar1"));
    assertThat(cause.getMetadataKeys(), hasSize(2));
    assertThat(cause.getMetadata("es.bar_0"), hasItem("bar0"));
    assertThat(cause.getMetadata("es.bar_2"), hasItem("bar2"));

    cause = (ElasticsearchException) cause.getCause();
    assertEquals(cause.getMessage(), "Elasticsearch exception [type=exception, reason=baz]");
    assertThat(cause.getHeaderKeys(), hasSize(2));
    assertThat(cause.getHeader("baz_0"), hasItem("baz0"));
    assertThat(cause.getHeader("baz_2"), hasItem("baz2"));
    assertThat(cause.getMetadataKeys(), hasSize(2));
    assertThat(cause.getMetadata("es.baz_1"), hasItem("baz1"));
    assertThat(cause.getMetadata("es.baz_3"), hasItem("baz3"));

    cause = (ElasticsearchException) cause.getCause();
    assertEquals(cause.getMessage(),
            "Elasticsearch exception [type=routing_missing_exception, reason=routing is required for [_test]/[_type]/[_id]]");
    assertThat(cause.getHeaderKeys(), hasSize(0));
    assertThat(cause.getMetadataKeys(), hasSize(2));
    assertThat(cause.getMetadata("es.index"), hasItem("_test"));
    assertThat(cause.getMetadata("es.index_uuid"), hasItem("_na_"));
}

/**
 * Test that some values like arrays of numbers are ignored when parsing back
 * an exception.
 */
public void testFromXContentWithIgnoredMetadataAndHeaders() throws IOException {
    final XContent xContent = randomFrom(XContentType.values()).xContent();

    // The exception content to parse is built using a XContentBuilder
    // because the current Java API does not allow to add metadata/headers
    // of other types than list of strings.
    BytesReference originalBytes;
    try (XContentBuilder builder = XContentBuilder.builder(xContent)) {
        builder.startObject()
                .field("metadata_int", 1)
                .array("metadata_array_of_ints", new int[]{8, 13, 21})
                .field("reason", "Custom reason")
                .array("metadata_array_of_boolean", new boolean[]{false, false})
                .startArray("metadata_array_of_objects")
                    .startObject()
                        .field("object_array_one", "value_one")
                    .endObject()
                    .startObject()
                        .field("object_array_two", "value_two")
                    .endObject()
                .endArray()
                .field("type", "custom_exception")
                .field("metadata_long", 1L)
                .array("metadata_array_of_longs", new long[]{2L, 3L, 5L})
                .field("metadata_other", "some metadata")
                .startObject("header")
                    .field("header_string", "some header")
                    .array("header_array_of_strings", new String[]{"foo", "bar", "baz"})
                .endObject()
                .startObject("metadata_object")
                    .field("object_field", "value")
                .endObject()
        .endObject();

        originalBytes = builder.bytes();
    }

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

    assertNotNull(parsedException);
    assertEquals("Elasticsearch exception [type=custom_exception, reason=Custom reason]", parsedException.getMessage());
    assertEquals(2, parsedException.getHeaderKeys().size());
    assertThat(parsedException.getHeader("header_string"), hasItem("some header"));
    assertThat(parsedException.getHeader("header_array_of_strings"), hasItems("foo", "bar", "baz"));
    assertEquals(1, parsedException.getMetadataKeys().size());
    assertThat(parsedException.getMetadata("es.metadata_other"), hasItem("some metadata"));
}

/**
 * Create a new {@link XContentParser}.
 */
protected static XContentParser createParser(XContent xContent, String data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Create a new {@link XContentParser}.
 */
protected static XContentParser createParser(XContent xContent, InputStream data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Create a new {@link XContentParser}.
 */
protected static XContentParser createParser(XContent xContent, byte[] data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Create a new {@link XContentParser}.
 */
protected static XContentParser createParser(XContent xContent, BytesReference data) throws IOException {
    return xContent.createParser(xContentRegistry(), data);
}

/**
 * Returns the {@link org.elasticsearch.common.xcontent.XContent} for the provided content type.
 */
public static XContent xContent(XmlXContentType type) {
    return type.xContent();
}

/**
 * Guesses the content type based on the provided bytes.
 */
public static XContent xContent(byte[] data) {
    return xContent(data, 0, data.length);
}