[VOL-5486] Upgrade library versions
Change-Id: I8b4e88699e03f44ee13e467867f45ae3f0a63c4b
Signed-off-by: Abhay Kumar <abhay.kumar@radisys.com>
diff --git a/vendor/github.com/jhump/protoreflect/desc/load.go b/vendor/github.com/jhump/protoreflect/desc/load.go
index 4a05830..8fd09ac 100644
--- a/vendor/github.com/jhump/protoreflect/desc/load.go
+++ b/vendor/github.com/jhump/protoreflect/desc/load.go
@@ -1,150 +1,109 @@
package desc
import (
+ "errors"
"fmt"
"reflect"
"sync"
"github.com/golang/protobuf/proto"
- dpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+ "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoregistry"
+ "google.golang.org/protobuf/types/descriptorpb"
+ "github.com/jhump/protoreflect/desc/sourceinfo"
"github.com/jhump/protoreflect/internal"
)
+// The global cache is used to store descriptors that wrap items in
+// protoregistry.GlobalTypes and protoregistry.GlobalFiles. This prevents
+// repeating work to re-wrap underlying global descriptors.
var (
- cacheMu sync.RWMutex
- filesCache = map[string]*FileDescriptor{}
- messagesCache = map[string]*MessageDescriptor{}
- enumCache = map[reflect.Type]*EnumDescriptor{}
+ // We put all wrapped file and message descriptors in this cache.
+ loadedDescriptors = lockingCache{cache: mapCache{}}
+
+ // Unfortunately, we need a different mechanism for enums for
+ // compatibility with old APIs, which required that they were
+ // registered in a different way :(
+ loadedEnumsMu sync.RWMutex
+ loadedEnums = map[reflect.Type]*EnumDescriptor{}
)
// LoadFileDescriptor creates a file descriptor using the bytes returned by
// proto.FileDescriptor. Descriptors are cached so that they do not need to be
// re-processed if the same file is fetched again later.
func LoadFileDescriptor(file string) (*FileDescriptor, error) {
- return loadFileDescriptor(file, nil)
-}
-
-func loadFileDescriptor(file string, r *ImportResolver) (*FileDescriptor, error) {
- f := getFileFromCache(file)
- if f != nil {
- return f, nil
- }
- cacheMu.Lock()
- defer cacheMu.Unlock()
- return loadFileDescriptorLocked(file, r)
-}
-
-func loadFileDescriptorLocked(file string, r *ImportResolver) (*FileDescriptor, error) {
- f := filesCache[file]
- if f != nil {
- return f, nil
- }
- fd, err := internal.LoadFileDescriptor(file)
- if err != nil {
- return nil, err
- }
-
- f, err = toFileDescriptorLocked(fd, r)
- if err != nil {
- return nil, err
- }
- putCacheLocked(file, f)
- return f, nil
-}
-
-func toFileDescriptorLocked(fd *dpb.FileDescriptorProto, r *ImportResolver) (*FileDescriptor, error) {
- deps := make([]*FileDescriptor, len(fd.GetDependency()))
- for i, dep := range fd.GetDependency() {
- resolvedDep := r.ResolveImport(fd.GetName(), dep)
- var err error
- deps[i], err = loadFileDescriptorLocked(resolvedDep, r)
- if _, ok := err.(internal.ErrNoSuchFile); ok && resolvedDep != dep {
- // try original path
- deps[i], err = loadFileDescriptorLocked(dep, r)
- }
- if err != nil {
- return nil, err
+ d, err := sourceinfo.GlobalFiles.FindFileByPath(file)
+ if errors.Is(err, protoregistry.NotFound) {
+ // for backwards compatibility, see if this matches a known old
+ // alias for the file (older versions of libraries that registered
+ // the files using incorrect/non-canonical paths)
+ if alt := internal.StdFileAliases[file]; alt != "" {
+ d, err = sourceinfo.GlobalFiles.FindFileByPath(alt)
}
}
- return CreateFileDescriptor(fd, deps...)
-}
-
-func getFileFromCache(file string) *FileDescriptor {
- cacheMu.RLock()
- defer cacheMu.RUnlock()
- return filesCache[file]
-}
-
-func putCacheLocked(filename string, fd *FileDescriptor) {
- filesCache[filename] = fd
- putMessageCacheLocked(fd.messages)
-}
-
-func putMessageCacheLocked(mds []*MessageDescriptor) {
- for _, md := range mds {
- messagesCache[md.fqn] = md
- putMessageCacheLocked(md.nested)
+ if err != nil {
+ if !errors.Is(err, protoregistry.NotFound) {
+ return nil, internal.ErrNoSuchFile(file)
+ }
+ return nil, err
}
-}
+ if fd := loadedDescriptors.get(d); fd != nil {
+ return fd.(*FileDescriptor), nil
+ }
-// interface implemented by generated messages, which all have a Descriptor() method in
-// addition to the methods of proto.Message
-type protoMessage interface {
- proto.Message
- Descriptor() ([]byte, []int)
+ var fd *FileDescriptor
+ loadedDescriptors.withLock(func(cache descriptorCache) {
+ fd, err = wrapFile(d, cache)
+ })
+ return fd, err
}
// LoadMessageDescriptor loads descriptor using the encoded descriptor proto returned by
// Message.Descriptor() for the given message type. If the given type is not recognized,
// then a nil descriptor is returned.
func LoadMessageDescriptor(message string) (*MessageDescriptor, error) {
- return loadMessageDescriptor(message, nil)
+ mt, err := sourceinfo.GlobalTypes.FindMessageByName(protoreflect.FullName(message))
+ if err != nil {
+ if errors.Is(err, protoregistry.NotFound) {
+ return nil, nil
+ }
+ return nil, err
+ }
+ return loadMessageDescriptor(mt.Descriptor())
}
-func loadMessageDescriptor(message string, r *ImportResolver) (*MessageDescriptor, error) {
- m := getMessageFromCache(message)
- if m != nil {
- return m, nil
+func loadMessageDescriptor(md protoreflect.MessageDescriptor) (*MessageDescriptor, error) {
+ d := loadedDescriptors.get(md)
+ if d != nil {
+ return d.(*MessageDescriptor), nil
}
- pt := proto.MessageType(message)
- if pt == nil {
- return nil, nil
- }
- msg, err := messageFromType(pt)
+ var err error
+ loadedDescriptors.withLock(func(cache descriptorCache) {
+ d, err = wrapMessage(md, cache)
+ })
if err != nil {
return nil, err
}
-
- cacheMu.Lock()
- defer cacheMu.Unlock()
- return loadMessageDescriptorForTypeLocked(message, msg, r)
+ return d.(*MessageDescriptor), err
}
// LoadMessageDescriptorForType loads descriptor using the encoded descriptor proto returned
// by message.Descriptor() for the given message type. If the given type is not recognized,
// then a nil descriptor is returned.
func LoadMessageDescriptorForType(messageType reflect.Type) (*MessageDescriptor, error) {
- return loadMessageDescriptorForType(messageType, nil)
-}
-
-func loadMessageDescriptorForType(messageType reflect.Type, r *ImportResolver) (*MessageDescriptor, error) {
m, err := messageFromType(messageType)
if err != nil {
return nil, err
}
- return loadMessageDescriptorForMessage(m, r)
+ return LoadMessageDescriptorForMessage(m)
}
// LoadMessageDescriptorForMessage loads descriptor using the encoded descriptor proto
// returned by message.Descriptor(). If the given type is not recognized, then a nil
// descriptor is returned.
func LoadMessageDescriptorForMessage(message proto.Message) (*MessageDescriptor, error) {
- return loadMessageDescriptorForMessage(message, nil)
-}
-
-func loadMessageDescriptorForMessage(message proto.Message, r *ImportResolver) (*MessageDescriptor, error) {
// efficiently handle dynamic messages
type descriptorable interface {
GetMessageDescriptor() *MessageDescriptor
@@ -153,57 +112,26 @@
return d.GetMessageDescriptor(), nil
}
- name := proto.MessageName(message)
- if name == "" {
- return nil, nil
+ var md protoreflect.MessageDescriptor
+ if m, ok := message.(protoreflect.ProtoMessage); ok {
+ md = m.ProtoReflect().Descriptor()
+ } else {
+ md = proto.MessageReflect(message).Descriptor()
}
- m := getMessageFromCache(name)
- if m != nil {
- return m, nil
- }
-
- cacheMu.Lock()
- defer cacheMu.Unlock()
- return loadMessageDescriptorForTypeLocked(name, message.(protoMessage), nil)
+ return loadMessageDescriptor(sourceinfo.WrapMessage(md))
}
-func messageFromType(mt reflect.Type) (protoMessage, error) {
+func messageFromType(mt reflect.Type) (proto.Message, error) {
if mt.Kind() != reflect.Ptr {
mt = reflect.PtrTo(mt)
}
- m, ok := reflect.Zero(mt).Interface().(protoMessage)
+ m, ok := reflect.Zero(mt).Interface().(proto.Message)
if !ok {
return nil, fmt.Errorf("failed to create message from type: %v", mt)
}
return m, nil
}
-func loadMessageDescriptorForTypeLocked(name string, message protoMessage, r *ImportResolver) (*MessageDescriptor, error) {
- m := messagesCache[name]
- if m != nil {
- return m, nil
- }
-
- fdb, _ := message.Descriptor()
- fd, err := internal.DecodeFileDescriptor(name, fdb)
- if err != nil {
- return nil, err
- }
-
- f, err := toFileDescriptorLocked(fd, r)
- if err != nil {
- return nil, err
- }
- putCacheLocked(fd.GetName(), f)
- return f.FindSymbol(name).(*MessageDescriptor), nil
-}
-
-func getMessageFromCache(message string) *MessageDescriptor {
- cacheMu.RLock()
- defer cacheMu.RUnlock()
- return messagesCache[message]
-}
-
// interface implemented by all generated enums
type protoEnum interface {
EnumDescriptor() ([]byte, []int)
@@ -220,10 +148,6 @@
// LoadEnumDescriptorForType loads descriptor using the encoded descriptor proto returned
// by enum.EnumDescriptor() for the given enum type.
func LoadEnumDescriptorForType(enumType reflect.Type) (*EnumDescriptor, error) {
- return loadEnumDescriptorForType(enumType, nil)
-}
-
-func loadEnumDescriptorForType(enumType reflect.Type, r *ImportResolver) (*EnumDescriptor, error) {
// we cache descriptors using non-pointer type
if enumType.Kind() == reflect.Ptr {
enumType = enumType.Elem()
@@ -237,18 +161,24 @@
return nil, err
}
- cacheMu.Lock()
- defer cacheMu.Unlock()
- return loadEnumDescriptorForTypeLocked(enumType, enum, r)
+ return loadEnumDescriptor(enumType, enum)
+}
+
+func getEnumFromCache(t reflect.Type) *EnumDescriptor {
+ loadedEnumsMu.RLock()
+ defer loadedEnumsMu.RUnlock()
+ return loadedEnums[t]
+}
+
+func putEnumInCache(t reflect.Type, d *EnumDescriptor) {
+ loadedEnumsMu.Lock()
+ defer loadedEnumsMu.Unlock()
+ loadedEnums[t] = d
}
// LoadEnumDescriptorForEnum loads descriptor using the encoded descriptor proto
// returned by enum.EnumDescriptor().
func LoadEnumDescriptorForEnum(enum protoEnum) (*EnumDescriptor, error) {
- return loadEnumDescriptorForEnum(enum, nil)
-}
-
-func loadEnumDescriptorForEnum(enum protoEnum, r *ImportResolver) (*EnumDescriptor, error) {
et := reflect.TypeOf(enum)
// we cache descriptors using non-pointer type
if et.Kind() == reflect.Ptr {
@@ -260,55 +190,46 @@
return e, nil
}
- cacheMu.Lock()
- defer cacheMu.Unlock()
- return loadEnumDescriptorForTypeLocked(et, enum, r)
+ return loadEnumDescriptor(et, enum)
}
func enumFromType(et reflect.Type) (protoEnum, error) {
- if et.Kind() != reflect.Int32 {
- et = reflect.PtrTo(et)
- }
e, ok := reflect.Zero(et).Interface().(protoEnum)
if !ok {
+ if et.Kind() != reflect.Ptr {
+ et = et.Elem()
+ }
+ e, ok = reflect.Zero(et).Interface().(protoEnum)
+ }
+ if !ok {
return nil, fmt.Errorf("failed to create enum from type: %v", et)
}
return e, nil
}
-func loadEnumDescriptorForTypeLocked(et reflect.Type, enum protoEnum, r *ImportResolver) (*EnumDescriptor, error) {
- e := enumCache[et]
- if e != nil {
- return e, nil
- }
-
+func getDescriptorForEnum(enum protoEnum) (*descriptorpb.FileDescriptorProto, []int, error) {
fdb, path := enum.EnumDescriptor()
- name := fmt.Sprintf("%v", et)
+ name := fmt.Sprintf("%T", enum)
fd, err := internal.DecodeFileDescriptor(name, fdb)
+ return fd, path, err
+}
+
+func loadEnumDescriptor(et reflect.Type, enum protoEnum) (*EnumDescriptor, error) {
+ fdp, path, err := getDescriptorForEnum(enum)
if err != nil {
return nil, err
}
- // see if we already have cached "rich" descriptor
- f, ok := filesCache[fd.GetName()]
- if !ok {
- f, err = toFileDescriptorLocked(fd, r)
- if err != nil {
- return nil, err
- }
- putCacheLocked(fd.GetName(), f)
+
+ fd, err := LoadFileDescriptor(fdp.GetName())
+ if err != nil {
+ return nil, err
}
- ed := findEnum(f, path)
- enumCache[et] = ed
+ ed := findEnum(fd, path)
+ putEnumInCache(et, ed)
return ed, nil
}
-func getEnumFromCache(et reflect.Type) *EnumDescriptor {
- cacheMu.RLock()
- defer cacheMu.RUnlock()
- return enumCache[et]
-}
-
func findEnum(fd *FileDescriptor, path []int) *EnumDescriptor {
if len(path) == 1 {
return fd.GetEnumTypes()[path[0]]
@@ -323,11 +244,7 @@
// LoadFieldDescriptorForExtension loads the field descriptor that corresponds to the given
// extension description.
func LoadFieldDescriptorForExtension(ext *proto.ExtensionDesc) (*FieldDescriptor, error) {
- return loadFieldDescriptorForExtension(ext, nil)
-}
-
-func loadFieldDescriptorForExtension(ext *proto.ExtensionDesc, r *ImportResolver) (*FieldDescriptor, error) {
- file, err := loadFileDescriptor(ext.Filename, r)
+ file, err := LoadFileDescriptor(ext.Filename)
if err != nil {
return nil, err
}