The JsonParser class does not progress as much as it could when the processing faulty input.

When the JsonParser process malformed input, it does halt the parsing and handle the error leaving unprocessed tokens in the underlying Jackson parser. These tokens will be processed when the JsonParser handle another input. When the Jackson parser fails we handle the error and then give up and reported behavior is a consequence.

The JsonParser has been modified to continue when a malformed input is reported instead of stopping after the error has been processed. Errors are collected and delivered after we all tokens have been processed.

fixes #4338

Author: vietj

src/main/java/io/vertx/core/parsetools/impl/JsonParserImpl.java

@@ -12,6 +12,7 @@
 package io.vertx.core.parsetools.impl;
 
 import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonLocation;
 import com.fasterxml.jackson.core.JsonToken;
 import com.fasterxml.jackson.core.ObjectCodec;
 import com.fasterxml.jackson.core.base.ParserBase;
@@ -31,10 +32,7 @@
 import io.vertx.core.streams.ReadStream;
 
 import java.io.IOException;
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
@@ -54,6 +52,7 @@ public class JsonParserImpl implements JsonParser {
   private final ReadStream<Buffer> stream;
   private boolean emitting;
   private final Deque<JsonEventImpl> pending = new ArrayDeque<>();
+  private List<IOException> collectedExceptions;
 
   public JsonParserImpl(ReadStream<Buffer> stream) {
     this.stream = stream;
@@ -143,21 +142,24 @@ private void handleEvent(JsonEventImpl event) {
     }
   }
 
+  private void handle(IOException ioe) {
+    if (collectedExceptions == null) {
+      collectedExceptions = new ArrayList<>();
+    }
+    collectedExceptions.add(ioe);
+  }
+
   @Override
   public void handle(Buffer data) {
     byte[] bytes = data.getBytes();
     try {
       parser.feedInput(bytes, 0, bytes.length);
-      checkTokens();
     } catch (IOException e) {
-      if (exceptionHandler != null) {
-        exceptionHandler.handle(e);
-        return;
-      } else {
-        throw new DecodeException(e.getMessage(), e);
-      }
+      handle(e);
     }
+    checkTokens();
     checkPending();
+    checkExceptions();
   }
 
   @Override
@@ -167,25 +169,33 @@ public void end() {
     }
     ended = true;
     parser.endOfInput();
-    try {
-      checkTokens();
-    } catch (IOException e) {
-      if (exceptionHandler != null) {
-        exceptionHandler.handle(e);
-        return;
-      } else {
-        throw new DecodeException(e.getMessage(), e);
-      }
-    }
+    checkTokens();
     checkPending();
+    checkExceptions();
   }
 
-  private void checkTokens() throws IOException {
+  private void checkTokens() {
+    JsonLocation prevLocation = null;
     while (true) {
-      JsonToken token = parser.nextToken();
+      JsonToken token;
+      try {
+        token = parser.nextToken();
+      } catch (IOException e) {
+        JsonLocation location = parser.currentLocation();
+        if (prevLocation != null) {
+          if (location.equals(prevLocation)) {
+            // If we haven't done any progress, give up
+            return;
+          }
+        }
+        prevLocation = location;
+        handle(e);
+        continue;
+      }
       if (token == null || token == JsonToken.NOT_AVAILABLE) {
         break;
       }
+      prevLocation = null;
       String field = currentField;
       currentField = null;
       JsonEventImpl event;
@@ -199,11 +209,20 @@ private void checkTokens() throws IOException {
           break;
         }
         case FIELD_NAME: {
-          currentField = parser.getCurrentName();
+          try {
+            currentField = parser.getCurrentName();
+          } catch (IOException e) {
+            handle(e);
+          }
           continue;
         }
         case VALUE_STRING: {
-          event = new JsonEventImpl(token, JsonEventType.VALUE, field, parser.getText());
+          try {
+            event = new JsonEventImpl(token, JsonEventType.VALUE, field, parser.getText());
+          } catch (IOException e) {
+            handle(e);
+            continue;
+          }
           break;
         }
         case VALUE_TRUE: {
@@ -219,11 +238,21 @@ private void checkTokens() throws IOException {
           break;
         }
         case VALUE_NUMBER_INT: {
-          event = new JsonEventImpl(token, JsonEventType.VALUE, field, parser.getLongValue());
+          try {
+            event = new JsonEventImpl(token, JsonEventType.VALUE, field, parser.getLongValue());
+          } catch (IOException e) {
+            handle(e);
+            continue;
+          }
           break;
         }
         case VALUE_NUMBER_FLOAT: {
-          event = new JsonEventImpl(token, JsonEventType.VALUE, field, parser.getDoubleValue());
+          try {
+            event = new JsonEventImpl(token, JsonEventType.VALUE, field, parser.getDoubleValue());
+          } catch (IOException e) {
+            handle(e);
+            continue;
+          }
           break;
         }
         case END_OBJECT: {
@@ -288,6 +317,21 @@ private void checkPending() {
     }
   }
 
+  private void checkExceptions() {
+    List<IOException> exceptions = collectedExceptions;
+    collectedExceptions = null;
+    if (exceptions != null && exceptions.size() > 0) {
+      if (exceptionHandler != null) {
+        for (IOException ioe : exceptions) {
+          exceptionHandler.handle(ioe);
+        }
+      } else {
+        IOException ioe = exceptions.get(0);
+        throw new DecodeException(ioe.getMessage(), ioe);
+      }
+    }
+  }
+
   @Override
   public JsonParser objectEventMode() {
     objectValueMode = false;

src/test/java/io/vertx/core/parsetools/JsonParserTest.java

@@ -113,6 +113,35 @@ public void parseUnfinished() {
     assertEquals(1, errors.size());
   }
 
+  @Test
+  public void testParseWithErrors() {
+    Buffer data = Buffer.buffer("{\"foo\":\"foo_value\"},{\"bar\":\"bar_value\"},{\"juu\":\"juu_value\"}");
+    JsonParser parser = JsonParser.newParser();
+    List<JsonObject> objects = new ArrayList<>();
+    List<Throwable> errors = new ArrayList<>();
+    AtomicInteger endCount = new AtomicInteger();
+    parser.objectValueMode()
+      .handler(event -> objects.add(event.objectValue()))
+      .exceptionHandler(errors::add)
+      .endHandler(v -> endCount.incrementAndGet());
+    parser.write(data);
+    assertEquals(3, objects.size());
+    List<JsonObject> expected = Arrays.asList(
+      new JsonObject().put("foo", "foo_value"),
+      new JsonObject().put("bar", "bar_value"),
+      new JsonObject().put("juu", "juu_value")
+    );
+    assertEquals(expected, objects);
+    assertEquals(2, errors.size());
+    assertEquals(0, endCount.get());
+    objects.clear();
+    errors.clear();
+    parser.end();
+    assertEquals(Collections.emptyList(), objects);
+    assertEquals(Collections.emptyList(), errors);
+    assertEquals(1, endCount.get());
+  }
+
   @Test
   public void parseNumberFormatException() {
     Buffer data = Buffer.buffer(Long.MAX_VALUE + "0");