org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: No content to map due to end-of-input

To help us debug your issue fill in the basic information below using the options provided

Serverless Java Container version: eg. 1.5

Implementations: Jersey / Spring / Spring Boot / Spring Boot 2 / Spark

Framework version: eg SpringBoot 3.2.3.RELEASE

Frontend service: REST API

Deployment method: eg SAM, Serverless Framework, Console

Scenario

Describe what you are trying to accomplish

Expected behavior

To read the body

Actual behavior

500 Internal Server Error

Steps to reproduce

package com.engati.api.gateway.filter;

import com.engati.api.gateway.config.SanitizationProvider; import com.engati.api.gateway.config.UrlServiceMappingConfiguration; import com.engati.api.gateway.constants.Constants; import com.engati.api.gateway.dto.UrlServicesMapping; import com.engati.api.gateway.utils.MapCollector; import com.engati.api.gateway.utils.Utils; import com.fasterxml.jackson.databind.ObjectMapper; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections.MapUtils; import org.apache.commons.lang.StringUtils; import org.jetbrains.annotations.NotNull; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.gateway.server.mvc.filter.BodyFilterFunctions; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Component; import org.springframework.web.servlet.function.HandlerFilterFunction; import org.springframework.web.servlet.function.HandlerFunction; import org.springframework.web.servlet.function.ServerRequest; import org.springframework.web.servlet.function.ServerResponse; import com.fasterxml.jackson.core.JsonProcessingException;

import java.util.List; import java.util.Map; import java.util.Objects;

import com.engati.api.gateway.dto.CustomerContext; import reactor.core.publisher.Mono;

@Component @Slf4j public class ProxyRequestBodyModificationFilter implements HandlerFilterFunction<ServerResponse, ServerResponse> {

@Autowired private UrlServiceMappingConfiguration urlServiceMappingConfiguration;

@Autowired private ObjectMapper objectMapper;

@Autowired private SanitizationProvider sanitizationProvider;

@NotNull @Override public ServerResponse filter(ServerRequest request, @NotNull HandlerFunction next) throws Exception { String targetApi = request.param(Constants.TARGET_API).orElse(null); String requestURI = request.uri().toString(); log.info("Received request for URI: {}", requestURI); try { if (StringUtils.isBlank(targetApi)) { log.error("Target API is null for request URI: {}", requestURI); return Utils.setGatewayResponse(HttpStatus.BAD_REQUEST); } UrlServicesMapping urlServicesMapping = urlServiceMappingConfiguration.getServiceMapping(targetApi); if (Objects.isNull(urlServicesMapping) || !urlServicesMapping.isValid()) { log.error("URL service mapping validation failed for request URI: {}", requestURI); return Utils.setGatewayResponse(HttpStatus.NOT_FOUND); } System.out.println("hey"); Map<String, Object> requestBody = request.body(Map.class); for (Map.Entry<String, Object> entry : requestBody.entrySet()) { System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue()); } System.out.println("heyyy"); if (eligibleForRequestBodyMutation(request, urlServicesMapping)) { // && // Integer.parseInt((request.headers().firstHeader(HttpHeaders.CONTENT_LENGTH))) != 0) { try { ServerRequest modifiedRequest = BodyFilterFunctions.modifyRequestBody( Map.class, Map.class, null, new BodyFilterFunctions.RewriteFunction<Map, Map>() {

                    @Override
                    public Map apply(ServerRequest serverRequest, Map map) {
                      log.info("Original Request Body:{}", map);
                      if (map == null) {
                        return (Map) Mono.empty();
                      }
                      if (!urlServicesMapping.isDoNotReplaceBodyContext()) {
                        map = replaceBodyContext(request, map);
                      }
                      if (urlServicesMapping.isSanitizationRequired()) {
                        map = sanitizeUserInput(map);
                      }
                      return Mono.justOrEmpty(map).block();
                    }
                  })
              .apply(request);
      return next.handle(modifiedRequest);
    } catch (Exception e) {
      log.error("Error processing request: {}", targetApi, e);
      return Utils.setGatewayResponse(HttpStatus.INTERNAL_SERVER_ERROR);
    }
  }
  return next.handle(request);
} catch (Exception e) {
  log.error("Error occurred while processing request: {}", targetApi, e);
  return Utils.setGatewayResponse(HttpStatus.INTERNAL_SERVER_ERROR);
}

}

private Map<String, Object> replaceBodyContext( ServerRequest request, Map<String, Object> requestBody) { CustomerContext context = (CustomerContext) request.attributes().get(Constants.CUSTOMER_CONTEXT); return replaceBodyContextUsingContext(requestBody, context); }

private boolean eligibleForRequestBodyMutation( ServerRequest request, UrlServicesMapping urlServiceMapping) { if (request.method() == HttpMethod.GET || !urlServiceMapping.shouldMutateRequestBody()) { return false; } String contentType = request.headers().firstHeader(HttpHeaders.CONTENT_TYPE); return StringUtils.isNotBlank(contentType) && contentType.contains(Constants.APPLICATION_JSON); }

public Map<String, Object> replaceBodyContextUsingContext( Map<String, Object> contentToMutate, CustomerContext context) { if (Objects.nonNull(contentToMutate) && Objects.nonNull(context)) { try { String stringContent = objectMapper.writeValueAsString(contentToMutate); stringContent = Utils.replaceStringContext(stringContent, context); return Utils.mapReader.readValue(stringContent); } catch (JsonProcessingException e) { log.error( "Error while trying to replace context for content: {} with customer context: {}", contentToMutate, context, e); } } return contentToMutate; }

private Map<String, Object> sanitizeUserInput(Map<String, Object> bufferData) { return (Map<String, Object>) sanitizeData(bufferData); }

private Object sanitizeData(Object data) { if (Objects.isNull(data)) { return null; } if (data instanceof String) { return sanitizeStringData(data.toString()); } else if (data instanceof Map) { Map<String, Object> map = (Map<String, Object>) data; if (MapUtils.isEmpty(map)) { return data; } return map.entrySet().stream() .collect(MapCollector.toMap(Map.Entry::getKey, entry -> sanitizeData(entry.getValue()))); } else if (data instanceof List) { List

aws / serverless-java-container