optimize JsonRpcServlet

Author: 317787106

framework/src/main/java/org/tron/core/services/filter/BufferedResponseWrapper.java

@@ -18,8 +18,7 @@
  * the handler returns and write its own error response when true.
  *
  * <p>Header-mutating methods ({@code setStatus}, {@code setContentType}) are buffered here and
- * only forwarded to the real response via {@link #commitToResponse()}, preventing a timed-out
- * handler thread from racing with the timeout error writer.
+ * only forwarded to the real response via {@link #commitToResponse()}.
  */
 public class BufferedResponseWrapper extends HttpServletResponseWrapper {
 
@@ -28,8 +27,9 @@ public class BufferedResponseWrapper extends HttpServletResponseWrapper {
   private final int maxBytes;
   private int status = HttpServletResponse.SC_OK;
   private String contentType;
+  private boolean committed = false;
   @Getter
-  private boolean overflow = false;
+  private volatile boolean overflow = false;
 
   private final ServletOutputStream outputStream = new ServletOutputStream() {
     @Override
@@ -122,6 +122,10 @@ public PrintWriter getWriter() {
   }
 
   public void commitToResponse() throws IOException {
+    if (committed) {
+      throw new IllegalStateException("commitToResponse() already called");
+    }
+    committed = true;
     if (contentType != null) {
       actual.setContentType(contentType);
     }

framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcServlet.java

@@ -1,7 +1,9 @@
 package org.tron.core.services.jsonrpc;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.googlecode.jsonrpc4j.HttpStatusCodeProvider;
 import com.googlecode.jsonrpc4j.JsonRpcInterceptor;
@@ -29,12 +31,13 @@ public class JsonRpcServlet extends RateLimiterServlet {
 
   private static final ObjectMapper MAPPER = new ObjectMapper();
 
-  enum JsonRpcError {
+  private enum JsonRpcError {
     PARSE_ERROR(-32700),
+    INTERNAL_ERROR(-32603),
     EXCEED_LIMIT(-32005),
     RESPONSE_TOO_LARGE(-32003);
 
-    final int code;
+    private final int code;
 
     JsonRpcError(int code) {
       this.code = code;
@@ -86,19 +89,25 @@ public Integer getJsonRpcCode(int httpStatusCode) {
   protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
     CommonParameter parameter = CommonParameter.getInstance();
 
-    byte[] body;
+    // Transport IOException from readBody propagates as HTTP 500 (genuine IO failure).
+    byte[] body = readBody(req.getInputStream());
     JsonNode rootNode;
     try {
-      body = readBody(req.getInputStream());
       rootNode = MAPPER.readTree(body);
-    } catch (IOException e) {
-      writeJsonRpcError(resp, JsonRpcError.PARSE_ERROR, "Parse error", null);
+      if (rootNode == null || rootNode.isMissingNode()) {
+        writeJsonRpcError(resp, JsonRpcError.PARSE_ERROR, "Parse error", null, false);
+        return;
+      }
+    } catch (JsonProcessingException e) {
+      writeJsonRpcError(resp, JsonRpcError.PARSE_ERROR, "Parse error", null, false);
       return;
     }
+
+    boolean isBatch = rootNode.isArray();
     int batchSize = parameter.getJsonRpcMaxBatchSize();
-    if (rootNode.isArray() && batchSize > 0 && rootNode.size() > batchSize) {
+    if (isBatch && batchSize > 0 && rootNode.size() > batchSize) {
       writeJsonRpcError(resp, JsonRpcError.EXCEED_LIMIT,
-          "Batch size " + rootNode.size() + " exceeds the limit of " + batchSize, null);
+          "Batch size " + rootNode.size() + " exceeds the limit of " + batchSize, null, true);
       return;
     }
 
@@ -108,15 +117,18 @@ protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws I
 
     try {
       rpcServer.handle(cachedReq, bufferedResp);
-    } catch (Exception e) {
-      throw new IOException("RPC execution failed", e);
+    } catch (RuntimeException e) {
+      logger.error("RPC execution failed", e);
+      JsonNode idNode = isBatch ? null : rootNode.get("id");
+      writeJsonRpcError(resp, JsonRpcError.INTERNAL_ERROR, "Internal error", idNode, isBatch);
+      return;
     }
 
     if (bufferedResp.isOverflow()) {
-      JsonNode idNode = !rootNode.isArray() ? rootNode.get("id") : null;
+      JsonNode idNode = isBatch ? null : rootNode.get("id");
       writeJsonRpcError(resp, JsonRpcError.RESPONSE_TOO_LARGE,
           "Response exceeds the limit of " + parameter.getJsonRpcMaxResponseSize() + " bytes",
-          idNode);
+          idNode, isBatch);
       return;
     }
     bufferedResp.commitToResponse();
@@ -133,18 +145,25 @@ private byte[] readBody(InputStream in) throws IOException {
   }
 
   private void writeJsonRpcError(HttpServletResponse resp, JsonRpcError error, String message,
-      JsonNode id) throws IOException {
-    ObjectNode root = MAPPER.createObjectNode();
-    root.put("jsonrpc", "2.0");
-    ObjectNode errNode = root.putObject("error");
+      JsonNode id, boolean isBatch) throws IOException {
+    ObjectNode errorObj = MAPPER.createObjectNode();
+    errorObj.put("jsonrpc", "2.0");
+    ObjectNode errNode = errorObj.putObject("error");
     errNode.put("code", error.code);
     errNode.put("message", message);
     if (id != null && !id.isNull() && !id.isMissingNode()) {
-      root.set("id", id);
+      errorObj.set("id", id);
+    } else {
+      errorObj.putNull("id");
+    }
+    byte[] bytes;
+    if (isBatch) {
+      ArrayNode arr = MAPPER.createArrayNode();
+      arr.add(errorObj);
+      bytes = MAPPER.writeValueAsBytes(arr);
     } else {
-      root.putNull("id");
+      bytes = MAPPER.writeValueAsBytes(errorObj);
     }
-    byte[] bytes = MAPPER.writeValueAsBytes(root);
     resp.setContentType("application/json; charset=utf-8");
     resp.setStatus(HttpServletResponse.SC_OK);
     resp.setContentLength(bytes.length);

framework/src/main/resources/config.conf

@@ -374,10 +374,10 @@ node {
     maxSubTopics = 1000
     # Allowed maximum number for blockFilter, default: 50000, >0 otherwise no limit
     maxBlockFilterNum = 50000
-    # Allowed batch size, default: 100, default: 100, >0 otherwise no limit
+    # Allowed batch size, default: 100, >0 otherwise no limit
     maxBatchSize = 100
-    # Allowed max response byte size, default: 26214400, >0 otherwise no limit
-    maxResponseSize = 26214400 // 25 MB = 25 * 1024 * 1024 B
+    # Allowed max response byte size, default: 26214400 (25 MB), >0 otherwise no limit
+    maxResponseSize = 26214400
   }
 
   # Disabled api list, it will work for http, rpc and pbft, both FullNode and SolidityNode,