diff --git a/common/src/main/java/dev/cel/common/values/BUILD.bazel b/common/src/main/java/dev/cel/common/values/BUILD.bazel index 15c70a9e3..3656da6ca 100644 --- a/common/src/main/java/dev/cel/common/values/BUILD.bazel +++ b/common/src/main/java/dev/cel/common/values/BUILD.bazel @@ -76,7 +76,6 @@ java_library( ":cel_value", "//:auto_value", "//common:error_codes", - "//common:options", "//common:runtime_exception", "//common/annotations", "//common/types", @@ -94,7 +93,25 @@ java_library( ], deps = [ "@maven//:com_google_errorprone_error_prone_annotations", + ], +) + +java_library( + name = "base_proto_cel_value_converter", + srcs = ["BaseProtoCelValueConverter.java"], + tags = [ + ], + deps = [ + ":cel_byte_string", + ":cel_value", + ":values", + "//common/annotations", + "//common/internal:well_known_proto", + "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", + "@maven//:com_google_protobuf_protobuf_java", + "@maven//:com_google_protobuf_protobuf_java_util", + "@maven_android//:com_google_protobuf_protobuf_javalite", ], ) @@ -104,22 +121,19 @@ java_library( tags = [ ], deps = [ + ":base_proto_cel_value_converter", ":cel_value", ":values", "//:auto_value", - "//common:options", "//common/annotations", "//common/internal:cel_descriptor_pools", "//common/internal:dynamic_proto", "//common/internal:well_known_proto", "//common/types", - "//common/types:cel_types", "//common/types:type_providers", - "//common/values:cel_byte_string", "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", "@maven//:com_google_protobuf_protobuf_java", - "@maven//:com_google_protobuf_protobuf_java_util", "@maven//:org_jspecify_jspecify", "@maven_android//:com_google_protobuf_protobuf_javalite", ], diff --git a/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java b/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java new file mode 100644 index 000000000..e0d48136f --- /dev/null +++ b/common/src/main/java/dev/cel/common/values/BaseProtoCelValueConverter.java @@ -0,0 +1,231 @@ +// Copyright 2025 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dev.cel.common.values; + +import static com.google.common.collect.ImmutableList.toImmutableList; +import static com.google.common.collect.ImmutableMap.toImmutableMap; +import static com.google.common.math.LongMath.checkedAdd; +import static com.google.common.math.LongMath.checkedSubtract; + +import com.google.common.base.Preconditions; +import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.BoolValue; +import com.google.protobuf.ByteString; +import com.google.protobuf.DoubleValue; +import com.google.protobuf.FloatValue; +import com.google.protobuf.Int32Value; +import com.google.protobuf.Int64Value; +import com.google.protobuf.MessageLite; +import com.google.protobuf.MessageLiteOrBuilder; +import com.google.protobuf.StringValue; +import com.google.protobuf.Struct; +import com.google.protobuf.Timestamp; +import com.google.protobuf.UInt32Value; +import com.google.protobuf.UInt64Value; +import com.google.protobuf.Value; +import com.google.protobuf.util.Durations; +import com.google.protobuf.util.Timestamps; +import dev.cel.common.annotations.Internal; +import dev.cel.common.internal.WellKnownProto; +import java.time.Duration; +import java.time.Instant; +import java.util.Optional; + +/** + * {@code BaseProtoCelValueConverter} contains the common logic for converting between native Java + * and protobuf objects to {@link CelValue}. This base class is inherited by {@code + * ProtoCelValueConverter} and {@code ProtoLiteCelValueConverter} to perform the conversion using + * full and lite variants of protobuf messages respectively. + * + *

CEL Library Internals. Do Not Use. + */ +@Immutable +@Internal +public abstract class BaseProtoCelValueConverter extends CelValueConverter { + + public abstract CelValue fromProtoMessageToCelValue(String protoTypeName, MessageLite msg); + + /** + * Adapts a {@link CelValue} to a native Java object. The CelValue is adapted into protobuf object + * when an equivalent exists. + */ + @Override + public Object fromCelValueToJavaObject(CelValue celValue) { + Preconditions.checkNotNull(celValue); + + if (celValue instanceof TimestampValue) { + return TimeUtils.toProtoTimestamp(((TimestampValue) celValue).value()); + } else if (celValue instanceof DurationValue) { + return TimeUtils.toProtoDuration(((DurationValue) celValue).value()); + } else if (celValue instanceof BytesValue) { + return ByteString.copyFrom(((BytesValue) celValue).value().toByteArray()); + } else if (celValue.equals(NullValue.NULL_VALUE)) { + return com.google.protobuf.NullValue.NULL_VALUE; + } + + return super.fromCelValueToJavaObject(celValue); + } + + /** {@inheritDoc} Protobuf semantics take precedence for conversion. */ + @Override + public CelValue fromJavaObjectToCelValue(Object value) { + Preconditions.checkNotNull(value); + + Optional wellKnownProto = WellKnownProto.getByClass(value.getClass()); + if (wellKnownProto.isPresent()) { + return fromWellKnownProtoToCelValue((MessageLiteOrBuilder) value, wellKnownProto.get()); + } + + if (value instanceof ByteString) { + return BytesValue.create(CelByteString.of(((ByteString) value).toByteArray())); + } else if (value instanceof com.google.protobuf.NullValue) { + return NullValue.NULL_VALUE; + } + + return super.fromJavaObjectToCelValue(value); + } + + protected CelValue fromWellKnownProtoToCelValue( + MessageLiteOrBuilder message, WellKnownProto wellKnownProto) { + switch (wellKnownProto) { + case JSON_VALUE: + return adaptJsonValueToCelValue((Value) message); + case JSON_STRUCT_VALUE: + return adaptJsonStructToCelValue((Struct) message); + case JSON_LIST_VALUE: + return adaptJsonListToCelValue((com.google.protobuf.ListValue) message); + case DURATION: + return DurationValue.create( + TimeUtils.toJavaDuration((com.google.protobuf.Duration) message)); + case TIMESTAMP: + return TimestampValue.create(TimeUtils.toJavaInstant((Timestamp) message)); + case BOOL_VALUE: + return fromJavaPrimitiveToCelValue(((BoolValue) message).getValue()); + case BYTES_VALUE: + return fromJavaPrimitiveToCelValue( + ((com.google.protobuf.BytesValue) message).getValue().toByteArray()); + case DOUBLE_VALUE: + return fromJavaPrimitiveToCelValue(((DoubleValue) message).getValue()); + case FLOAT_VALUE: + return fromJavaPrimitiveToCelValue(((FloatValue) message).getValue()); + case INT32_VALUE: + return fromJavaPrimitiveToCelValue(((Int32Value) message).getValue()); + case INT64_VALUE: + return fromJavaPrimitiveToCelValue(((Int64Value) message).getValue()); + case STRING_VALUE: + return fromJavaPrimitiveToCelValue(((StringValue) message).getValue()); + case UINT32_VALUE: + return UintValue.create(((UInt32Value) message).getValue(), true); + case UINT64_VALUE: + return UintValue.create(((UInt64Value) message).getValue(), true); + default: + throw new UnsupportedOperationException( + "Unsupported message to CelValue conversion - " + message); + } + } + + private CelValue adaptJsonValueToCelValue(Value value) { + switch (value.getKindCase()) { + case BOOL_VALUE: + return fromJavaPrimitiveToCelValue(value.getBoolValue()); + case NUMBER_VALUE: + return fromJavaPrimitiveToCelValue(value.getNumberValue()); + case STRING_VALUE: + return fromJavaPrimitiveToCelValue(value.getStringValue()); + case LIST_VALUE: + return adaptJsonListToCelValue(value.getListValue()); + case STRUCT_VALUE: + return adaptJsonStructToCelValue(value.getStructValue()); + case NULL_VALUE: + case KIND_NOT_SET: // Fall-through is intended + return NullValue.NULL_VALUE; + } + throw new UnsupportedOperationException( + "Unsupported Json to CelValue conversion: " + value.getKindCase()); + } + + private ListValue adaptJsonListToCelValue(com.google.protobuf.ListValue listValue) { + return ImmutableListValue.create( + listValue.getValuesList().stream() + .map(this::adaptJsonValueToCelValue) + .collect(toImmutableList())); + } + + // TODO: Investigate changing MapValue key to StringValue + private MapValue adaptJsonStructToCelValue(Struct struct) { + return ImmutableMapValue.create( + struct.getFieldsMap().entrySet().stream() + .collect( + toImmutableMap( + e -> fromJavaObjectToCelValue(e.getKey()), + e -> adaptJsonValueToCelValue(e.getValue())))); + } + + /** Helper to convert between java.util.time and protobuf duration/timestamp. */ + private static class TimeUtils { + private static final int NANOS_PER_SECOND = 1000000000; + + private static Instant toJavaInstant(Timestamp timestamp) { + timestamp = normalizedTimestamp(timestamp.getSeconds(), timestamp.getNanos()); + return Instant.ofEpochSecond(timestamp.getSeconds(), timestamp.getNanos()); + } + + private static Duration toJavaDuration(com.google.protobuf.Duration duration) { + duration = normalizedDuration(duration.getSeconds(), duration.getNanos()); + return java.time.Duration.ofSeconds(duration.getSeconds(), duration.getNanos()); + } + + private static Timestamp toProtoTimestamp(Instant instant) { + return normalizedTimestamp(instant.getEpochSecond(), instant.getNano()); + } + + private static com.google.protobuf.Duration toProtoDuration(Duration duration) { + return normalizedDuration(duration.getSeconds(), duration.getNano()); + } + + private static Timestamp normalizedTimestamp(long seconds, int nanos) { + if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) { + seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND); + nanos = nanos % NANOS_PER_SECOND; + } + if (nanos < 0) { + nanos = nanos + NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding) + seconds = checkedSubtract(seconds, 1); + } + Timestamp timestamp = Timestamp.newBuilder().setSeconds(seconds).setNanos(nanos).build(); + return Timestamps.checkValid(timestamp); + } + + private static com.google.protobuf.Duration normalizedDuration(long seconds, int nanos) { + if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) { + seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND); + nanos %= NANOS_PER_SECOND; + } + if (seconds > 0 && nanos < 0) { + nanos += NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding) + seconds--; // no overflow since seconds is positive (and we're decrementing) + } + if (seconds < 0 && nanos > 0) { + nanos -= NANOS_PER_SECOND; // no overflow since nanos is positive (and we're subtracting) + seconds++; // no overflow since seconds is negative (and we're incrementing) + } + com.google.protobuf.Duration duration = + com.google.protobuf.Duration.newBuilder().setSeconds(seconds).setNanos(nanos).build(); + return Durations.checkValid(duration); + } + } + + protected BaseProtoCelValueConverter() {} +} diff --git a/common/src/main/java/dev/cel/common/values/CelByteString.java b/common/src/main/java/dev/cel/common/values/CelByteString.java index 196af790b..d8a50949e 100644 --- a/common/src/main/java/dev/cel/common/values/CelByteString.java +++ b/common/src/main/java/dev/cel/common/values/CelByteString.java @@ -14,7 +14,6 @@ package dev.cel.common.values; -import com.google.common.base.Preconditions; import com.google.errorprone.annotations.Immutable; import java.util.Arrays; @@ -30,7 +29,9 @@ public final class CelByteString { private volatile int hash = 0; public static CelByteString of(byte[] buffer) { - Preconditions.checkNotNull(buffer); + if (buffer == null) { + throw new NullPointerException("buffer cannot be null"); + } if (buffer.length == 0) { return EMPTY; } diff --git a/common/src/main/java/dev/cel/common/values/CelValueConverter.java b/common/src/main/java/dev/cel/common/values/CelValueConverter.java index 83275e3c1..c938ccc5f 100644 --- a/common/src/main/java/dev/cel/common/values/CelValueConverter.java +++ b/common/src/main/java/dev/cel/common/values/CelValueConverter.java @@ -18,7 +18,6 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.primitives.UnsignedLong; -import dev.cel.common.CelOptions; import dev.cel.common.annotations.Internal; import java.util.Map; import java.util.Map.Entry; @@ -34,8 +33,6 @@ @Internal abstract class CelValueConverter { - protected final CelOptions celOptions; - /** Adapts a {@link CelValue} to a plain old Java Object. */ public Object fromCelValueToJavaObject(CelValue celValue) { Preconditions.checkNotNull(celValue); @@ -112,7 +109,7 @@ protected CelValue fromJavaPrimitiveToCelValue(Object value) { } else if (value instanceof Float) { return DoubleValue.create(Double.valueOf((Float) value)); } else if (value instanceof UnsignedLong) { - return UintValue.create(((UnsignedLong) value).longValue(), celOptions.enableUnsignedLongs()); + return UintValue.create(((UnsignedLong) value).longValue(), /* enableUnsignedLongs= */ true); } // Fall back to an Opaque value, as a custom class was supplied in the runtime. The legacy @@ -145,8 +142,5 @@ private MapValue toMapValue(Map map) { return ImmutableMapValue.create(mapBuilder.buildOrThrow()); } - protected CelValueConverter(CelOptions celOptions) { - Preconditions.checkNotNull(celOptions); - this.celOptions = celOptions; - } + protected CelValueConverter() {} } diff --git a/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java b/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java index 16f5cc215..03002a52b 100644 --- a/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java +++ b/common/src/main/java/dev/cel/common/values/ProtoCelValueConverter.java @@ -14,50 +14,30 @@ package dev.cel.common.values; -import static com.google.common.collect.ImmutableList.toImmutableList; -import static com.google.common.collect.ImmutableMap.toImmutableMap; -import static com.google.common.math.LongMath.checkedAdd; -import static com.google.common.math.LongMath.checkedSubtract; - import com.google.common.base.Preconditions; import com.google.errorprone.annotations.Immutable; import com.google.protobuf.Any; -import com.google.protobuf.BoolValue; -import com.google.protobuf.ByteString; import com.google.protobuf.Descriptors.EnumValueDescriptor; import com.google.protobuf.Descriptors.FieldDescriptor; -import com.google.protobuf.DoubleValue; import com.google.protobuf.DynamicMessage; -import com.google.protobuf.FloatValue; -import com.google.protobuf.Int32Value; -import com.google.protobuf.Int64Value; import com.google.protobuf.InvalidProtocolBufferException; import com.google.protobuf.MapEntry; import com.google.protobuf.Message; +import com.google.protobuf.MessageLite; +import com.google.protobuf.MessageLiteOrBuilder; import com.google.protobuf.MessageOrBuilder; -import com.google.protobuf.StringValue; -import com.google.protobuf.Struct; -import com.google.protobuf.Timestamp; -import com.google.protobuf.UInt32Value; -import com.google.protobuf.UInt64Value; -import com.google.protobuf.Value; -import com.google.protobuf.util.Durations; -import com.google.protobuf.util.Timestamps; -import dev.cel.common.CelOptions; import dev.cel.common.annotations.Internal; import dev.cel.common.internal.CelDescriptorPool; import dev.cel.common.internal.DynamicProto; import dev.cel.common.internal.WellKnownProto; -import dev.cel.common.types.CelTypes; -import java.time.Duration; -import java.time.Instant; import java.util.HashMap; import java.util.List; import java.util.Map; /** - * {@code CelValueConverter} handles bidirectional conversion between native Java and protobuf - * objects to {@link CelValue}. + * {@code ProtoCelValueConverter} handles bidirectional conversion between native Java and protobuf + * objects to {@link CelValue}. This converter leverages descriptors, thus requires the full version + * of protobuf implementation. * *

Protobuf semantics take precedence for conversion. For example, CEL's TimestampValue will be * converted into Protobuf's Timestamp instead of java.time.Instant. @@ -66,35 +46,19 @@ */ @Immutable @Internal -public final class ProtoCelValueConverter extends CelValueConverter { +public final class ProtoCelValueConverter extends BaseProtoCelValueConverter { private final CelDescriptorPool celDescriptorPool; private final DynamicProto dynamicProto; /** Constructs a new instance of ProtoCelValueConverter. */ public static ProtoCelValueConverter newInstance( - CelOptions celOptions, CelDescriptorPool celDescriptorPool, DynamicProto dynamicProto) { - return new ProtoCelValueConverter(celOptions, celDescriptorPool, dynamicProto); + CelDescriptorPool celDescriptorPool, DynamicProto dynamicProto) { + return new ProtoCelValueConverter(celDescriptorPool, dynamicProto); } - /** - * Adapts a {@link CelValue} to a native Java object. The CelValue is adapted into protobuf object - * when an equivalent exists. - */ @Override - public Object fromCelValueToJavaObject(CelValue celValue) { - Preconditions.checkNotNull(celValue); - - if (celValue instanceof TimestampValue) { - return TimeUtils.toProtoTimestamp(((TimestampValue) celValue).value()); - } else if (celValue instanceof DurationValue) { - return TimeUtils.toProtoDuration(((DurationValue) celValue).value()); - } else if (celValue instanceof BytesValue) { - return ByteString.copyFrom(((BytesValue) celValue).value().toByteArray()); - } else if (NullValue.NULL_VALUE.equals(celValue)) { - return com.google.protobuf.NullValue.NULL_VALUE; - } - - return super.fromCelValueToJavaObject(celValue); + public CelValue fromProtoMessageToCelValue(String unusedProtoTypeName, MessageLite msg) { + return fromProtoMessageToCelValue((MessageOrBuilder) msg); } /** Adapts a Protobuf message into a {@link CelValue}. */ @@ -112,6 +76,13 @@ public CelValue fromProtoMessageToCelValue(MessageOrBuilder message) { return ProtoMessageValue.create((Message) message, celDescriptorPool, this); } + return fromWellKnownProtoToCelValue(message, wellKnownProto); + } + + @Override + protected CelValue fromWellKnownProtoToCelValue( + MessageLiteOrBuilder msg, WellKnownProto wellKnownProto) { + MessageOrBuilder message = (MessageOrBuilder) msg; switch (wellKnownProto) { case ANY_VALUE: Message unpackedMessage; @@ -122,62 +93,14 @@ public CelValue fromProtoMessageToCelValue(MessageOrBuilder message) { "Unpacking failed for message: " + message.getDescriptorForType().getFullName(), e); } return fromProtoMessageToCelValue(unpackedMessage); - case JSON_VALUE: - return adaptJsonValueToCelValue((Value) message); - case JSON_STRUCT_VALUE: - return adaptJsonStructToCelValue((Struct) message); - case JSON_LIST_VALUE: - return adaptJsonListToCelValue((com.google.protobuf.ListValue) message); - case DURATION: - return DurationValue.create( - TimeUtils.toJavaDuration((com.google.protobuf.Duration) message)); - case TIMESTAMP: - return TimestampValue.create(TimeUtils.toJavaInstant((Timestamp) message)); - case BOOL_VALUE: - return fromJavaPrimitiveToCelValue(((BoolValue) message).getValue()); - case BYTES_VALUE: - return fromJavaPrimitiveToCelValue( - ((com.google.protobuf.BytesValue) message).getValue().toByteArray()); - case DOUBLE_VALUE: - return fromJavaPrimitiveToCelValue(((DoubleValue) message).getValue()); - case FLOAT_VALUE: - return fromJavaPrimitiveToCelValue(((FloatValue) message).getValue()); - case INT32_VALUE: - return fromJavaPrimitiveToCelValue(((Int32Value) message).getValue()); - case INT64_VALUE: - return fromJavaPrimitiveToCelValue(((Int64Value) message).getValue()); - case STRING_VALUE: - return fromJavaPrimitiveToCelValue(((StringValue) message).getValue()); - case UINT32_VALUE: - return UintValue.create( - ((UInt32Value) message).getValue(), celOptions.enableUnsignedLongs()); - case UINT64_VALUE: - return UintValue.create( - ((UInt64Value) message).getValue(), celOptions.enableUnsignedLongs()); default: - throw new UnsupportedOperationException( - "Unsupported message to CelValue conversion - " + message); + return super.fromWellKnownProtoToCelValue(message, wellKnownProto); } } - /** - * Adapts a plain old Java Object to a {@link CelValue}. Protobuf semantics take precedence for - * conversion. - */ @Override public CelValue fromJavaObjectToCelValue(Object value) { - Preconditions.checkNotNull(value); - - if (value instanceof Message) { - return fromProtoMessageToCelValue((Message) value); - } else if (value instanceof Message.Builder) { - Message.Builder msgBuilder = (Message.Builder) value; - return fromProtoMessageToCelValue(msgBuilder.build()); - } else if (value instanceof ByteString) { - return BytesValue.create(CelByteString.of(((ByteString) value).toByteArray())); - } else if (value instanceof com.google.protobuf.NullValue) { - return NullValue.NULL_VALUE; - } else if (value instanceof EnumValueDescriptor) { + if (value instanceof EnumValueDescriptor) { // (b/178627883) Strongly typed enum is not supported yet return IntValue.create(((EnumValueDescriptor) value).getNumber()); } @@ -195,12 +118,14 @@ public CelValue fromProtoMessageFieldToCelValue( Object result = message.getField(fieldDescriptor); switch (fieldDescriptor.getType()) { case MESSAGE: - if (CelTypes.isWrapperType(fieldDescriptor.getMessageType().getFullName()) + if (WellKnownProto.isWrapperType(fieldDescriptor.getMessageType().getFullName()) && !message.hasField(fieldDescriptor)) { // Special semantics for wrapper types per CEL specification. These all convert into null // instead of the default value. return NullValue.NULL_VALUE; - } else if (fieldDescriptor.isMapField()) { + } + + if (fieldDescriptor.isMapField()) { Map map = new HashMap<>(); Object mapKey; Object mapValue; @@ -225,11 +150,12 @@ public CelValue fromProtoMessageFieldToCelValue( } return fromJavaObjectToCelValue(map); } - break; + + return fromProtoMessageToCelValue((MessageOrBuilder) result); case UINT32: - return UintValue.create((int) result, celOptions.enableUnsignedLongs()); + return UintValue.create((int) result, true); case UINT64: - return UintValue.create((long) result, celOptions.enableUnsignedLongs()); + return UintValue.create((long) result, true); default: break; } @@ -237,99 +163,7 @@ public CelValue fromProtoMessageFieldToCelValue( return fromJavaObjectToCelValue(result); } - private CelValue adaptJsonValueToCelValue(Value value) { - switch (value.getKindCase()) { - case BOOL_VALUE: - return fromJavaPrimitiveToCelValue(value.getBoolValue()); - case NUMBER_VALUE: - return fromJavaPrimitiveToCelValue(value.getNumberValue()); - case STRING_VALUE: - return fromJavaPrimitiveToCelValue(value.getStringValue()); - case LIST_VALUE: - return adaptJsonListToCelValue(value.getListValue()); - case STRUCT_VALUE: - return adaptJsonStructToCelValue(value.getStructValue()); - case NULL_VALUE: - case KIND_NOT_SET: // Fall-through is intended - return NullValue.NULL_VALUE; - } - throw new UnsupportedOperationException( - "Unsupported Json to CelValue conversion: " + value.getKindCase()); - } - - private ListValue adaptJsonListToCelValue(com.google.protobuf.ListValue listValue) { - return ImmutableListValue.create( - listValue.getValuesList().stream() - .map(this::adaptJsonValueToCelValue) - .collect(toImmutableList())); - } - - private MapValue adaptJsonStructToCelValue(Struct struct) { - return ImmutableMapValue.create( - struct.getFieldsMap().entrySet().stream() - .collect( - toImmutableMap( - e -> fromJavaObjectToCelValue(e.getKey()), - e -> adaptJsonValueToCelValue(e.getValue())))); - } - - /** Helper to convert between java.util.time and protobuf duration/timestamp. */ - private static class TimeUtils { - private static final int NANOS_PER_SECOND = 1000000000; - - private static Instant toJavaInstant(Timestamp timestamp) { - timestamp = normalizedTimestamp(timestamp.getSeconds(), timestamp.getNanos()); - return Instant.ofEpochSecond(timestamp.getSeconds(), timestamp.getNanos()); - } - - private static Duration toJavaDuration(com.google.protobuf.Duration duration) { - duration = normalizedDuration(duration.getSeconds(), duration.getNanos()); - return java.time.Duration.ofSeconds(duration.getSeconds(), duration.getNanos()); - } - - private static Timestamp toProtoTimestamp(Instant instant) { - return normalizedTimestamp(instant.getEpochSecond(), instant.getNano()); - } - - private static com.google.protobuf.Duration toProtoDuration(Duration duration) { - return normalizedDuration(duration.getSeconds(), duration.getNano()); - } - - private static Timestamp normalizedTimestamp(long seconds, int nanos) { - if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) { - seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND); - nanos = nanos % NANOS_PER_SECOND; - } - if (nanos < 0) { - nanos = nanos + NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding) - seconds = checkedSubtract(seconds, 1); - } - Timestamp timestamp = Timestamp.newBuilder().setSeconds(seconds).setNanos(nanos).build(); - return Timestamps.checkValid(timestamp); - } - - private static com.google.protobuf.Duration normalizedDuration(long seconds, int nanos) { - if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) { - seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND); - nanos %= NANOS_PER_SECOND; - } - if (seconds > 0 && nanos < 0) { - nanos += NANOS_PER_SECOND; // no overflow since nanos is negative (and we're adding) - seconds--; // no overflow since seconds is positive (and we're decrementing) - } - if (seconds < 0 && nanos > 0) { - nanos -= NANOS_PER_SECOND; // no overflow since nanos is positive (and we're subtracting) - seconds++; // no overflow since seconds is negative (and we're incrementing) - } - com.google.protobuf.Duration duration = - com.google.protobuf.Duration.newBuilder().setSeconds(seconds).setNanos(nanos).build(); - return Durations.checkValid(duration); - } - } - - private ProtoCelValueConverter( - CelOptions celOptions, CelDescriptorPool celDescriptorPool, DynamicProto dynamicProto) { - super(celOptions); + private ProtoCelValueConverter(CelDescriptorPool celDescriptorPool, DynamicProto dynamicProto) { Preconditions.checkNotNull(celDescriptorPool); Preconditions.checkNotNull(dynamicProto); this.celDescriptorPool = celDescriptorPool; diff --git a/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java b/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java index 430328596..d0ce40a8c 100644 --- a/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java +++ b/common/src/main/java/dev/cel/common/values/ProtoMessageValueProvider.java @@ -41,6 +41,10 @@ public class ProtoMessageValueProvider implements CelValueProvider { private final ProtoMessageFactory protoMessageFactory; private final ProtoCelValueConverter protoCelValueConverter; + public ProtoCelValueConverter getProtoCelValueConverter() { + return protoCelValueConverter; + } + @Override public Optional newValue(String structType, Map fields) { try { @@ -96,8 +100,7 @@ public static ProtoMessageValueProvider newInstance( private ProtoMessageValueProvider(DynamicProto dynamicProto, CelOptions celOptions) { this.protoMessageFactory = dynamicProto.getProtoMessageFactory(); this.protoCelValueConverter = - ProtoCelValueConverter.newInstance( - celOptions, protoMessageFactory.getDescriptorPool(), dynamicProto); + ProtoCelValueConverter.newInstance(protoMessageFactory.getDescriptorPool(), dynamicProto); this.protoAdapter = new ProtoAdapter(dynamicProto, celOptions.enableUnsignedLongs()); } } diff --git a/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java index c373f04fc..528cddee4 100644 --- a/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java +++ b/common/src/test/java/dev/cel/common/values/CelValueConverterTest.java @@ -18,7 +18,6 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; -import dev.cel.common.CelOptions; import java.util.Optional; import org.junit.Test; import org.junit.runner.RunWith; @@ -26,8 +25,7 @@ @RunWith(JUnit4.class) public class CelValueConverterTest { - private static final CelValueConverter CEL_VALUE_CONVERTER = - new CelValueConverter(CelOptions.DEFAULT) {}; + private static final CelValueConverter CEL_VALUE_CONVERTER = new CelValueConverter() {}; @Test public void fromJavaPrimitiveToCelValue_returnsOpaqueValue() { diff --git a/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java b/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java index 2c1e92e1d..0d74c33e0 100644 --- a/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java +++ b/common/src/test/java/dev/cel/common/values/ProtoCelValueConverterTest.java @@ -21,7 +21,6 @@ import com.google.protobuf.Timestamp; import com.google.protobuf.util.Durations; import com.google.protobuf.util.Timestamps; -import dev.cel.common.CelOptions; import dev.cel.common.internal.DefaultDescriptorPool; import dev.cel.common.internal.DefaultMessageFactory; import dev.cel.common.internal.DynamicProto; @@ -35,9 +34,7 @@ public class ProtoCelValueConverterTest { private static final ProtoCelValueConverter PROTO_CEL_VALUE_CONVERTER = ProtoCelValueConverter.newInstance( - CelOptions.DEFAULT, - DefaultDescriptorPool.INSTANCE, - DynamicProto.create(DefaultMessageFactory.INSTANCE)); + DefaultDescriptorPool.INSTANCE, DynamicProto.create(DefaultMessageFactory.INSTANCE)); @Test public void fromCelValueToJavaObject_returnsTimestampValue() { diff --git a/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java b/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java index ab3c52d18..f2e5aef5a 100644 --- a/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java +++ b/common/src/test/java/dev/cel/common/values/ProtoMessageValueTest.java @@ -35,7 +35,6 @@ import com.google.testing.junit.testparameterinjector.TestParameterInjector; import com.google.testing.junit.testparameterinjector.TestParameters; import dev.cel.common.CelDescriptorUtil; -import dev.cel.common.CelOptions; import dev.cel.common.internal.CelDescriptorPool; import dev.cel.common.internal.DefaultDescriptorPool; import dev.cel.common.internal.DefaultMessageFactory; @@ -55,9 +54,7 @@ public final class ProtoMessageValueTest { private static final ProtoCelValueConverter PROTO_CEL_VALUE_CONVERTER = ProtoCelValueConverter.newInstance( - CelOptions.current().build(), - DefaultDescriptorPool.INSTANCE, - DynamicProto.create(DefaultMessageFactory.INSTANCE)); + DefaultDescriptorPool.INSTANCE, DynamicProto.create(DefaultMessageFactory.INSTANCE)); @Test public void emptyProtoMessage() { @@ -140,7 +137,6 @@ public void findField_extensionField_success() { ImmutableList.of(TestAllTypesExtensions.getDescriptor()))); ProtoCelValueConverter protoCelValueConverter = ProtoCelValueConverter.newInstance( - CelOptions.DEFAULT, DefaultDescriptorPool.INSTANCE, DynamicProto.create(DefaultMessageFactory.create(descriptorPool))); TestAllTypes proto2Message = diff --git a/common/values/BUILD.bazel b/common/values/BUILD.bazel index 962d376cb..d3806b431 100644 --- a/common/values/BUILD.bazel +++ b/common/values/BUILD.bazel @@ -21,6 +21,11 @@ java_library( exports = ["//common/src/main/java/dev/cel/common/values"], ) +java_library( + name = "base_proto_cel_value_converter", + exports = ["//common/src/main/java/dev/cel/common/values:base_proto_cel_value_converter"], +) + java_library( name = "proto_message_value_provider", exports = ["//common/src/main/java/dev/cel/common/values:proto_message_value_provider"], diff --git a/runtime/src/main/java/dev/cel/runtime/BUILD.bazel b/runtime/src/main/java/dev/cel/runtime/BUILD.bazel index a9bd41225..7c78c7884 100644 --- a/runtime/src/main/java/dev/cel/runtime/BUILD.bazel +++ b/runtime/src/main/java/dev/cel/runtime/BUILD.bazel @@ -643,6 +643,7 @@ java_library( ], deps = [ ":activation", + ":cel_value_runtime_type_provider", ":descriptor_message_provider", ":descriptor_type_resolver", ":dispatcher", @@ -658,7 +659,6 @@ java_library( ":proto_message_runtime_equality", ":runtime_equality", ":runtime_type_provider", - ":runtime_type_provider_legacy", ":standard_functions", ":unknown_attributes", "//:auto_value", @@ -714,12 +714,12 @@ java_library( ":lite_runtime", ":runtime_equality", ":runtime_helpers", - ":runtime_type_provider", ":standard_functions", ":type_resolver", "//:auto_value", "//common:cel_ast", "//common:options", + "//runtime", "@maven//:com_google_code_findbugs_annotations", "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", @@ -838,23 +838,21 @@ cel_android_library( ) java_library( - name = "runtime_type_provider_legacy", - srcs = ["RuntimeTypeProviderLegacyImpl.java"], + name = "cel_value_runtime_type_provider", + srcs = ["CelValueRuntimeTypeProvider.java"], deps = [ ":runtime_type_provider", ":unknown_attributes", "//common:error_codes", - "//common:options", "//common:runtime_exception", "//common/annotations", - "//common/internal:cel_descriptor_pools", - "//common/internal:dynamic_proto", "//common/values", + "//common/values:base_proto_cel_value_converter", "//common/values:cel_value", "//common/values:cel_value_provider", - "//common/values:proto_message_value", "@maven//:com_google_errorprone_error_prone_annotations", "@maven//:com_google_guava_guava", + "@maven_android//:com_google_protobuf_protobuf_javalite", ], ) diff --git a/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java b/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java index 141f9dc83..d792c7780 100644 --- a/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java +++ b/runtime/src/main/java/dev/cel/runtime/CelRuntimeLegacyImpl.java @@ -291,16 +291,18 @@ public CelRuntimeLegacyImpl build() { RuntimeTypeProvider runtimeTypeProvider; if (options.enableCelValue()) { - CelValueProvider messageValueProvider = + ProtoMessageValueProvider messageValueProvider = ProtoMessageValueProvider.newInstance(dynamicProto, options); if (celValueProvider != null) { - messageValueProvider = + celValueProvider = new CelValueProvider.CombinedCelValueProvider(celValueProvider, messageValueProvider); + } else { + celValueProvider = messageValueProvider; } runtimeTypeProvider = - new RuntimeTypeProviderLegacyImpl( - options, messageValueProvider, celDescriptorPool, dynamicProto); + CelValueRuntimeTypeProvider.newInstance( + celValueProvider, messageValueProvider.getProtoCelValueConverter()); } else { runtimeTypeProvider = new DescriptorMessageProvider(runtimeTypeFactory, options); } diff --git a/runtime/src/main/java/dev/cel/runtime/RuntimeTypeProviderLegacyImpl.java b/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java similarity index 54% rename from runtime/src/main/java/dev/cel/runtime/RuntimeTypeProviderLegacyImpl.java rename to runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java index 36bd054f3..3a7182350 100644 --- a/runtime/src/main/java/dev/cel/runtime/RuntimeTypeProviderLegacyImpl.java +++ b/runtime/src/main/java/dev/cel/runtime/CelValueRuntimeTypeProvider.java @@ -14,17 +14,14 @@ package dev.cel.runtime; -import com.google.common.annotations.VisibleForTesting; import com.google.errorprone.annotations.Immutable; +import com.google.protobuf.MessageLite; import dev.cel.common.CelErrorCode; -import dev.cel.common.CelOptions; import dev.cel.common.CelRuntimeException; import dev.cel.common.annotations.Internal; -import dev.cel.common.internal.CelDescriptorPool; -import dev.cel.common.internal.DynamicProto; +import dev.cel.common.values.BaseProtoCelValueConverter; import dev.cel.common.values.CelValue; import dev.cel.common.values.CelValueProvider; -import dev.cel.common.values.ProtoCelValueConverter; import dev.cel.common.values.SelectableValue; import dev.cel.common.values.StringValue; import java.util.Map; @@ -33,20 +30,14 @@ /** Bridge between the old RuntimeTypeProvider and CelValueProvider APIs. */ @Internal @Immutable -public final class RuntimeTypeProviderLegacyImpl implements RuntimeTypeProvider { +final class CelValueRuntimeTypeProvider implements RuntimeTypeProvider { private final CelValueProvider valueProvider; - private final ProtoCelValueConverter protoCelValueConverter; - - @VisibleForTesting - public RuntimeTypeProviderLegacyImpl( - CelOptions celOptions, - CelValueProvider valueProvider, - CelDescriptorPool celDescriptorPool, - DynamicProto dynamicProto) { - this.valueProvider = valueProvider; - this.protoCelValueConverter = - ProtoCelValueConverter.newInstance(celOptions, celDescriptorPool, dynamicProto); + private final BaseProtoCelValueConverter protoCelValueConverter; + + static CelValueRuntimeTypeProvider newInstance( + CelValueProvider valueProvider, BaseProtoCelValueConverter protoCelValueConverter) { + return new CelValueRuntimeTypeProvider(valueProvider, protoCelValueConverter); } @Override @@ -61,41 +52,34 @@ public Object createMessage(String messageName, Map values) { } @Override - @SuppressWarnings("unchecked") public Object selectField(Object message, String fieldName) { - CelValue convertedCelValue = protoCelValueConverter.fromJavaObjectToCelValue(message); - if (!(convertedCelValue instanceof SelectableValue)) { - throw new CelRuntimeException( - new IllegalArgumentException( - String.format( - "Error resolving field '%s'. Field selections must be performed on messages or" - + " maps.", - fieldName)), - CelErrorCode.ATTRIBUTE_NOT_FOUND); - } - - SelectableValue selectableValue = (SelectableValue) convertedCelValue; + SelectableValue selectableValue = getSelectableValueOrThrow(message, fieldName); return unwrapCelValue(selectableValue.select(StringValue.create(fieldName))); } @Override - @SuppressWarnings("unchecked") public Object hasField(Object message, String fieldName) { - CelValue convertedCelValue = protoCelValueConverter.fromJavaObjectToCelValue(message); - if (!(convertedCelValue instanceof SelectableValue)) { - throw new CelRuntimeException( - new IllegalArgumentException( - String.format( - "Error resolving field '%s'. Field selections must be performed on messages or" - + " maps.", - fieldName)), - CelErrorCode.ATTRIBUTE_NOT_FOUND); + SelectableValue selectableValue = getSelectableValueOrThrow(message, fieldName); + + return selectableValue.find(StringValue.create(fieldName)).isPresent(); + } + + @SuppressWarnings("unchecked") + private SelectableValue getSelectableValueOrThrow(Object obj, String fieldName) { + CelValue convertedCelValue; + if ((obj instanceof MessageLite)) { + // TODO: Pass in typeName for lite messages + convertedCelValue = protoCelValueConverter.fromProtoMessageToCelValue("", (MessageLite) obj); + } else { + convertedCelValue = protoCelValueConverter.fromJavaObjectToCelValue(obj); } - SelectableValue selectableValue = (SelectableValue) convertedCelValue; + if (!(convertedCelValue instanceof SelectableValue)) { + throwInvalidFieldSelection(fieldName); + } - return selectableValue.find(StringValue.create(fieldName)).isPresent(); + return (SelectableValue) convertedCelValue; } @Override @@ -104,7 +88,18 @@ public Object adapt(Object message) { return message; // CelUnknownSet is handled specially for iterative evaluation. No need to // adapt to CelValue. } - return unwrapCelValue(protoCelValueConverter.fromJavaObjectToCelValue(message)); + + if (message instanceof MessageLite.Builder) { + message = ((MessageLite.Builder) message).build(); + } + + if (message instanceof MessageLite) { + // TODO: Pass in typeName for lite messages + return unwrapCelValue( + protoCelValueConverter.fromProtoMessageToCelValue("", (MessageLite) message)); + } else { + return unwrapCelValue(protoCelValueConverter.fromJavaObjectToCelValue(message)); + } } /** @@ -115,4 +110,20 @@ public Object adapt(Object message) { private Object unwrapCelValue(CelValue object) { return protoCelValueConverter.fromCelValueToJavaObject(object); } + + private static void throwInvalidFieldSelection(String fieldName) { + throw new CelRuntimeException( + new IllegalArgumentException( + String.format( + "Error resolving field '%s'. Field selections must be performed on messages or" + + " maps.", + fieldName)), + CelErrorCode.ATTRIBUTE_NOT_FOUND); + } + + private CelValueRuntimeTypeProvider( + CelValueProvider valueProvider, BaseProtoCelValueConverter protoCelValueConverter) { + this.valueProvider = valueProvider; + this.protoCelValueConverter = protoCelValueConverter; + } } diff --git a/runtime/src/test/resources/wrappers.baseline b/runtime/src/test/resources/wrappers.baseline index b440e71ac..4a188e484 100644 --- a/runtime/src/test/resources/wrappers.baseline +++ b/runtime/src/test/resources/wrappers.baseline @@ -72,4 +72,15 @@ declare x { } =====> bindings: {x=} -result: true \ No newline at end of file +result: true + +Source: dyn_var +declare x { + value cel.expr.conformance.proto3.TestAllTypes +} +declare dyn_var { + value dyn +} +=====> +bindings: {dyn_var=NULL_VALUE} +result: NULL_VALUE \ No newline at end of file diff --git a/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java b/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java index 1494c2197..119428d65 100644 --- a/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java +++ b/testing/src/main/java/dev/cel/testing/BaseInterpreterTest.java @@ -1958,6 +1958,10 @@ public void wrappers() throws Exception { + "x.single_uint32_wrapper == null && " + "x.single_uint64_wrapper == null"; runTest(ImmutableMap.of("x", TestAllTypes.getDefaultInstance())); + + declareVariable("dyn_var", CelProtoTypes.DYN); + source = "dyn_var"; + runTest(ImmutableMap.of("dyn_var", NullValue.NULL_VALUE)); } @Test