Add protobuf message provider

Author: jlisam

runtime/jaxrs/src/main/java/com/flit/runtime/jaxrs/FlitExceptionMapper.java

@@ -8,9 +8,11 @@
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.Response;
 import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+@Provider
 public class FlitExceptionMapper implements ExceptionMapper<FlitException> {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(FlitExceptionMapper.class);

runtime/jaxrs/src/main/java/com/flit/runtime/jaxrs/InvalidProtobufExceptionMapper.java

@@ -0,0 +1,36 @@
+package com.flit.runtime.jaxrs;
+
+import com.flit.runtime.ErrorCode;
+import com.google.protobuf.InvalidProtocolBufferException;
+import java.util.HashMap;
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.ExceptionMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class InvalidProtobufExceptionMapper implements
+    ExceptionMapper<InvalidProtocolBufferException> {
+
+  private static final Logger LOGGER = LoggerFactory
+      .getLogger(InvalidProtobufExceptionMapper.class);
+
+  @Context private HttpServletRequest request;
+
+  @Override
+  public Response toResponse(InvalidProtocolBufferException exception) {
+    LOGGER.error("InvalidProtocolBufferException: request = {}, method = {}, msg= {}",
+        request.getRequestURI(), request.getMethod(), exception.getMessage(), exception);
+
+    Map<String, Object> response = new HashMap<>();
+    response.put("code", ErrorCode.INVALID_ARGUMENT.getErrorCode());
+    response.put("msg", exception.getMessage());
+    return Response.status(ErrorCode.INVALID_ARGUMENT.getHttpStatus())
+        .type(MediaType.APPLICATION_JSON)
+        .entity(response)
+        .build();
+  }
+}

runtime/jaxrs/src/main/java/com/flit/runtime/jaxrs/ProtobufMessageProvider.java

@@ -0,0 +1,97 @@
+package com.flit.runtime.jaxrs;
+
+import com.google.protobuf.Message;
+import com.google.protobuf.util.JsonFormat;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.nio.charset.StandardCharsets;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class ProtobufMessageProvider implements MessageBodyWriter<Message>,
+    MessageBodyReader<Message> {
+
+  @Override
+  public boolean isWriteable(Class<?> type, Type genericType,
+      Annotation[] annotations, MediaType mediaType) {
+    return Message.class.isAssignableFrom(type) && (
+        "json".equals(mediaType.getSubtype()) || "protobuf".equals(mediaType.getSubtype()));
+  }
+
+  @Override
+  public long getSize(Message t, Class<?> type,
+      Type genericType, Annotation[] annotations,
+      MediaType mediaType) {
+    if (t == null) {
+      return -1;
+    }
+    ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
+    try {
+      writeTo(t, type, genericType, annotations, mediaType, null, out);
+    } catch (java.io.IOException e) {
+      return -1;
+    }
+    return out.size();
+  }
+
+  @Override
+  public void writeTo(Message t, Class<?> type,
+      Type genericType, Annotation[] annotations,
+      MediaType mediaType,
+      MultivaluedMap<String, Object> httpHeaders,
+      OutputStream entityStream)
+      throws IOException, WebApplicationException {
+    switch (mediaType.getSubtype()) {
+      case "protobuf":
+        t.writeTo(entityStream);
+        break;
+      case "json":
+        entityStream
+            .write(JsonFormat.printer().print(t).getBytes(StandardCharsets.UTF_8));
+        break;
+      default:
+        throw new WebApplicationException("MediaType not supported!");
+    }
+  }
+
+  @Override
+  public boolean isReadable(Class<?> type, Type genericType,
+      Annotation[] annotations, MediaType mediaType) {
+    return Message.class.isAssignableFrom(type) && (
+        "json".equals(mediaType.getSubtype()) || "protobuf".equals(mediaType.getSubtype()));
+  }
+
+  @Override
+  public Message readFrom(Class<Message> type, Type genericType, Annotation[] annotations,
+      MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
+      throws WebApplicationException {
+    try {
+      switch (mediaType.getSubtype()) {
+        case "protobuf":
+          Method m = type.getMethod("parseFrom", InputStream.class);
+          return (Message) m.invoke(null, entityStream);
+        case "json":
+          Message.Builder msg = (Message.Builder) type
+              .getMethod("newBuilder").invoke(null);
+          JsonFormat.parser()
+              .merge(new InputStreamReader(entityStream), msg);
+          return msg.build();
+        default:
+          throw new WebApplicationException("MediaType not supported!");
+      }
+    } catch (Exception e) {
+      throw new WebApplicationException(e);
+    }
+  }
+}

runtime/jaxrs/src/test/java/com/flit/runtime/jaxrs/InvalidProtobufExceptionMapperTest.java

@@ -0,0 +1,40 @@
+package com.flit.runtime.jaxrs;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import java.util.Map;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class InvalidProtobufExceptionMapperTest {
+
+  @Mock
+  private HttpServletRequest request;
+
+  @InjectMocks
+  private InvalidProtobufExceptionMapper mapper = new InvalidProtobufExceptionMapper();
+
+  @Before
+  public void setup() {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  public void testToResponse() {
+    InvalidProtocolBufferException exception = new InvalidProtocolBufferException(
+        "something happened");
+    Response response = mapper.toResponse(exception);
+    assertEquals(response.getStatus(), 400);
+    Map<String, Object> expectedResult = Map
+        .of("msg", "something happened", "code", "invalid_argument");
+    assertEquals(response.getEntity(), expectedResult);
+    assertEquals(response.getMediaType(), MediaType.APPLICATION_JSON_TYPE);
+  }
+}