Examples with ParsingException org.elasticsearch.common.ParsingException used on opensource projects

Example 56 with ParsingException

use of org.elasticsearch.common.ParsingException in project elasticsearch by elastic.

the class RemoteScrollableHitSourceTests method testParseRequestFailure.

public void testParseRequestFailure() throws Exception {
    AtomicBoolean called = new AtomicBoolean();
    Consumer<Response> checkResponse = r -> {
        assertFalse(r.isTimedOut());
        assertNull(r.getScrollId());
        assertEquals(0, r.getTotalHits());
        assertThat(r.getFailures(), hasSize(1));
        assertThat(r.getFailures().get(0).getReason(), instanceOf(ParsingException.class));
        ParsingException failure = (ParsingException) r.getFailures().get(0).getReason();
        assertEquals("Unknown key for a VALUE_STRING in [invalid].", failure.getMessage());
        assertEquals(2, failure.getLineNumber());
        assertEquals(14, failure.getColumnNumber());
        called.set(true);
    };
    sourceWithMockedRemoteCall("request_failure.json").doStart(checkResponse);
    assertTrue(called.get());
    called.set(false);
    sourceWithMockedRemoteCall("request_failure.json").doStartNextScroll("scroll", timeValueMillis(0), checkResponse);
    assertTrue(called.get());
}

Example 57 with ParsingException

use of org.elasticsearch.common.ParsingException in project elasticsearch by elastic.

the class RemoteScrollableHitSource method execute.

private <T> void execute(String method, String uri, Map<String, String> params, HttpEntity entity, BiFunction<XContentParser, XContentType, T> parser, Consumer<? super T> listener) {
    // Preserve the thread context so headers survive after the call
    java.util.function.Supplier<ThreadContext.StoredContext> contextSupplier = threadPool.getThreadContext().newRestorableContext(true);
    class RetryHelper extends AbstractRunnable {

        private final Iterator<TimeValue> retries = backoffPolicy.iterator();

        @Override
        protected void doRun() throws Exception {
            client.performRequestAsync(method, uri, params, entity, new ResponseListener() {

                @Override
                public void onSuccess(org.elasticsearch.client.Response response) {
                    // Restore the thread context to get the precious headers
                    try (ThreadContext.StoredContext ctx = contextSupplier.get()) {
                        // eliminates compiler warning
                        assert ctx != null;
                        T parsedResponse;
                        try {
                            HttpEntity responseEntity = response.getEntity();
                            InputStream content = responseEntity.getContent();
                            XContentType xContentType = null;
                            if (responseEntity.getContentType() != null) {
                                final String mimeType = ContentType.parse(responseEntity.getContentType().getValue()).getMimeType();
                                xContentType = XContentType.fromMediaType(mimeType);
                            }
                            if (xContentType == null) {
                                try {
                                    throw new ElasticsearchException("Response didn't include Content-Type: " + bodyMessage(response.getEntity()));
                                } catch (IOException e) {
                                    ElasticsearchException ee = new ElasticsearchException("Error extracting body from response");
                                    ee.addSuppressed(e);
                                    throw ee;
                                }
                            }
                            // EMPTY is safe here because we don't call namedObject
                            try (XContentParser xContentParser = xContentType.xContent().createParser(NamedXContentRegistry.EMPTY, content)) {
                                parsedResponse = parser.apply(xContentParser, xContentType);
                            } catch (ParsingException e) {
                                /* Because we're streaming the response we can't get a copy of it here. The best we can do is hint that it
                                 * is totally wrong and we're probably not talking to Elasticsearch. */
                                throw new ElasticsearchException("Error parsing the response, remote is likely not an Elasticsearch instance", e);
                            }
                        } catch (IOException e) {
                            throw new ElasticsearchException("Error deserializing response, remote is likely not an Elasticsearch instance", e);
                        }
                        listener.accept(parsedResponse);
                    }
                }

                @Override
                public void onFailure(Exception e) {
                    try (ThreadContext.StoredContext ctx = contextSupplier.get()) {
                        // eliminates compiler warning
                        assert ctx != null;
                        if (e instanceof ResponseException) {
                            ResponseException re = (ResponseException) e;
                            if (RestStatus.TOO_MANY_REQUESTS.getStatus() == re.getResponse().getStatusLine().getStatusCode()) {
                                if (retries.hasNext()) {
                                    TimeValue delay = retries.next();
                                    logger.trace((Supplier<?>) () -> new ParameterizedMessage("retrying rejected search after [{}]", delay), e);
                                    countSearchRetry.run();
                                    threadPool.schedule(delay, ThreadPool.Names.SAME, RetryHelper.this);
                                    return;
                                }
                            }
                            e = wrapExceptionToPreserveStatus(re.getResponse().getStatusLine().getStatusCode(), re.getResponse().getEntity(), re);
                        } else if (e instanceof ContentTooLongException) {
                            e = new IllegalArgumentException("Remote responded with a chunk that was too large. Use a smaller batch size.", e);
                        }
                        fail.accept(e);
                    }
                }
            });
        }

        @Override
        public void onFailure(Exception t) {
            fail.accept(t);
        }
    }
    new RetryHelper().run();
}

