GsonMessageReader.java

  1. /*
  2.  * Copyright 2020 Providence Authors
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements. See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership. The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License. You may obtain a copy of the License at
  11.  *
  12.  *   http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing,
  15.  * software distributed under the License is distributed on an
  16.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17.  * KIND, either express or implied. See the License for the
  18.  * specific language governing permissions and limitations
  19.  * under the License.
  20.  */
  21. package net.morimekta.proto.gson.sio;

  23. import com.google.gson.JsonParseException;
  24. import com.google.gson.stream.JsonReader;
  25. import com.google.gson.stream.JsonToken;
  26. import com.google.protobuf.Any;
  27. import com.google.protobuf.ByteString;
  28. import com.google.protobuf.Descriptors;
  29. import com.google.protobuf.Duration;
  30. import com.google.protobuf.Message;
  31. import com.google.protobuf.Timestamp;
  32. import net.morimekta.collect.ListBuilder;
  33. import net.morimekta.collect.MapBuilder;
  34. import net.morimekta.collect.UnmodifiableList;
  35. import net.morimekta.collect.UnmodifiableMap;
  36. import net.morimekta.proto.MorimektaOptions;
  37. import net.morimekta.proto.ProtoEnum;
  38. import net.morimekta.proto.ProtoMessageBuilder;
  39. import net.morimekta.proto.gson.ProtoTypeOptions;
  40. import net.morimekta.proto.sio.MessageReader;
  41. import net.morimekta.proto.utils.GoogleTypesUtil;
  42. import net.morimekta.strings.io.LineBufferedReader;

  44. import java.io.Closeable;
  45. import java.io.IOException;
  46. import java.io.Reader;
  47. import java.time.Instant;
  48. import java.util.Base64;
  49. import java.util.List;
  50. import java.util.Map;

  52. import static java.lang.Boolean.parseBoolean;
  53. import static java.lang.Integer.parseInt;
  54. import static java.lang.Long.parseLong;
  55. import static net.morimekta.proto.gson.ProtoTypeOptions.Option.FAIL_ON_NULL_VALUE;
  56. import static net.morimekta.proto.gson.ProtoTypeOptions.Option.FAIL_ON_UNKNOWN_FIELD;
  57. import static net.morimekta.proto.gson.ProtoTypeOptions.Option.IGNORE_UNKNOWN_ANY_TYPE;
  58. import static net.morimekta.proto.gson.ProtoTypeOptions.Option.LENIENT_READER;
  59. import static net.morimekta.proto.gson.ProtoTypeOptions.Value.ANY_TYPE_FIELD_NAME;
  60. import static net.morimekta.proto.utils.FieldUtil.getMapKeyDescriptor;
  61. import static net.morimekta.proto.utils.FieldUtil.getMapValueDescriptor;
  62. import static net.morimekta.proto.utils.JsonNameUtil.ANY_TYPE_FIELDS;
  63. import static net.morimekta.proto.utils.JsonNameUtil.NUMERIC_FIELD_ID;
  64. import static net.morimekta.proto.utils.JsonNameUtil.getJsonFieldMap;
  65. import static net.morimekta.proto.utils.ProtoTypeRegistry.getTypeNameFromTypeUrl;
  66. import static net.morimekta.proto.utils.ProtoTypeRegistry.getTypeUrl;

  68. /**
  69.  * Reader for reading a JSON message from a stream.
  70.  */
  71. public class GsonMessageReader implements MessageReader, Closeable {
  72.     private final JsonReader       reader;
  73.     private final ProtoTypeOptions options;

  75.     /**
  76.      * @param in      Reader to read from.
  77.      * @param options Proto options.
  78.      */
  79.     public GsonMessageReader(Reader in, ProtoTypeOptions options) {
  80.         this(makeJsonReader(in, options.isEnabled(LENIENT_READER)), options);
  81.     }

  83.     /**
  84.      * @param reader  JSON Reader to read from.
  85.      * @param options Proto options.
  86.      */
  87.     public GsonMessageReader(JsonReader reader, ProtoTypeOptions options) {
  88.         this.reader = reader;
  89.         this.options = options;
  90.     }

  92.     @Override
  93.     public void close() throws IOException {
  94.         reader.close();
  95.     }

  97.     @Override
  98.     public Message read(Descriptors.Descriptor descriptor) throws IOException {
  99.         if (reader.peek() == JsonToken.NULL) {
  100.             reader.nextNull();
  101.             return null;
  102.         }
  103.         if (reader.peek() == JsonToken.BEGIN_ARRAY) {
  104.             if (!descriptor.getOptions().getExtension(MorimektaOptions.compact)) {
  105.                 throw new JsonParseException("Compact format not allowed for " + descriptor.getFullName() + " at " + reader.getPath());
  106.             }
  107.             ProtoMessageBuilder builder = new ProtoMessageBuilder(descriptor);
  108.             List<Descriptors.FieldDescriptor> fields = descriptor.getFields();

  110.             reader.beginArray();
  111.             int idx = 0;
  112.             while (reader.peek() != JsonToken.END_ARRAY) {
  113.                 if (idx >= fields.size()) {
  114.                     if (options.isEnabled(FAIL_ON_NULL_VALUE)) {
  115.                         throw new JsonParseException("Data after last field at " + reader.getPath());
  116.                     }
  117.                     reader.skipValue();
  118.                 } else if (reader.peek() == JsonToken.NULL) {
  119.                     reader.nextNull();
  120.                 } else {
  121.                     Descriptors.FieldDescriptor field = fields.get(idx);
  122.                     builder.set(field, readSingleValue(field));
  123.                 }
  124.                 idx++;
  125.             }
  126.             reader.endArray();
  127.             return builder.getMessage().build();
  128.         } else if (reader.peek() == JsonToken.BEGIN_OBJECT) {
  129.             ProtoMessageBuilder builder = new ProtoMessageBuilder(descriptor);
  130.             Map<String, Descriptors.FieldDescriptor> jsonFields = getJsonFieldMap(descriptor);

  132.             reader.beginObject();
  133.             boolean first = true;
  134.             while (reader.peek() != JsonToken.END_OBJECT) {
  135.                 String name = reader.nextName();
  136.                 if (first) {
  137.                     first = false;
  138.                     if (descriptor.equals(Any.getDescriptor()) &&
  139.                         (ANY_TYPE_FIELDS.contains(name) || options.getValue(ANY_TYPE_FIELD_NAME).equals(name))) {
  140.                         var anyBuilder = (Any.Builder) builder.getMessage();
  141.                         var typeUrl = reader.nextString();
  142.                         var packedType = options.getRegistry().messageTypeByTypeUrl(typeUrl);
  143.                         if (packedType != null) {
  144.                             var packedJsonFields = getJsonFieldMap(packedType);
  145.                             var packedBuilder = new ProtoMessageBuilder(packedType);
  146.                             while (reader.peek() != JsonToken.END_OBJECT) {
  147.                                 findFieldAndReadValue(packedBuilder, reader.nextName(), packedType, packedJsonFields);
  148.                             }
  149.                             anyBuilder.setTypeUrl(getTypeUrl(packedType));
  150.                             anyBuilder.setValue(packedBuilder.getMessage().build().toByteString());
  151.                             break;
  152.                         } else if (options.isEnabled(IGNORE_UNKNOWN_ANY_TYPE)) {
  153.                             anyBuilder.setTypeUrl("type.googleapis.com/" + getTypeNameFromTypeUrl(typeUrl));
  154.                             // ignore entire struct.
  155.                             while (reader.peek() != JsonToken.END_OBJECT) {
  156.                                 reader.nextName();
  157.                                 reader.skipValue();
  158.                             }
  159.                         } else {
  160.                             throw new JsonParseException("Unknown type " + typeUrl + " at " + reader.getPreviousPath());
  161.                         }
  162.                         break;
  163.                     }
  164.                 }
  165.                 findFieldAndReadValue(builder, name, descriptor, jsonFields);
  166.             }
  167.             reader.endObject();
  168.             return builder.getMessage().build();
  169.         } else {
  170.             if (Timestamp.getDescriptor().equals(descriptor)) {
  171.                 var builder = Timestamp.newBuilder();
  172.                 if (reader.peek() == JsonToken.NUMBER) {
  173.                     // timestamp as fractional seconds since epoch.
  174.                     var timestampDbl = reader.nextDouble();
  175.                     var timestampS = (long) timestampDbl;
  176.                     var micros = (int) Math.round((timestampDbl - timestampS) * 1_000_000L);
  177.                     builder.setSeconds(timestampS);
  178.                     builder.setNanos(micros * 1000);
  179.                 } else if (reader.peek() == JsonToken.STRING) {
  180.                     // ISO date string.
  181.                     var instant = parseIsoDateTime(reader, reader.nextString());
  182.                     builder.setSeconds(instant.getEpochSecond());
  183.                     builder.setNanos(instant.getNano());
  184.                 } else {
  185.                     throw new JsonParseException("Expected '{' or '[' or unix timestamp or ISO date or null, but found " + reader.peek() + " at " + reader.getPath());
  186.                 }
  187.                 return builder.build();
  188.             } else if (Duration.getDescriptor().equals(descriptor)) {
  189.                 var builder = Duration.newBuilder();
  190.                 if (reader.peek() == JsonToken.NUMBER) {
  191.                     // duration as seconds.
  192.                     var durationDbl = reader.nextDouble();
  193.                     var durationS = (long) durationDbl;
  194.                     var micros = (int) Math.round((durationDbl - durationS) * 1_000_000L);
  195.                     builder.setSeconds(durationS);
  196.                     builder.setNanos(micros * 1000);
  197.                 } else if (reader.peek() == JsonToken.STRING) {
  198.                     var duration = parseDuration(reader, reader.nextString());
  199.                     builder.setSeconds(duration.getSeconds());
  200.                     builder.setNanos(duration.getNano());
  201.                 } else {
  202.                     throw new JsonParseException("Expected '{' or '[', duration number or string or null, but found " + reader.peek() + " at " + reader.getPath());
  203.                 }
  204.                 return builder.build();
  205.             }
  206.             throw new JsonParseException("Expected '{' or '[' or null, but found: " + reader.peek() + " at " + reader.getPath());
  207.         }
  208.     }

  210.     private void findFieldAndReadValue(ProtoMessageBuilder builder,
  211.                                        String fieldName,
  212.                                        Descriptors.Descriptor descriptor,
  213.                                        Map<String, Descriptors.FieldDescriptor> jsonFields) throws IOException {
  214.         Descriptors.FieldDescriptor field;
  215.         if (NUMERIC_FIELD_ID.matcher(fieldName).matches()) {
  216.             int number = parseInt(fieldName);
  217.             field = descriptor.findFieldByNumber(number);
  218.             if (field == null) {
  219.                 field = options.getRegistry().extensionByScopeAndNumber(descriptor, number);
  220.             }
  221.         } else {
  222.             field = jsonFields.get(fieldName);
  223.             if (field == null) {
  224.                 field = options.getRegistry().extensionByScopeAndName(descriptor, fieldName);
  225.             }
  226.         }
  227.         if (field == null) {
  228.             if (options.isEnabled(FAIL_ON_UNKNOWN_FIELD)) {
  229.                 throw new JsonParseException("Unknown field at " + reader.getPath());
  230.             }
  231.             reader.skipValue();
  232.         } else {
  233.             Object o = readValue(field);
  234.             if (o != null) {
  235.                 builder.set(field, o);
  236.             } else if (options.isEnabled(FAIL_ON_NULL_VALUE)) {
  237.                 throw new JsonParseException("Null value at " + reader.getPath());
  238.             }
  239.         }
  240.     }

  242.     private Object readValue(Descriptors.FieldDescriptor descriptor) throws IOException {
  243.         if (reader.peek() == JsonToken.NULL) {
  244.             reader.nextNull();
  245.             return null;
  246.         }
  247.         if (descriptor.isRepeated()) {
  248.             if (descriptor.isMapField()) {
  249.                 var keyDescriptor = getMapKeyDescriptor(descriptor);
  250.                 var valueDescriptor = getMapValueDescriptor(descriptor);

  252.                 MapBuilder<Object, Object> map = UnmodifiableMap.newBuilder();
  253.                 reader.beginObject();
  254.                 while (reader.peek() != JsonToken.END_OBJECT) {
  255.                     var key = readMapKey(keyDescriptor);
  256.                     var value = readSingleValue(valueDescriptor);
  257.                     if (value != null) {
  258.                         map.put(key, value);
  259.                     } else if (options.isEnabled(FAIL_ON_NULL_VALUE)) {
  260.                         throw new JsonParseException("Null value in map at " + reader.getPreviousPath());
  261.                     }
  262.                 }
  263.                 reader.endObject();
  264.                 return map.build();
  265.             } else {
  266.                 ListBuilder<Object> list = UnmodifiableList.newBuilder();
  267.                 reader.beginArray();
  268.                 while (reader.peek() != JsonToken.END_ARRAY) {
  269.                     list.add(readSingleValue(descriptor));
  270.                 }
  271.                 reader.endArray();
  272.                 return list.build();
  273.             }
  274.         } else {
  275.             return readSingleValue(descriptor);
  276.         }
  277.     }

  279.     private Object readMapKey(Descriptors.FieldDescriptor descriptor) throws IOException {
  280.         var name = reader.nextName();
  281.         switch (descriptor.getType().getJavaType()) {
  282.             case BOOLEAN: {
  283.                 return parseBoolean(name);
  284.             }
  285.             case INT: {
  286.                 return parseInt(name);
  287.             }
  288.             case LONG: {
  289.                 return parseLong(name);
  290.             }
  291.             case STRING: {
  292.                 return name;
  293.             }
  294.             default: {
  295.                 // Usually not testable.
  296.                 throw new IOException("Unhandled map key type: " + descriptor.getType());
  297.             }
  298.         }
  299.     }

  301.     private Object readSingleValue(Descriptors.FieldDescriptor descriptor) throws IOException {
  302.         if (reader.peek() == JsonToken.NULL) {
  303.             return null;
  304.         }
  305.         switch (descriptor.getType().getJavaType()) {
  306.             case BOOLEAN: {
  307.                 return reader.nextBoolean();
  308.             }
  309.             case INT: {
  310.                 try {
  311.                     return reader.nextInt();
  312.                 } catch (NumberFormatException e) {
  313.                     throw new JsonParseException("Invalid int value \"" + reader.nextString() + "\" at " + reader.getPath());
  314.                 }
  315.             }
  316.             case LONG: {
  317.                 try {
  318.                     return reader.nextLong();
  319.                 } catch (NumberFormatException e) {
  320.                     throw new JsonParseException("Invalid long value \"" + reader.nextString() + "\" at " + reader.getPath());
  321.                 }
  322.             }
  323.             case FLOAT: {
  324.                 try {
  325.                     return (float) reader.nextDouble();
  326.                 } catch (NumberFormatException e) {
  327.                     throw new JsonParseException("Invalid float value \"" + reader.nextString() + "\" at " + reader.getPath());
  328.                 }
  329.             }
  330.             case DOUBLE: {
  331.                 try {
  332.                     return reader.nextDouble();
  333.                 } catch (NumberFormatException e) {
  334.                     throw new JsonParseException("Invalid double value \"" + reader.nextString() + "\" at " + reader.getPath());
  335.                 }
  336.             }
  337.             case STRING: {
  338.                 return reader.nextString();
  339.             }
  340.             case BYTE_STRING: {
  341.                 return parseBase64(reader.nextString());
  342.             }
  343.             case ENUM: {
  344.                 return readEnum(descriptor.getEnumType());
  345.             }
  346.             case MESSAGE: {
  347.                 return read(descriptor.getMessageType());
  348.             }
  349.             default: {
  350.                 // Usually not testable.
  351.                 throw new JsonParseException("Unhandled value type: " + descriptor.getType());
  352.             }
  353.         }
  354.     }

  356.     private ByteString parseBase64(String value) {
  357.         try {
  358.             return ByteString.copyFrom(Base64.getDecoder().decode(value));
  359.         } catch (IllegalArgumentException e) {
  360.             throw new JsonParseException(e.getMessage() + " at " + reader.getPreviousPath(), e);
  361.         }
  362.     }

  364.     private Object readEnum(Descriptors.EnumDescriptor descriptor) throws IOException {
  365.         ProtoEnum<?> type = ProtoEnum.getEnumDescriptor(descriptor);
  366.         if (reader.peek() == JsonToken.NUMBER) {
  367.             var num = reader.nextInt();
  368.             return type.valueForNumber(num);
  369.         } else {
  370.             var name = reader.nextString();
  371.             return type.valueForName(name);
  372.         }
  373.     }

  375.     private static JsonReader makeJsonReader(Reader in, boolean lenient) {
  376.         JsonReader reader = new JsonReader(new LineBufferedReader(in));
  377.         if (lenient) {
  378.             reader.setLenient(true);
  379.         }
  380.         return reader;
  381.     }

  383.     private static java.time.Duration parseDuration(JsonReader reader, String value) {
  384.         try {
  385.             return GoogleTypesUtil.parseJavaDurationString(value);
  386.         } catch (IllegalArgumentException e) {
  387.             throw new JsonParseException(e.getMessage() + " at " + reader.getPreviousPath(), e);
  388.         }
  389.     }

  391.     private static Instant parseIsoDateTime(JsonReader reader, String value) {
  392.         try {
  393.             return GoogleTypesUtil.parseJavaTimestampString(value);
  394.         } catch (IllegalArgumentException e) {
  395.             throw new JsonParseException(e.getMessage() + " at " + reader.getPreviousPath());
  396.         }
  397.     }
  398. }
Created with JaCoCo 0.8.8.202204050719