[VOL-5051] - Build and deploy voltctl
[VOL-5152]
[VOL-4961]
[VOL-5063]
[VOL-4966]
[VOL-4893]
[VOL-4906]
go.mod
go.sum
vendor/modules.txt
------------------
o Update voltha-lib-go dep to 7.5.3
o Update voltha-protos dep to 5.4.11
o make mod-update
Makefile
makefiles/
o Add more repo:onf-make makefile logic
o make LOCAL_FIX_PERMS=1 mod-update need to work around docker perm problems.
internal/
pkg/
vendor/
---------
o Update copyright ending date to span 2024.
o make mod-update to regenerate vendor/
Change-Id: Ib89fd6a9cc15c7e08b1274b110dd8141832557e9
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go b/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go
index 3f19d6b..de13b92 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/dynamic_message.go
@@ -14,6 +14,7 @@
"github.com/jhump/protoreflect/codec"
"github.com/jhump/protoreflect/desc"
+ "github.com/jhump/protoreflect/internal"
)
// ErrUnknownTagNumber is an error that is returned when an operation refers
@@ -527,14 +528,8 @@
}
// GetDefaultValue only returns nil for message types
md := fd.GetMessageType()
- if md.IsProto3() {
- // try to return a proper nil pointer
- msgType := proto.MessageType(md.GetFullyQualifiedName())
- if msgType != nil && msgType.Implements(typeOfProtoMessage) {
- return reflect.Zero(msgType).Interface().(proto.Message), nil
- }
- // fallback to nil dynamic message pointer
- return (*Message)(nil), nil
+ if m.md.IsProto3() {
+ return nilMessage(md), nil
} else {
// for proto2, return default instance of message
return m.mf.NewMessage(md), nil
@@ -561,6 +556,16 @@
return res, nil
}
+func nilMessage(md *desc.MessageDescriptor) interface{} {
+ // try to return a proper nil pointer
+ msgType := proto.MessageType(md.GetFullyQualifiedName())
+ if msgType != nil && msgType.Implements(typeOfProtoMessage) {
+ return reflect.Zero(msgType).Interface().(proto.Message)
+ }
+ // fallback to nil dynamic message pointer
+ return (*Message)(nil)
+}
+
// HasField returns true if this message has a value for the given field. If the
// given field is not valid (e.g. belongs to a different message type), false is
// returned. If this message is defined in a file with "proto3" syntax, this
@@ -980,7 +985,7 @@
return nil, FieldIsNotMapError
}
kfd := fd.GetMessageType().GetFields()[0]
- ki, err := validElementFieldValue(kfd, key)
+ ki, err := validElementFieldValue(kfd, key, false)
if err != nil {
return nil, err
}
@@ -1185,12 +1190,12 @@
return FieldIsNotMapError
}
kfd := fd.GetMessageType().GetFields()[0]
- ki, err := validElementFieldValue(kfd, key)
+ ki, err := validElementFieldValue(kfd, key, false)
if err != nil {
return err
}
vfd := fd.GetMessageType().GetFields()[1]
- vi, err := validElementFieldValue(vfd, val)
+ vi, err := validElementFieldValue(vfd, val, true)
if err != nil {
return err
}
@@ -1279,7 +1284,7 @@
return FieldIsNotMapError
}
kfd := fd.GetMessageType().GetFields()[0]
- ki, err := validElementFieldValue(kfd, key)
+ ki, err := validElementFieldValue(kfd, key, false)
if err != nil {
return err
}
@@ -1580,7 +1585,7 @@
if !fd.IsRepeated() {
return FieldIsNotRepeatedError
}
- val, err := validElementFieldValue(fd, val)
+ val, err := validElementFieldValue(fd, val, false)
if err != nil {
return err
}
@@ -1709,7 +1714,7 @@
if fd.IsMap() || !fd.IsRepeated() {
return FieldIsNotRepeatedError
}
- val, err := validElementFieldValue(fd, val)
+ val, err := validElementFieldValue(fd, val, false)
if err != nil {
return err
}
@@ -1813,7 +1818,7 @@
// value should be a slice of entry messages that we need convert into a map[interface{}]interface{}
m := map[interface{}]interface{}{}
for i := 0; i < val.Len(); i++ {
- e, err := validElementFieldValue(fd, val.Index(i).Interface())
+ e, err := validElementFieldValue(fd, val.Index(i).Interface(), false)
if err != nil {
return nil, err
}
@@ -1843,7 +1848,7 @@
// unwrap it
ev = reflect.ValueOf(ev.Interface())
}
- e, err := validElementFieldValueForRv(fd, ev)
+ e, err := validElementFieldValueForRv(fd, ev, false)
if err != nil {
return nil, err
}
@@ -1853,7 +1858,7 @@
return s, nil
}
- return validElementFieldValueForRv(fd, val)
+ return validElementFieldValueForRv(fd, val, false)
}
func asDynamicMessage(m proto.Message, md *desc.MessageDescriptor, mf *MessageFactory) (*Message, error) {
@@ -1867,11 +1872,11 @@
return dm, nil
}
-func validElementFieldValue(fd *desc.FieldDescriptor, val interface{}) (interface{}, error) {
- return validElementFieldValueForRv(fd, reflect.ValueOf(val))
+func validElementFieldValue(fd *desc.FieldDescriptor, val interface{}, allowNilMessage bool) (interface{}, error) {
+ return validElementFieldValueForRv(fd, reflect.ValueOf(val), allowNilMessage)
}
-func validElementFieldValueForRv(fd *desc.FieldDescriptor, val reflect.Value) (interface{}, error) {
+func validElementFieldValueForRv(fd *desc.FieldDescriptor, val reflect.Value, allowNilMessage bool) (interface{}, error) {
t := fd.GetType()
if !val.IsValid() {
return nil, typeError(fd, nil)
@@ -1921,6 +1926,11 @@
}
var msgType string
if dm, ok := m.(*Message); ok {
+ if allowNilMessage && dm == nil {
+ // if dm == nil, we'll panic below, so early out if that is allowed
+ // (only allowed for map values, to indicate an entry w/ no value)
+ return m, nil
+ }
msgType = dm.GetMessageDescriptor().GetFullyQualifiedName()
} else {
msgType = proto.MessageName(m)
@@ -2051,7 +2061,22 @@
}
target.Reset()
- return m.mergeInto(target)
+ return m.mergeInto(target, defaultDeterminism)
+}
+
+// ConvertToDeterministic converts this dynamic message into the given message.
+// It is just like ConvertTo, but it attempts to produce deterministic results.
+// That means that if the target is a generated message (not another dynamic
+// message) and the current runtime is unaware of any fields or extensions that
+// are present in m, they will be serialized into the target's unrecognized
+// fields deterministically.
+func (m *Message) ConvertToDeterministic(target proto.Message) error {
+ if err := m.checkType(target); err != nil {
+ return err
+ }
+
+ target.Reset()
+ return m.mergeInto(target, true)
}
// ConvertFrom converts the given message into this dynamic message. This is
@@ -2080,7 +2105,20 @@
if err := m.checkType(target); err != nil {
return err
}
- return m.mergeInto(target)
+ return m.mergeInto(target, defaultDeterminism)
+}
+
+// MergeIntoDeterministic merges this dynamic message into the given message.
+// It is just like MergeInto, but it attempts to produce deterministic results.
+// That means that if the target is a generated message (not another dynamic
+// message) and the current runtime is unaware of any fields or extensions that
+// are present in m, they will be serialized into the target's unrecognized
+// fields deterministically.
+func (m *Message) MergeIntoDeterministic(target proto.Message) error {
+ if err := m.checkType(target); err != nil {
+ return err
+ }
+ return m.mergeInto(target, true)
}
// MergeFrom merges the given message into this dynamic message. All field
@@ -2145,7 +2183,7 @@
return nil
}
-func (m *Message) mergeInto(pm proto.Message) error {
+func (m *Message) mergeInto(pm proto.Message, deterministic bool) error {
if dm, ok := pm.(*Message); ok {
return dm.mergeFrom(m)
}
@@ -2157,13 +2195,9 @@
// track tags for which the dynamic message has data but the given
// message doesn't know about it
- u := target.FieldByName("XXX_unrecognized")
- var unknownTags map[int32]struct{}
- if u.IsValid() && u.Type() == typeOfBytes {
- unknownTags = map[int32]struct{}{}
- for tag := range m.values {
- unknownTags[tag] = struct{}{}
- }
+ unknownTags := map[int32]struct{}{}
+ for tag := range m.values {
+ unknownTags[tag] = struct{}{}
}
// check that we can successfully do the merge
@@ -2231,7 +2265,7 @@
continue
}
f := target.FieldByName(prop.Name)
- if err := mergeVal(reflect.ValueOf(v), f); err != nil {
+ if err := mergeVal(reflect.ValueOf(v), f, deterministic); err != nil {
return err
}
}
@@ -2245,7 +2279,7 @@
}
oov := reflect.New(oop.Type.Elem())
f := oov.Elem().FieldByName(prop.Name)
- if err := mergeVal(reflect.ValueOf(v), f); err != nil {
+ if err := mergeVal(reflect.ValueOf(v), f, deterministic); err != nil {
return err
}
target.Field(oop.Field).Set(oov)
@@ -2257,7 +2291,7 @@
continue
}
e := reflect.New(reflect.TypeOf(ext.ExtensionType)).Elem()
- if err := mergeVal(reflect.ValueOf(v), e); err != nil {
+ if err := mergeVal(reflect.ValueOf(v), e, deterministic); err != nil {
return err
}
if err := proto.SetExtension(pm, ext, e.Interface()); err != nil {
@@ -2268,17 +2302,34 @@
// if we have fields that the given message doesn't know about, add to its unknown fields
if len(unknownTags) > 0 {
- ub := u.Interface().([]byte)
var b codec.Buffer
- b.SetDeterministic(defaultDeterminism)
- for tag := range unknownTags {
- fd := m.FindFieldDescriptor(tag)
- if err := b.EncodeFieldValue(fd, m.values[tag]); err != nil {
- return err
+ b.SetDeterministic(deterministic)
+ if deterministic {
+ // if we need to emit things deterministically, sort the
+ // extensions by their tag number
+ sortedUnknownTags := make([]int32, 0, len(unknownTags))
+ for tag := range unknownTags {
+ sortedUnknownTags = append(sortedUnknownTags, tag)
+ }
+ sort.Slice(sortedUnknownTags, func(i, j int) bool {
+ return sortedUnknownTags[i] < sortedUnknownTags[j]
+ })
+ for _, tag := range sortedUnknownTags {
+ fd := m.FindFieldDescriptor(tag)
+ if err := b.EncodeFieldValue(fd, m.values[tag]); err != nil {
+ return err
+ }
+ }
+ } else {
+ for tag := range unknownTags {
+ fd := m.FindFieldDescriptor(tag)
+ if err := b.EncodeFieldValue(fd, m.values[tag]); err != nil {
+ return err
+ }
}
}
- ub = append(ub, b.Bytes()...)
- u.Set(reflect.ValueOf(ub))
+
+ internal.SetUnrecognized(pm, b.Bytes())
}
// finally, convey unknown fields into the given message by letting it unmarshal them
@@ -2331,7 +2382,7 @@
}
}
-func mergeVal(src, target reflect.Value) error {
+func mergeVal(src, target reflect.Value, deterministic bool) error {
if src.Kind() == reflect.Interface && !src.IsNil() {
src = src.Elem()
}
@@ -2368,19 +2419,19 @@
if dest.Kind() == reflect.Ptr {
dest.Set(reflect.New(dest.Type().Elem()))
}
- if err := mergeVal(src.Index(i), dest); err != nil {
+ if err := mergeVal(src.Index(i), dest, deterministic); err != nil {
return err
}
}
} else if targetType.Kind() == reflect.Map {
- return mergeMapVal(src, target, targetType)
+ return mergeMapVal(src, target, targetType, deterministic)
} else if srcType == typeOfDynamicMessage && targetType.Implements(typeOfProtoMessage) {
dm := src.Interface().(*Message)
if target.IsNil() {
target.Set(reflect.New(targetType.Elem()))
}
m := target.Interface().(proto.Message)
- if err := dm.mergeInto(m); err != nil {
+ if err := dm.mergeInto(m, deterministic); err != nil {
return err
}
} else {
@@ -2478,17 +2529,14 @@
// extension fields
rexts, _ := proto.ExtensionDescs(pm)
- var unknownExtensions []byte
for _, ed := range rexts {
v, _ := proto.GetExtension(pm, ed)
if v == nil {
continue
}
if ed.ExtensionType == nil {
- extBytes, _ := v.([]byte)
- if len(extBytes) > 0 {
- unknownExtensions = append(unknownExtensions, extBytes...)
- }
+ // unrecognized extension: we'll handle that below when we
+ // handle other unrecognized fields
continue
}
fd := m.er.FindExtension(m.md.GetFullyQualifiedName(), ed.Field)
@@ -2507,22 +2555,17 @@
// now actually perform the merge
for fd, v := range values {
- mergeField(m, fd, v)
+ if err := mergeField(m, fd, v); err != nil {
+ return err
+ }
}
- u := src.FieldByName("XXX_unrecognized")
- if u.IsValid() && u.Type() == typeOfBytes {
+ data := internal.GetUnrecognized(pm)
+ if len(data) > 0 {
// ignore any error returned: pulling in unknown fields is best-effort
- _ = m.UnmarshalMerge(u.Interface().([]byte))
+ _ = m.UnmarshalMerge(data)
}
- // lastly, also extract any unknown extensions the message may have (unknown extensions
- // are stored with other extensions, not in the XXX_unrecognized field, so we have to do
- // more than just the step above...)
- if len(unknownExtensions) > 0 {
- // pulling in unknown fields is best-effort, so we just ignore errors
- _ = m.UnmarshalMerge(unknownExtensions)
- }
return nil
}
@@ -2574,12 +2617,15 @@
var dm *Message
if d, ok := pm.(*Message); ok {
dm = d
- } else {
+ } else if pm != nil {
dm = m.mf.NewDynamicMessage(md)
if err := dm.ConvertFrom(pm); err != nil {
return nil
}
}
+ if dm == nil {
+ return nil
+ }
if err := dm.validateRecursive(chprefix); err != nil {
return err
}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/equal.go b/vendor/github.com/jhump/protoreflect/dynamic/equal.go
index 5fbcc24..e44c6c5 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/equal.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/equal.go
@@ -13,6 +13,12 @@
// have the same message type and same fields set to equal values. For proto3 messages, fields set
// to their zero value are considered unset.
func Equal(a, b *Message) bool {
+ if a == b {
+ return true
+ }
+ if (a == nil) != (b == nil) {
+ return false
+ }
if a.md.GetFullyQualifiedName() != b.md.GetFullyQualifiedName() {
return false
}
@@ -128,25 +134,24 @@
return proto.Equal(a, b)
}
// Mixed
- if aok {
- md, err := desc.LoadMessageDescriptorForMessage(b)
- if err != nil {
- return false
- }
- db = NewMessageWithMessageFactory(md, da.mf)
- if db.ConvertFrom(b) != nil {
- return false
- }
- return Equal(da, db)
- } else {
- md, err := desc.LoadMessageDescriptorForMessage(a)
- if err != nil {
- return false
- }
- da = NewMessageWithMessageFactory(md, db.mf)
- if da.ConvertFrom(a) != nil {
- return false
- }
- return Equal(da, db)
+ if bok {
+ // we want a to be the dynamic one
+ b, da = a, db
}
+
+ // Instead of panic'ing below if we have a nil dynamic message, check
+ // now and return false if the input message is not also nil.
+ if da == nil {
+ return isNil(b)
+ }
+
+ md, err := desc.LoadMessageDescriptorForMessage(b)
+ if err != nil {
+ return false
+ }
+ db = NewMessageWithMessageFactory(md, da.mf)
+ if db.ConvertFrom(b) != nil {
+ return false
+ }
+ return Equal(da, db)
}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/json.go b/vendor/github.com/jhump/protoreflect/dynamic/json.go
index 7dfae09..02c8298 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/json.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/json.go
@@ -114,6 +114,10 @@
}
func (m *Message) marshalJSON(b *indentBuffer, opts *jsonpb.Marshaler) error {
+ if m == nil {
+ _, err := b.WriteString("null")
+ return err
+ }
if r, changed := wrapResolver(opts.AnyResolver, m.mf, m.md.GetFile()); changed {
newOpts := *opts
newOpts.AnyResolver = r
@@ -364,7 +368,7 @@
default:
return fmt.Errorf("invalid map key value: %v (%v)", mk, rk.Type())
}
- err := writeString(b, strkey)
+ err := writeJsonString(b, strkey)
if err != nil {
return err
}
@@ -430,44 +434,49 @@
return writeJsonString(b, rv.String())
default:
// must be a message
+ if isNil(v) {
+ _, err := b.WriteString("null")
+ return err
+ }
+
if dm, ok := v.(*Message); ok {
return dm.marshalJSON(b, opts)
+ }
+
+ var err error
+ if b.indentCount <= 0 || len(b.indent) == 0 {
+ err = opts.Marshal(b, v.(proto.Message))
} else {
- var err error
- if b.indentCount <= 0 || len(b.indent) == 0 {
- err = opts.Marshal(b, v.(proto.Message))
- } else {
- str, err := opts.MarshalToString(v.(proto.Message))
- if err != nil {
- return err
+ str, err := opts.MarshalToString(v.(proto.Message))
+ if err != nil {
+ return err
+ }
+ indent := strings.Repeat(b.indent, b.indentCount)
+ pos := 0
+ // add indention prefix to each line
+ for pos < len(str) {
+ start := pos
+ nextPos := strings.Index(str[pos:], "\n")
+ if nextPos == -1 {
+ nextPos = len(str)
+ } else {
+ nextPos = pos + nextPos + 1 // include newline
}
- indent := strings.Repeat(b.indent, b.indentCount)
- pos := 0
- // add indention prefix to each line
- for pos < len(str) {
- start := pos
- nextPos := strings.Index(str[pos:], "\n")
- if nextPos == -1 {
- nextPos = len(str)
- } else {
- nextPos = pos + nextPos + 1 // include newline
- }
- line := str[start:nextPos]
- if pos > 0 {
- _, err = b.WriteString(indent)
- if err != nil {
- return err
- }
- }
- _, err = b.WriteString(line)
+ line := str[start:nextPos]
+ if pos > 0 {
+ _, err = b.WriteString(indent)
if err != nil {
return err
}
- pos = nextPos
}
+ _, err = b.WriteString(line)
+ if err != nil {
+ return err
+ }
+ pos = nextPos
}
- return err
}
+ return err
}
}
@@ -665,8 +674,10 @@
}
func isWellKnownListValue(fd *desc.FieldDescriptor) bool {
+ // we look for ListValue; but we also look for Value, which can be assigned a ListValue
return !fd.IsRepeated() && fd.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE &&
- fd.GetMessageType().GetFullyQualifiedName() == "google.protobuf.ListValue"
+ (fd.GetMessageType().GetFullyQualifiedName() == "google.protobuf.ListValue" ||
+ fd.GetMessageType().GetFullyQualifiedName() == "google.protobuf.Value")
}
func unmarshalJsField(fd *desc.FieldDescriptor, r *jsReader, mf *MessageFactory, opts *jsonpb.Unmarshaler) (interface{}, error) {
@@ -698,11 +709,11 @@
return nil, err
}
for r.hasNext() {
- kk, err := unmarshalJsFieldElement(keyType, r, mf, opts)
+ kk, err := unmarshalJsFieldElement(keyType, r, mf, opts, false)
if err != nil {
return nil, err
}
- vv, err := unmarshalJsFieldElement(valueType, r, mf, opts)
+ vv, err := unmarshalJsFieldElement(valueType, r, mf, opts, true)
if err != nil {
return nil, err
}
@@ -725,7 +736,7 @@
var v interface{}
for r.hasNext() {
var err error
- v, err = unmarshalJsFieldElement(fd, r, mf, opts)
+ v, err = unmarshalJsFieldElement(fd, r, mf, opts, false)
if err != nil {
return nil, err
}
@@ -761,7 +772,7 @@
// binary wire format that supports changing an optional field to repeated and vice versa.
// If the field is repeated, we store value as singleton slice of that one value.
- v, err := unmarshalJsFieldElement(fd, r, mf, opts)
+ v, err := unmarshalJsFieldElement(fd, r, mf, opts, false)
if err != nil {
return nil, err
}
@@ -776,7 +787,7 @@
}
}
-func unmarshalJsFieldElement(fd *desc.FieldDescriptor, r *jsReader, mf *MessageFactory, opts *jsonpb.Unmarshaler) (interface{}, error) {
+func unmarshalJsFieldElement(fd *desc.FieldDescriptor, r *jsReader, mf *MessageFactory, opts *jsonpb.Unmarshaler, allowNilMessage bool) (interface{}, error) {
t, err := r.peek()
if err != nil {
return nil, err
@@ -785,6 +796,13 @@
switch fd.GetType() {
case descriptor.FieldDescriptorProto_TYPE_MESSAGE,
descriptor.FieldDescriptorProto_TYPE_GROUP:
+
+ if t == nil && allowNilMessage {
+ // if json is simply "null" return a nil pointer
+ r.poll()
+ return nilMessage(fd.GetMessageType()), nil
+ }
+
m := mf.NewMessage(fd.GetMessageType())
if dm, ok := m.(*Message); ok {
if err := dm.unmarshalJson(r, opts); err != nil {
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/maps_1.11.go b/vendor/github.com/jhump/protoreflect/dynamic/maps_1.11.go
index bb68d7b..03162a4 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/maps_1.11.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/maps_1.11.go
@@ -1,4 +1,5 @@
-//+build !go1.12
+//go:build !go1.12
+// +build !go1.12
package dynamic
@@ -44,7 +45,7 @@
// unwrap it
k = reflect.ValueOf(k.Interface())
}
- kk, err := validFieldValueForRv(keyField, k)
+ kk, err := validElementFieldValueForRv(keyField, k, false)
if err != nil {
return nil, err
}
@@ -53,7 +54,7 @@
// unwrap it
v = reflect.ValueOf(v.Interface())
}
- vv, err := validFieldValueForRv(valField, v)
+ vv, err := validElementFieldValueForRv(valField, v, true)
if err != nil {
return nil, err
}
@@ -76,7 +77,7 @@
return true
}
-func mergeMapVal(src, target reflect.Value, targetType reflect.Type) error {
+func mergeMapVal(src, target reflect.Value, targetType reflect.Type, deterministic bool) error {
tkt := targetType.Key()
tvt := targetType.Elem()
for _, k := range src.MapKeys() {
@@ -90,7 +91,7 @@
nk = k.Addr()
} else {
nk = reflect.New(tkt).Elem()
- if err := mergeVal(k, nk); err != nil {
+ if err := mergeVal(k, nk, deterministic); err != nil {
return err
}
}
@@ -100,7 +101,7 @@
nv = v.Addr()
} else {
nv = reflect.New(tvt).Elem()
- if err := mergeVal(v, nv); err != nil {
+ if err := mergeVal(v, nv, deterministic); err != nil {
return err
}
}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/maps_1.12.go b/vendor/github.com/jhump/protoreflect/dynamic/maps_1.12.go
index f5ffd67..ef1b370 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/maps_1.12.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/maps_1.12.go
@@ -1,4 +1,5 @@
-//+build go1.12
+//go:build go1.12
+// +build go1.12
package dynamic
@@ -47,7 +48,7 @@
// unwrap it
k = reflect.ValueOf(k.Interface())
}
- kk, err := validFieldValueForRv(keyField, k)
+ kk, err := validElementFieldValueForRv(keyField, k, false)
if err != nil {
return nil, err
}
@@ -56,7 +57,7 @@
// unwrap it
v = reflect.ValueOf(v.Interface())
}
- vv, err := validFieldValueForRv(valField, v)
+ vv, err := validElementFieldValueForRv(valField, v, true)
if err != nil {
return nil, err
}
@@ -80,7 +81,7 @@
return true
}
-func mergeMapVal(src, target reflect.Value, targetType reflect.Type) error {
+func mergeMapVal(src, target reflect.Value, targetType reflect.Type, deterministic bool) error {
tkt := targetType.Key()
tvt := targetType.Elem()
iter := src.MapRange()
@@ -96,7 +97,7 @@
nk = k.Addr()
} else {
nk = reflect.New(tkt).Elem()
- if err := mergeVal(k, nk); err != nil {
+ if err := mergeVal(k, nk, deterministic); err != nil {
return err
}
}
@@ -106,7 +107,7 @@
nv = v.Addr()
} else {
nv = reflect.New(tvt).Elem()
- if err := mergeVal(v, nv); err != nil {
+ if err := mergeVal(v, nv, deterministic); err != nil {
return err
}
}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/message_factory.go b/vendor/github.com/jhump/protoreflect/dynamic/message_factory.go
index 6c54de8..9ab8e61 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/message_factory.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/message_factory.go
@@ -159,6 +159,18 @@
}
}
+func isWellKnownType(t reflect.Type) bool {
+ if t.Implements(typeOfWkt) {
+ return true
+ }
+ if msg, ok := reflect.Zero(t).Interface().(proto.Message); ok {
+ name := proto.MessageName(msg)
+ _, ok := wellKnownTypeNames[name]
+ return ok
+ }
+ return false
+}
+
// GetKnownType will return the reflect.Type for the given message name if it is
// known. If it is not known, nil is returned.
func (r *KnownTypeRegistry) GetKnownType(messageName string) reflect.Type {
@@ -166,7 +178,7 @@
if r == nil {
// a nil registry behaves the same as zero value instance: only know of well-known types
t := proto.MessageType(messageName)
- if t != nil && t.Implements(typeOfWkt) {
+ if t != nil && isWellKnownType(t) {
msgType = t
}
} else {
@@ -174,7 +186,7 @@
msgType = proto.MessageType(messageName)
} else if !r.excludeWkt {
t := proto.MessageType(messageName)
- if t != nil && t.Implements(typeOfWkt) {
+ if t != nil && isWellKnownType(t) {
msgType = t
}
}
diff --git a/vendor/github.com/jhump/protoreflect/dynamic/text.go b/vendor/github.com/jhump/protoreflect/dynamic/text.go
index 72636f2..5784d3e 100644
--- a/vendor/github.com/jhump/protoreflect/dynamic/text.go
+++ b/vendor/github.com/jhump/protoreflect/dynamic/text.go
@@ -193,9 +193,11 @@
if err != nil {
return err
}
- err = marshalKnownFieldText(b, vfd, mv)
- if err != nil {
- return err
+ if !isNil(mv) {
+ err = marshalKnownFieldText(b, vfd, mv)
+ if err != nil {
+ return err
+ }
}
err = b.end()
@@ -344,7 +346,7 @@
case '\t':
_, err = b.WriteString("\\t")
case '"':
- _, err = b.WriteString("\\")
+ _, err = b.WriteString("\\\"")
case '\\':
_, err = b.WriteString("\\\\")
default: