[VOL-5486] Fix deprecated versions
Change-Id: I3e03ea246020547ae75fa92ce8cf5cbba7e8f3bb
Signed-off-by: Abhay Kumar <abhay.kumar@radisys.com>
diff --git a/vendor/github.com/jhump/protoreflect/grpcreflect/adapt.go b/vendor/github.com/jhump/protoreflect/grpcreflect/adapt.go
new file mode 100644
index 0000000..661b925
--- /dev/null
+++ b/vendor/github.com/jhump/protoreflect/grpcreflect/adapt.go
@@ -0,0 +1,137 @@
+package grpcreflect
+
+import (
+ refv1 "google.golang.org/grpc/reflection/grpc_reflection_v1"
+ refv1alpha "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
+)
+
+func toV1Request(v1alpha *refv1alpha.ServerReflectionRequest) *refv1.ServerReflectionRequest {
+ var v1 refv1.ServerReflectionRequest
+ v1.Host = v1alpha.Host
+ switch mr := v1alpha.MessageRequest.(type) {
+ case *refv1alpha.ServerReflectionRequest_FileByFilename:
+ v1.MessageRequest = &refv1.ServerReflectionRequest_FileByFilename{
+ FileByFilename: mr.FileByFilename,
+ }
+ case *refv1alpha.ServerReflectionRequest_FileContainingSymbol:
+ v1.MessageRequest = &refv1.ServerReflectionRequest_FileContainingSymbol{
+ FileContainingSymbol: mr.FileContainingSymbol,
+ }
+ case *refv1alpha.ServerReflectionRequest_FileContainingExtension:
+ if mr.FileContainingExtension != nil {
+ v1.MessageRequest = &refv1.ServerReflectionRequest_FileContainingExtension{
+ FileContainingExtension: &refv1.ExtensionRequest{
+ ContainingType: mr.FileContainingExtension.GetContainingType(),
+ ExtensionNumber: mr.FileContainingExtension.GetExtensionNumber(),
+ },
+ }
+ }
+ case *refv1alpha.ServerReflectionRequest_AllExtensionNumbersOfType:
+ v1.MessageRequest = &refv1.ServerReflectionRequest_AllExtensionNumbersOfType{
+ AllExtensionNumbersOfType: mr.AllExtensionNumbersOfType,
+ }
+ case *refv1alpha.ServerReflectionRequest_ListServices:
+ v1.MessageRequest = &refv1.ServerReflectionRequest_ListServices{
+ ListServices: mr.ListServices,
+ }
+ default:
+ // no value set
+ }
+ return &v1
+}
+
+func toV1AlphaRequest(v1 *refv1.ServerReflectionRequest) *refv1alpha.ServerReflectionRequest {
+ var v1alpha refv1alpha.ServerReflectionRequest
+ v1alpha.Host = v1.Host
+ switch mr := v1.MessageRequest.(type) {
+ case *refv1.ServerReflectionRequest_FileByFilename:
+ if mr != nil {
+ v1alpha.MessageRequest = &refv1alpha.ServerReflectionRequest_FileByFilename{
+ FileByFilename: mr.FileByFilename,
+ }
+ }
+ case *refv1.ServerReflectionRequest_FileContainingSymbol:
+ if mr != nil {
+ v1alpha.MessageRequest = &refv1alpha.ServerReflectionRequest_FileContainingSymbol{
+ FileContainingSymbol: mr.FileContainingSymbol,
+ }
+ }
+ case *refv1.ServerReflectionRequest_FileContainingExtension:
+ if mr != nil {
+ v1alpha.MessageRequest = &refv1alpha.ServerReflectionRequest_FileContainingExtension{
+ FileContainingExtension: &refv1alpha.ExtensionRequest{
+ ContainingType: mr.FileContainingExtension.GetContainingType(),
+ ExtensionNumber: mr.FileContainingExtension.GetExtensionNumber(),
+ },
+ }
+ }
+ case *refv1.ServerReflectionRequest_AllExtensionNumbersOfType:
+ if mr != nil {
+ v1alpha.MessageRequest = &refv1alpha.ServerReflectionRequest_AllExtensionNumbersOfType{
+ AllExtensionNumbersOfType: mr.AllExtensionNumbersOfType,
+ }
+ }
+ case *refv1.ServerReflectionRequest_ListServices:
+ if mr != nil {
+ v1alpha.MessageRequest = &refv1alpha.ServerReflectionRequest_ListServices{
+ ListServices: mr.ListServices,
+ }
+ }
+ default:
+ // no value set
+ }
+ return &v1alpha
+}
+
+func toV1Response(v1alpha *refv1alpha.ServerReflectionResponse) *refv1.ServerReflectionResponse {
+ var v1 refv1.ServerReflectionResponse
+ v1.ValidHost = v1alpha.ValidHost
+ if v1alpha.OriginalRequest != nil {
+ v1.OriginalRequest = toV1Request(v1alpha.OriginalRequest)
+ }
+ switch mr := v1alpha.MessageResponse.(type) {
+ case *refv1alpha.ServerReflectionResponse_FileDescriptorResponse:
+ if mr != nil {
+ v1.MessageResponse = &refv1.ServerReflectionResponse_FileDescriptorResponse{
+ FileDescriptorResponse: &refv1.FileDescriptorResponse{
+ FileDescriptorProto: mr.FileDescriptorResponse.GetFileDescriptorProto(),
+ },
+ }
+ }
+ case *refv1alpha.ServerReflectionResponse_AllExtensionNumbersResponse:
+ if mr != nil {
+ v1.MessageResponse = &refv1.ServerReflectionResponse_AllExtensionNumbersResponse{
+ AllExtensionNumbersResponse: &refv1.ExtensionNumberResponse{
+ BaseTypeName: mr.AllExtensionNumbersResponse.GetBaseTypeName(),
+ ExtensionNumber: mr.AllExtensionNumbersResponse.GetExtensionNumber(),
+ },
+ }
+ }
+ case *refv1alpha.ServerReflectionResponse_ListServicesResponse:
+ if mr != nil {
+ svcs := make([]*refv1.ServiceResponse, len(mr.ListServicesResponse.GetService()))
+ for i, svc := range mr.ListServicesResponse.GetService() {
+ svcs[i] = &refv1.ServiceResponse{
+ Name: svc.GetName(),
+ }
+ }
+ v1.MessageResponse = &refv1.ServerReflectionResponse_ListServicesResponse{
+ ListServicesResponse: &refv1.ListServiceResponse{
+ Service: svcs,
+ },
+ }
+ }
+ case *refv1alpha.ServerReflectionResponse_ErrorResponse:
+ if mr != nil {
+ v1.MessageResponse = &refv1.ServerReflectionResponse_ErrorResponse{
+ ErrorResponse: &refv1.ErrorResponse{
+ ErrorCode: mr.ErrorResponse.GetErrorCode(),
+ ErrorMessage: mr.ErrorResponse.GetErrorMessage(),
+ },
+ }
+ }
+ default:
+ // no value set
+ }
+ return &v1
+}
diff --git a/vendor/github.com/jhump/protoreflect/grpcreflect/client.go b/vendor/github.com/jhump/protoreflect/grpcreflect/client.go
index 3fca3eb..1a35540 100644
--- a/vendor/github.com/jhump/protoreflect/grpcreflect/client.go
+++ b/vendor/github.com/jhump/protoreflect/grpcreflect/client.go
@@ -2,23 +2,39 @@
import (
"bytes"
+ "context"
"fmt"
"io"
"reflect"
"runtime"
+ "sort"
"sync"
+ "sync/atomic"
+ "time"
"github.com/golang/protobuf/proto"
- dpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
- "golang.org/x/net/context"
+ "google.golang.org/grpc"
"google.golang.org/grpc/codes"
- rpb "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
+ refv1 "google.golang.org/grpc/reflection/grpc_reflection_v1"
+ refv1alpha "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
"google.golang.org/grpc/status"
+ "google.golang.org/protobuf/reflect/protodesc"
+ "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoregistry"
+ "google.golang.org/protobuf/types/descriptorpb"
"github.com/jhump/protoreflect/desc"
"github.com/jhump/protoreflect/internal"
)
+// If we try the v1 reflection API and get back "not implemented", we'll wait
+// this long before trying v1 again. This allows a long-lived client to
+// dynamically switch from v1alpha to v1 if the underlying server is updated
+// to support it. But it also prevents every stream request from always trying
+// v1 first: if we try it and see it fail, we shouldn't continually retry it
+// if we expect it will fail again.
+const durationBetweenV1Attempts = time.Hour
+
// elementNotFoundError is the error returned by reflective operations where the
// server does not recognize a given file name, symbol name, or extension.
type elementNotFoundError struct {
@@ -51,14 +67,31 @@
)
func symbolNotFound(symbol string, symType symbolType, cause *elementNotFoundError) error {
+ if cause != nil && cause.kind == elementKindSymbol && cause.name == symbol {
+ // no need to wrap
+ if symType != symbolTypeUnknown && cause.symType == symbolTypeUnknown {
+ // We previously didn't know symbol type but now do?
+ // Create a new error that has the right symbol type.
+ return &elementNotFoundError{name: symbol, symType: symType, kind: elementKindSymbol}
+ }
+ return cause
+ }
return &elementNotFoundError{name: symbol, symType: symType, kind: elementKindSymbol, cause: cause}
}
func extensionNotFound(extendee string, tag int32, cause *elementNotFoundError) error {
+ if cause != nil && cause.kind == elementKindExtension && cause.name == extendee && cause.tag == tag {
+ // no need to wrap
+ return cause
+ }
return &elementNotFoundError{name: extendee, tag: tag, kind: elementKindExtension, cause: cause}
}
func fileNotFound(file string, cause *elementNotFoundError) error {
+ if cause != nil && cause.kind == elementKindFile && cause.name == file {
+ // no need to wrap
+ return cause
+ }
return &elementNotFoundError{name: file, kind: elementKindFile, cause: cause}
}
@@ -69,15 +102,15 @@
if first {
first = false
} else {
- fmt.Fprint(&b, "\ncaused by: ")
+ _, _ = fmt.Fprint(&b, "\ncaused by: ")
}
switch e.kind {
case elementKindSymbol:
- fmt.Fprintf(&b, "%s not found: %s", e.symType, e.name)
+ _, _ = fmt.Fprintf(&b, "%s not found: %s", e.symType, e.name)
case elementKindExtension:
- fmt.Fprintf(&b, "Extension not found: tag %d for %s", e.tag, e.name)
+ _, _ = fmt.Fprintf(&b, "Extension not found: tag %d for %s", e.tag, e.name)
default:
- fmt.Fprintf(&b, "File not found: %s", e.name)
+ _, _ = fmt.Fprintf(&b, "File not found: %s", e.name)
}
}
return b.String()
@@ -105,79 +138,186 @@
extensionNumber int32
}
+type resolvers struct {
+ descriptorResolver protodesc.Resolver
+ extensionResolver protoregistry.ExtensionTypeResolver
+}
+
+type fileEntry struct {
+ fd *desc.FileDescriptor
+ fallback bool
+}
+
// Client is a client connection to a server for performing reflection calls
// and resolving remote symbols.
type Client struct {
- ctx context.Context
- stub rpb.ServerReflectionClient
+ ctx context.Context
+ now func() time.Time
+ stubV1 refv1.ServerReflectionClient
+ stubV1Alpha refv1alpha.ServerReflectionClient
+ allowMissing atomic.Bool
+ fallbackResolver atomic.Pointer[resolvers]
- connMu sync.Mutex
- cancel context.CancelFunc
- stream rpb.ServerReflection_ServerReflectionInfoClient
+ connMu sync.Mutex
+ cancel context.CancelFunc
+ stream refv1.ServerReflection_ServerReflectionInfoClient
+ useV1Alpha bool
+ lastTriedV1 time.Time
cacheMu sync.RWMutex
- protosByName map[string]*dpb.FileDescriptorProto
- filesByName map[string]*desc.FileDescriptor
- filesBySymbol map[string]*desc.FileDescriptor
- filesByExtension map[extDesc]*desc.FileDescriptor
+ protosByName map[string]*descriptorpb.FileDescriptorProto
+ filesByName map[string]fileEntry
+ filesBySymbol map[string]fileEntry
+ filesByExtension map[extDesc]fileEntry
}
// NewClient creates a new Client with the given root context and using the
// given RPC stub for talking to the server.
-func NewClient(ctx context.Context, stub rpb.ServerReflectionClient) *Client {
+//
+// Deprecated: Use NewClientV1Alpha if you are intentionally pinning the
+// v1alpha version of the reflection service. Otherwise, use NewClientAuto
+// instead.
+func NewClient(ctx context.Context, stub refv1alpha.ServerReflectionClient) *Client {
+ return NewClientV1Alpha(ctx, stub)
+}
+
+// NewClientV1Alpha creates a new Client using the v1alpha version of reflection
+// with the given root context and using the given RPC stub for talking to the
+// server.
+func NewClientV1Alpha(ctx context.Context, stub refv1alpha.ServerReflectionClient) *Client {
+ return newClient(ctx, nil, stub)
+}
+
+// NewClientV1 creates a new Client using the v1 version of reflection with the
+// given root context and using the given RPC stub for talking to the server.
+func NewClientV1(ctx context.Context, stub refv1.ServerReflectionClient) *Client {
+ return newClient(ctx, stub, nil)
+}
+
+func newClient(ctx context.Context, stubv1 refv1.ServerReflectionClient, stubv1alpha refv1alpha.ServerReflectionClient) *Client {
cr := &Client{
ctx: ctx,
- stub: stub,
- protosByName: map[string]*dpb.FileDescriptorProto{},
- filesByName: map[string]*desc.FileDescriptor{},
- filesBySymbol: map[string]*desc.FileDescriptor{},
- filesByExtension: map[extDesc]*desc.FileDescriptor{},
+ now: time.Now,
+ stubV1: stubv1,
+ stubV1Alpha: stubv1alpha,
+ protosByName: map[string]*descriptorpb.FileDescriptorProto{},
+ filesByName: map[string]fileEntry{},
+ filesBySymbol: map[string]fileEntry{},
+ filesByExtension: map[extDesc]fileEntry{},
}
// don't leak a grpc stream
runtime.SetFinalizer(cr, (*Client).Reset)
return cr
}
+// NewClientAuto creates a new Client that will use either v1 or v1alpha version
+// of reflection (based on what the server supports) with the given root context
+// and using the given client connection.
+//
+// It will first the v1 version of the reflection service. If it gets back an
+// "Unimplemented" error, it will fall back to using the v1alpha version. It
+// will remember which version the server supports for any subsequent operations
+// that need to re-invoke the streaming RPC. But, if it's a very long-lived
+// client, it will periodically retry the v1 version (in case the server is
+// updated to support it also). The period for these retries is every hour.
+func NewClientAuto(ctx context.Context, cc grpc.ClientConnInterface) *Client {
+ stubv1 := refv1.NewServerReflectionClient(cc)
+ stubv1alpha := refv1alpha.NewServerReflectionClient(cc)
+ return newClient(ctx, stubv1, stubv1alpha)
+}
+
+// AllowMissingFileDescriptors configures the client to allow missing files
+// when building descriptors when possible. Missing files are often fatal
+// errors, but with this option they can sometimes be worked around. Building
+// a schema can only succeed with some files missing if the files in question
+// only provide custom options and/or other unused types.
+func (cr *Client) AllowMissingFileDescriptors() {
+ cr.allowMissing.Store(true)
+}
+
+// AllowFallbackResolver configures the client to allow falling back to the
+// given resolvers if the server is unable to supply descriptors for a particular
+// query. This allows working around issues where servers' reflection service
+// provides an incomplete set of descriptors, but the client has knowledge of
+// the missing descriptors from another source. It is usually most appropriate
+// to pass [protoregistry.GlobalFiles] and [protoregistry.GlobalTypes] as the
+// resolver values.
+//
+// The first value is used as a fallback for FileByFilename and FileContainingSymbol
+// queries. The second value is used as a fallback for FileContainingExtension. It
+// can also be used as a fallback for AllExtensionNumbersForType if it provides
+// a method with the following signature (which *[protoregistry.Types] provides):
+//
+// RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool)
+func (cr *Client) AllowFallbackResolver(descriptors protodesc.Resolver, exts protoregistry.ExtensionTypeResolver) {
+ if descriptors == nil && exts == nil {
+ cr.fallbackResolver.Store(nil)
+ } else {
+ cr.fallbackResolver.Store(&resolvers{
+ descriptorResolver: descriptors,
+ extensionResolver: exts,
+ })
+ }
+}
+
// FileByFilename asks the server for a file descriptor for the proto file with
// the given name.
func (cr *Client) FileByFilename(filename string) (*desc.FileDescriptor, error) {
// hit the cache first
cr.cacheMu.RLock()
- if fd, ok := cr.filesByName[filename]; ok {
+ if entry, ok := cr.filesByName[filename]; ok {
cr.cacheMu.RUnlock()
- return fd, nil
+ return entry.fd, nil
}
+ // not there? see if we've downloaded the proto
fdp, ok := cr.protosByName[filename]
cr.cacheMu.RUnlock()
- // not there? see if we've downloaded the proto
if ok {
return cr.descriptorFromProto(fdp)
}
- req := &rpb.ServerReflectionRequest{
- MessageRequest: &rpb.ServerReflectionRequest_FileByFilename{
+ req := &refv1.ServerReflectionRequest{
+ MessageRequest: &refv1.ServerReflectionRequest_FileByFilename{
FileByFilename: filename,
},
}
- fd, err := cr.getAndCacheFileDescriptors(req, filename, "")
+ accept := func(fd *desc.FileDescriptor) bool {
+ return fd.GetName() == filename
+ }
+
+ fd, err := cr.getAndCacheFileDescriptors(req, filename, "", accept)
if isNotFound(err) {
- // file not found? see if we can look up via alternate name
+ // File not found? see if we can look up via alternate name
if alternate, ok := internal.StdFileAliases[filename]; ok {
- req := &rpb.ServerReflectionRequest{
- MessageRequest: &rpb.ServerReflectionRequest_FileByFilename{
+ req := &refv1.ServerReflectionRequest{
+ MessageRequest: &refv1.ServerReflectionRequest_FileByFilename{
FileByFilename: alternate,
},
}
- fd, err = cr.getAndCacheFileDescriptors(req, alternate, filename)
- if isNotFound(err) {
- err = fileNotFound(filename, nil)
- }
- } else {
- err = fileNotFound(filename, nil)
+ fd, err = cr.getAndCacheFileDescriptors(req, alternate, filename, accept)
}
+ }
+ if isNotFound(err) {
+ // Still no? See if we can use a fallback resolver
+ resolver := cr.fallbackResolver.Load()
+ if resolver != nil && resolver.descriptorResolver != nil {
+ fileDesc, fallbackErr := resolver.descriptorResolver.FindFileByPath(filename)
+ if fallbackErr == nil {
+ var wrapErr error
+ fd, wrapErr = desc.WrapFile(fileDesc)
+ if wrapErr == nil {
+ fd = cr.cacheFile(fd, true)
+ err = nil // clear error since we've succeeded via the fallback
+ }
+ }
+ }
+ }
+ if isNotFound(err) {
+ err = fileNotFound(filename, nil)
} else if e, ok := err.(*elementNotFoundError); ok {
err = fileNotFound(filename, e)
}
+
return fd, err
}
@@ -186,18 +326,36 @@
func (cr *Client) FileContainingSymbol(symbol string) (*desc.FileDescriptor, error) {
// hit the cache first
cr.cacheMu.RLock()
- fd, ok := cr.filesBySymbol[symbol]
+ entry, ok := cr.filesBySymbol[symbol]
cr.cacheMu.RUnlock()
if ok {
- return fd, nil
+ return entry.fd, nil
}
- req := &rpb.ServerReflectionRequest{
- MessageRequest: &rpb.ServerReflectionRequest_FileContainingSymbol{
+ req := &refv1.ServerReflectionRequest{
+ MessageRequest: &refv1.ServerReflectionRequest_FileContainingSymbol{
FileContainingSymbol: symbol,
},
}
- fd, err := cr.getAndCacheFileDescriptors(req, "", "")
+ accept := func(fd *desc.FileDescriptor) bool {
+ return fd.FindSymbol(symbol) != nil
+ }
+ fd, err := cr.getAndCacheFileDescriptors(req, "", "", accept)
+ if isNotFound(err) {
+ // Symbol not found? See if we can use a fallback resolver
+ resolver := cr.fallbackResolver.Load()
+ if resolver != nil && resolver.descriptorResolver != nil {
+ d, fallbackErr := resolver.descriptorResolver.FindDescriptorByName(protoreflect.FullName(symbol))
+ if fallbackErr == nil {
+ var wrapErr error
+ fd, wrapErr = desc.WrapFile(d.ParentFile())
+ if wrapErr == nil {
+ fd = cr.cacheFile(fd, true)
+ err = nil // clear error since we've succeeded via the fallback
+ }
+ }
+ }
+ }
if isNotFound(err) {
err = symbolNotFound(symbol, symbolTypeUnknown, nil)
} else if e, ok := err.(*elementNotFoundError); ok {
@@ -212,21 +370,39 @@
func (cr *Client) FileContainingExtension(extendedMessageName string, extensionNumber int32) (*desc.FileDescriptor, error) {
// hit the cache first
cr.cacheMu.RLock()
- fd, ok := cr.filesByExtension[extDesc{extendedMessageName, extensionNumber}]
+ entry, ok := cr.filesByExtension[extDesc{extendedMessageName, extensionNumber}]
cr.cacheMu.RUnlock()
if ok {
- return fd, nil
+ return entry.fd, nil
}
- req := &rpb.ServerReflectionRequest{
- MessageRequest: &rpb.ServerReflectionRequest_FileContainingExtension{
- FileContainingExtension: &rpb.ExtensionRequest{
+ req := &refv1.ServerReflectionRequest{
+ MessageRequest: &refv1.ServerReflectionRequest_FileContainingExtension{
+ FileContainingExtension: &refv1.ExtensionRequest{
ContainingType: extendedMessageName,
ExtensionNumber: extensionNumber,
},
},
}
- fd, err := cr.getAndCacheFileDescriptors(req, "", "")
+ accept := func(fd *desc.FileDescriptor) bool {
+ return fd.FindExtension(extendedMessageName, extensionNumber) != nil
+ }
+ fd, err := cr.getAndCacheFileDescriptors(req, "", "", accept)
+ if isNotFound(err) {
+ // Extension not found? See if we can use a fallback resolver
+ resolver := cr.fallbackResolver.Load()
+ if resolver != nil && resolver.extensionResolver != nil {
+ extType, fallbackErr := resolver.extensionResolver.FindExtensionByNumber(protoreflect.FullName(extendedMessageName), protoreflect.FieldNumber(extensionNumber))
+ if fallbackErr == nil {
+ var wrapErr error
+ fd, wrapErr = desc.WrapFile(extType.TypeDescriptor().ParentFile())
+ if wrapErr == nil {
+ fd = cr.cacheFile(fd, true)
+ err = nil // clear error since we've succeeded via the fallback
+ }
+ }
+ }
+ }
if isNotFound(err) {
err = extensionNotFound(extendedMessageName, extensionNumber, nil)
} else if e, ok := err.(*elementNotFoundError); ok {
@@ -235,7 +411,7 @@
return fd, err
}
-func (cr *Client) getAndCacheFileDescriptors(req *rpb.ServerReflectionRequest, expectedName, alias string) (*desc.FileDescriptor, error) {
+func (cr *Client) getAndCacheFileDescriptors(req *refv1.ServerReflectionRequest, expectedName, alias string, accept func(*desc.FileDescriptor) bool) (*desc.FileDescriptor, error) {
resp, err := cr.send(req)
if err != nil {
return nil, err
@@ -253,9 +429,9 @@
// should be the answer). If we're looking for a file by name, we can be
// smarter and make sure to grab one by name instead of just grabbing the
// first one.
- var firstFd *dpb.FileDescriptorProto
+ var fds []*descriptorpb.FileDescriptorProto
for _, fdBytes := range fdResp.FileDescriptorProto {
- fd := &dpb.FileDescriptorProto{}
+ fd := &descriptorpb.FileDescriptorProto{}
if err = proto.Unmarshal(fdBytes, fd); err != nil {
return nil, err
}
@@ -266,13 +442,6 @@
}
cr.cacheMu.Lock()
- // see if this file was created and cached concurrently
- if firstFd == nil {
- if d, ok := cr.filesByName[fd.GetName()]; ok {
- cr.cacheMu.Unlock()
- return d, nil
- }
- }
// store in cache of raw descriptor protos, but don't overwrite existing protos
if existingFd, ok := cr.protosByName[fd.GetName()]; ok {
fd = existingFd
@@ -280,120 +449,208 @@
cr.protosByName[fd.GetName()] = fd
}
cr.cacheMu.Unlock()
- if firstFd == nil {
- firstFd = fd
- }
- }
- if firstFd == nil {
- return nil, &ProtocolError{reflect.TypeOf(firstFd).Elem()}
+
+ fds = append(fds, fd)
}
- return cr.descriptorFromProto(firstFd)
+ // find the right result from the files returned
+ for _, fd := range fds {
+ result, err := cr.descriptorFromProto(fd)
+ if err != nil {
+ return nil, err
+ }
+ if accept(result) {
+ return result, nil
+ }
+ }
+
+ return nil, status.Errorf(codes.NotFound, "response does not include expected file")
}
-func (cr *Client) descriptorFromProto(fd *dpb.FileDescriptorProto) (*desc.FileDescriptor, error) {
- deps := make([]*desc.FileDescriptor, len(fd.GetDependency()))
+func (cr *Client) descriptorFromProto(fd *descriptorpb.FileDescriptorProto) (*desc.FileDescriptor, error) {
+ allowMissing := cr.allowMissing.Load()
+ deps := make([]*desc.FileDescriptor, 0, len(fd.GetDependency()))
+ var deferredErr error
+ var missingDeps []int
for i, depName := range fd.GetDependency() {
if dep, err := cr.FileByFilename(depName); err != nil {
- return nil, err
+ if _, ok := err.(*elementNotFoundError); !ok || !allowMissing {
+ return nil, err
+ }
+ // We'll ignore for now to see if the file is really necessary.
+ // (If it only supplies custom options, we can get by without it.)
+ if deferredErr == nil {
+ deferredErr = err
+ }
+ missingDeps = append(missingDeps, i)
} else {
- deps[i] = dep
+ deps = append(deps, dep)
}
}
+ if len(missingDeps) > 0 {
+ fd = fileWithoutDeps(fd, missingDeps)
+ }
d, err := desc.CreateFileDescriptor(fd, deps...)
if err != nil {
+ if deferredErr != nil {
+ // assume the issue is the missing dep
+ return nil, deferredErr
+ }
return nil, err
}
- d = cr.cacheFile(d)
+ d = cr.cacheFile(d, false)
return d, nil
}
-func (cr *Client) cacheFile(fd *desc.FileDescriptor) *desc.FileDescriptor {
+func (cr *Client) cacheFile(fd *desc.FileDescriptor, fallback bool) *desc.FileDescriptor {
cr.cacheMu.Lock()
defer cr.cacheMu.Unlock()
- // cache file descriptor by name, but don't overwrite existing entry
- // (existing entry could come from concurrent caller)
- if existingFd, ok := cr.filesByName[fd.GetName()]; ok {
- return existingFd
+ // Cache file descriptor by name. If we can't overwrite an existing
+ // entry, return it. (Existing entry could come from concurrent caller.)
+ if existing, ok := cr.filesByName[fd.GetName()]; ok && !canOverwrite(existing, fallback) {
+ return existing.fd
}
- cr.filesByName[fd.GetName()] = fd
+ entry := fileEntry{fd: fd, fallback: fallback}
+ cr.filesByName[fd.GetName()] = entry
// also cache by symbols and extensions
for _, m := range fd.GetMessageTypes() {
- cr.cacheMessageLocked(fd, m)
+ cr.cacheMessageLocked(m, entry)
}
for _, e := range fd.GetEnumTypes() {
- cr.filesBySymbol[e.GetFullyQualifiedName()] = fd
+ if !cr.maybeCacheFileBySymbol(e.GetFullyQualifiedName(), entry) {
+ continue
+ }
for _, v := range e.GetValues() {
- cr.filesBySymbol[v.GetFullyQualifiedName()] = fd
+ cr.maybeCacheFileBySymbol(v.GetFullyQualifiedName(), entry)
}
}
for _, e := range fd.GetExtensions() {
- cr.filesBySymbol[e.GetFullyQualifiedName()] = fd
- cr.filesByExtension[extDesc{e.GetOwner().GetFullyQualifiedName(), e.GetNumber()}] = fd
+ if !cr.maybeCacheFileBySymbol(e.GetFullyQualifiedName(), entry) {
+ continue
+ }
+ cr.maybeCacheFileByExtension(extDesc{e.GetOwner().GetFullyQualifiedName(), e.GetNumber()}, entry)
}
for _, s := range fd.GetServices() {
- cr.filesBySymbol[s.GetFullyQualifiedName()] = fd
+ if !cr.maybeCacheFileBySymbol(s.GetFullyQualifiedName(), entry) {
+ continue
+ }
for _, m := range s.GetMethods() {
- cr.filesBySymbol[m.GetFullyQualifiedName()] = fd
+ cr.maybeCacheFileBySymbol(m.GetFullyQualifiedName(), entry)
}
}
return fd
}
-func (cr *Client) cacheMessageLocked(fd *desc.FileDescriptor, md *desc.MessageDescriptor) {
- cr.filesBySymbol[md.GetFullyQualifiedName()] = fd
+func (cr *Client) cacheMessageLocked(md *desc.MessageDescriptor, entry fileEntry) {
+ if !cr.maybeCacheFileBySymbol(md.GetFullyQualifiedName(), entry) {
+ return
+ }
for _, f := range md.GetFields() {
- cr.filesBySymbol[f.GetFullyQualifiedName()] = fd
+ cr.maybeCacheFileBySymbol(f.GetFullyQualifiedName(), entry)
}
for _, o := range md.GetOneOfs() {
- cr.filesBySymbol[o.GetFullyQualifiedName()] = fd
+ cr.maybeCacheFileBySymbol(o.GetFullyQualifiedName(), entry)
}
for _, e := range md.GetNestedEnumTypes() {
- cr.filesBySymbol[e.GetFullyQualifiedName()] = fd
+ if !cr.maybeCacheFileBySymbol(e.GetFullyQualifiedName(), entry) {
+ continue
+ }
for _, v := range e.GetValues() {
- cr.filesBySymbol[v.GetFullyQualifiedName()] = fd
+ cr.maybeCacheFileBySymbol(v.GetFullyQualifiedName(), entry)
}
}
for _, e := range md.GetNestedExtensions() {
- cr.filesBySymbol[e.GetFullyQualifiedName()] = fd
- cr.filesByExtension[extDesc{e.GetOwner().GetFullyQualifiedName(), e.GetNumber()}] = fd
+ if !cr.maybeCacheFileBySymbol(e.GetFullyQualifiedName(), entry) {
+ continue
+ }
+ cr.maybeCacheFileByExtension(extDesc{e.GetOwner().GetFullyQualifiedName(), e.GetNumber()}, entry)
}
for _, m := range md.GetNestedMessageTypes() {
- cr.cacheMessageLocked(fd, m) // recurse
+ cr.cacheMessageLocked(m, entry) // recurse
}
}
+func canOverwrite(existing fileEntry, fallback bool) bool {
+ return !fallback && existing.fallback
+}
+
+func (cr *Client) maybeCacheFileBySymbol(symbol string, entry fileEntry) bool {
+ existing, ok := cr.filesBySymbol[symbol]
+ if ok && !canOverwrite(existing, entry.fallback) {
+ return false
+ }
+ cr.filesBySymbol[symbol] = entry
+ return true
+}
+
+func (cr *Client) maybeCacheFileByExtension(ext extDesc, entry fileEntry) {
+ existing, ok := cr.filesByExtension[ext]
+ if ok && !canOverwrite(existing, entry.fallback) {
+ return
+ }
+ cr.filesByExtension[ext] = entry
+}
+
// AllExtensionNumbersForType asks the server for all known extension numbers
// for the given fully-qualified message name.
func (cr *Client) AllExtensionNumbersForType(extendedMessageName string) ([]int32, error) {
- req := &rpb.ServerReflectionRequest{
- MessageRequest: &rpb.ServerReflectionRequest_AllExtensionNumbersOfType{
+ req := &refv1.ServerReflectionRequest{
+ MessageRequest: &refv1.ServerReflectionRequest_AllExtensionNumbersOfType{
AllExtensionNumbersOfType: extendedMessageName,
},
}
resp, err := cr.send(req)
- if err != nil {
- if isNotFound(err) {
- return nil, symbolNotFound(extendedMessageName, symbolTypeMessage, nil)
- }
+ var exts []int32
+ if err != nil && !isNotFound(err) {
+ // If the server doesn't know about the message type and returns "not found",
+ // we'll treat that as "no known extensions" instead of returning an error.
return nil, err
}
-
- extResp := resp.GetAllExtensionNumbersResponse()
- if extResp == nil {
- return nil, &ProtocolError{reflect.TypeOf(extResp).Elem()}
+ if err == nil {
+ extResp := resp.GetAllExtensionNumbersResponse()
+ if extResp == nil {
+ return nil, &ProtocolError{reflect.TypeOf(extResp).Elem()}
+ }
+ exts = extResp.ExtensionNumber
}
- return extResp.ExtensionNumber, nil
+
+ resolver := cr.fallbackResolver.Load()
+ if resolver != nil && resolver.extensionResolver != nil {
+ type extRanger interface {
+ RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool)
+ }
+ if ranger, ok := resolver.extensionResolver.(extRanger); ok {
+ // Merge results with fallback resolver
+ extSet := map[int32]struct{}{}
+ ranger.RangeExtensionsByMessage(protoreflect.FullName(extendedMessageName), func(extType protoreflect.ExtensionType) bool {
+ extSet[int32(extType.TypeDescriptor().Number())] = struct{}{}
+ return true
+ })
+ if len(extSet) > 0 {
+ // De-dupe with the set of extension numbers we got
+ // from the server and merge the results back into exts.
+ for _, ext := range exts {
+ extSet[ext] = struct{}{}
+ }
+ exts = make([]int32, 0, len(extSet))
+ for ext := range extSet {
+ exts = append(exts, ext)
+ }
+ sort.Slice(exts, func(i, j int) bool { return exts[i] < exts[j] })
+ }
+ }
+ }
+ return exts, nil
}
// ListServices asks the server for the fully-qualified names of all exposed
// services.
func (cr *Client) ListServices() ([]string, error) {
- req := &rpb.ServerReflectionRequest{
- MessageRequest: &rpb.ServerReflectionRequest_ListServices{
+ req := &refv1.ServerReflectionRequest{
+ MessageRequest: &refv1.ServerReflectionRequest_ListServices{
// proto doesn't indicate any purpose for this value and server impl
// doesn't actually use it...
ListServices: "*",
@@ -415,10 +672,10 @@
return serviceNames, nil
}
-func (cr *Client) send(req *rpb.ServerReflectionRequest) (*rpb.ServerReflectionResponse, error) {
+func (cr *Client) send(req *refv1.ServerReflectionRequest) (*refv1.ServerReflectionResponse, error) {
// we allow one immediate retry, in case we have a stale stream
// (e.g. closed by server)
- resp, err := cr.doSend(true, req)
+ resp, err := cr.doSend(req)
if err != nil {
return nil, err
}
@@ -440,16 +697,33 @@
return ok && s.Code() == codes.NotFound
}
-func (cr *Client) doSend(retry bool, req *rpb.ServerReflectionRequest) (*rpb.ServerReflectionResponse, error) {
+func (cr *Client) doSend(req *refv1.ServerReflectionRequest) (*refv1.ServerReflectionResponse, error) {
// TODO: Streams are thread-safe, so we shouldn't need to lock. But without locking, we'll need more machinery
// (goroutines and channels) to ensure that responses are correctly correlated with their requests and thus
// delivered in correct oder.
cr.connMu.Lock()
defer cr.connMu.Unlock()
- return cr.doSendLocked(retry, req)
+ return cr.doSendLocked(0, nil, req)
}
-func (cr *Client) doSendLocked(retry bool, req *rpb.ServerReflectionRequest) (*rpb.ServerReflectionResponse, error) {
+func (cr *Client) doSendLocked(attemptCount int, prevErr error, req *refv1.ServerReflectionRequest) (*refv1.ServerReflectionResponse, error) {
+ if attemptCount >= 3 && prevErr != nil {
+ return nil, prevErr
+ }
+ if (status.Code(prevErr) == codes.Unimplemented ||
+ status.Code(prevErr) == codes.Unavailable) &&
+ cr.useV1() {
+ // If v1 is unimplemented, fallback to v1alpha.
+ // We also fallback on unavailable because some servers have been
+ // observed to close the connection/cancel the stream, w/out sending
+ // back status or headers, when the service name is not known. When
+ // this happens, the RPC status code is unavailable.
+ // See https://github.com/fullstorydev/grpcurl/issues/434
+ cr.useV1Alpha = true
+ cr.lastTriedV1 = cr.now()
+ }
+ attemptCount++
+
if err := cr.initStreamLocked(); err != nil {
return nil, err
}
@@ -460,21 +734,15 @@
_, err = cr.stream.Recv()
}
cr.resetLocked()
- if retry {
- return cr.doSendLocked(false, req)
- }
- return nil, err
+ return cr.doSendLocked(attemptCount, err, req)
}
- if resp, err := cr.stream.Recv(); err != nil {
+ resp, err := cr.stream.Recv()
+ if err != nil {
cr.resetLocked()
- if retry {
- return cr.doSendLocked(false, req)
- }
- return nil, err
- } else {
- return resp, nil
+ return cr.doSendLocked(attemptCount, err, req)
}
+ return resp, nil
}
func (cr *Client) initStreamLocked() error {
@@ -483,11 +751,38 @@
}
var newCtx context.Context
newCtx, cr.cancel = context.WithCancel(cr.ctx)
+ if cr.useV1Alpha == true && cr.now().Sub(cr.lastTriedV1) > durationBetweenV1Attempts {
+ // we're due for periodic retry of v1
+ cr.useV1Alpha = false
+ }
+ if cr.useV1() {
+ // try the v1 API
+ streamv1, err := cr.stubV1.ServerReflectionInfo(newCtx)
+ if err == nil {
+ cr.stream = streamv1
+ return nil
+ }
+ if status.Code(err) != codes.Unimplemented {
+ return err
+ }
+ // oh well, fall through below to try v1alpha and update state
+ // so we skip straight to v1alpha next time
+ cr.useV1Alpha = true
+ cr.lastTriedV1 = cr.now()
+ }
var err error
- cr.stream, err = cr.stub.ServerReflectionInfo(newCtx)
+ streamv1alpha, err := cr.stubV1Alpha.ServerReflectionInfo(newCtx)
+ if err == nil {
+ cr.stream = adaptStreamFromV1Alpha{streamv1alpha}
+ return nil
+ }
return err
}
+func (cr *Client) useV1() bool {
+ return !cr.useV1Alpha && cr.stubV1 != nil
+}
+
// Reset ensures that any active stream with the server is closed, releasing any
// resources.
func (cr *Client) Reset() {
@@ -498,7 +793,7 @@
func (cr *Client) resetLocked() {
if cr.stream != nil {
- cr.stream.CloseSend()
+ _ = cr.stream.CloseSend()
for {
// drain the stream, this covers io.EOF too
if _, err := cr.stream.Recv(); err != nil {
@@ -605,6 +900,46 @@
}
}
+func fileWithoutDeps(fd *descriptorpb.FileDescriptorProto, missingDeps []int) *descriptorpb.FileDescriptorProto {
+ // We need to rebuild the file without the missing deps.
+ fd = proto.Clone(fd).(*descriptorpb.FileDescriptorProto)
+ newNumDeps := len(fd.GetDependency()) - len(missingDeps)
+ newDeps := make([]string, 0, newNumDeps)
+ remapped := make(map[int]int, newNumDeps)
+ missingIdx := 0
+ for i, dep := range fd.GetDependency() {
+ if missingIdx < len(missingDeps) {
+ if i == missingDeps[missingIdx] {
+ // This dep was missing. Skip it.
+ missingIdx++
+ continue
+ }
+ }
+ remapped[i] = len(newDeps)
+ newDeps = append(newDeps, dep)
+ }
+ // Also rebuild public and weak import slices.
+ newPublic := make([]int32, 0, len(fd.GetPublicDependency()))
+ for _, idx := range fd.GetPublicDependency() {
+ newIdx, ok := remapped[int(idx)]
+ if ok {
+ newPublic = append(newPublic, int32(newIdx))
+ }
+ }
+ newWeak := make([]int32, 0, len(fd.GetWeakDependency()))
+ for _, idx := range fd.GetWeakDependency() {
+ newIdx, ok := remapped[int(idx)]
+ if ok {
+ newWeak = append(newWeak, int32(newIdx))
+ }
+ }
+
+ fd.Dependency = newDeps
+ fd.PublicDependency = newPublic
+ fd.WeakDependency = newWeak
+ return fd
+}
+
func findExtension(extendedType string, extensionNumber int32, scope extensionScope) *desc.FieldDescriptor {
// search extensions in this scope
for _, ext := range scope.extensions() {
@@ -664,3 +999,20 @@
}
return scopes
}
+
+type adaptStreamFromV1Alpha struct {
+ refv1alpha.ServerReflection_ServerReflectionInfoClient
+}
+
+func (a adaptStreamFromV1Alpha) Send(request *refv1.ServerReflectionRequest) error {
+ v1req := toV1AlphaRequest(request)
+ return a.ServerReflection_ServerReflectionInfoClient.Send(v1req)
+}
+
+func (a adaptStreamFromV1Alpha) Recv() (*refv1.ServerReflectionResponse, error) {
+ v1resp, err := a.ServerReflection_ServerReflectionInfoClient.Recv()
+ if err != nil {
+ return nil, err
+ }
+ return toV1Response(v1resp), nil
+}
diff --git a/vendor/github.com/jhump/protoreflect/grpcreflect/server.go b/vendor/github.com/jhump/protoreflect/grpcreflect/server.go
index c9ef619..7ff1912 100644
--- a/vendor/github.com/jhump/protoreflect/grpcreflect/server.go
+++ b/vendor/github.com/jhump/protoreflect/grpcreflect/server.go
@@ -4,13 +4,19 @@
"fmt"
"google.golang.org/grpc"
+ "google.golang.org/grpc/reflection"
"github.com/jhump/protoreflect/desc"
)
+// GRPCServer is the interface provided by a gRPC server. In addition to being a
+// service registrar (for registering services and handlers), it also has an
+// accessor for retrieving metadata about all registered services.
+type GRPCServer = reflection.GRPCServer
+
// LoadServiceDescriptors loads the service descriptors for all services exposed by the
// given GRPC server.
-func LoadServiceDescriptors(s *grpc.Server) (map[string]*desc.ServiceDescriptor, error) {
+func LoadServiceDescriptors(s GRPCServer) (map[string]*desc.ServiceDescriptor, error) {
descs := map[string]*desc.ServiceDescriptor{}
for name, info := range s.GetServiceInfo() {
file, ok := info.Metadata.(string)