Example 58 with ParsingException

use of org.elasticsearch.common.ParsingException in project elasticsearch by elastic.

the class ObjectParserTests method testParseNamedObjectNoFieldsInArray.

public void testParseNamedObjectNoFieldsInArray() throws IOException {
    XContentParser parser = createParser(JsonXContent.jsonXContent, "{\"named\": [\n" + "  {}" + "]}");
    ParsingException e = expectThrows(ParsingException.class, () -> NamedObjectHolder.PARSER.apply(parser, null));
    assertEquals("[named_object_holder] failed to parse field [named]", e.getMessage());
    assertEquals("[named] can be a single object with any number of fields or an array where each entry is an object with a single field", e.getCause().getMessage());
}

Example 59 with ParsingException

use of org.elasticsearch.common.ParsingException in project elasticsearch by elastic.

the class ConstantScoreQueryBuilderTests method testNoArrayAsFilterElements.

/**
     * test that "filter" does not accept an array of queries, throws {@link ParsingException}
     */
public void testNoArrayAsFilterElements() throws IOException {
    String queryString = "{ \"" + ConstantScoreQueryBuilder.NAME + "\" : {\n" + "\"filter\" : [ { \"term\": { \"foo\": \"a\" } },\n" + "{ \"term\": { \"foo\": \"x\" } } ]\n" + "} }";
    ParsingException e = expectThrows(ParsingException.class, () -> parseQuery(queryString));
    assertThat(e.getMessage(), containsString("unexpected token [START_ARRAY]"));
}

Example 60 with ParsingException

use of org.elasticsearch.common.ParsingException in project elasticsearch by elastic.

the class FuzzyQueryBuilderTests method testParseFailsWithMultipleFields.

public void testParseFailsWithMultipleFields() throws IOException {
    String json1 = "{\n" + "  \"fuzzy\" : {\n" + "    \"message1\" : {\n" + "      \"value\" : \"this is a test\"\n" + "    }\n" + "  }\n" + "}";
    // should be all good
    parseQuery(json1);
    String json2 = "{\n" + "  \"fuzzy\" : {\n" + "    \"message1\" : {\n" + "      \"value\" : \"this is a test\"\n" + "    },\n" + "    \"message2\" : {\n" + "      \"value\" : \"this is a test\"\n" + "    }\n" + "  }\n" + "}";
    ParsingException e = expectThrows(ParsingException.class, () -> parseQuery(json2));
    assertEquals("[fuzzy] query doesn't support multiple fields, found [message1] and [message2]", e.getMessage());
    String shortJson = "{\n" + "  \"fuzzy\" : {\n" + "    \"message1\" : \"this is a test\",\n" + "    \"message2\" : \"value\" : \"this is a test\"\n" + "  }\n" + "}";
    e = expectThrows(ParsingException.class, () -> parseQuery(shortJson));
    assertEquals("[fuzzy] query doesn't support multiple fields, found [message1] and [message2]", e.getMessage());
}