khenaidoo | d948f77 | 2021-08-11 17:49:24 -0400 | [diff] [blame] | 1 | // Copyright 2016 The Go Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style |
| 3 | // license that can be found in the LICENSE file. |
| 4 | |
| 5 | // Package descriptor provides functions for obtaining the protocol buffer |
| 6 | // descriptors of generated Go types. |
| 7 | // |
| 8 | // Deprecated: See the "google.golang.org/protobuf/reflect/protoreflect" package |
| 9 | // for how to obtain an EnumDescriptor or MessageDescriptor in order to |
| 10 | // programatically interact with the protobuf type system. |
| 11 | package descriptor |
| 12 | |
| 13 | import ( |
| 14 | "bytes" |
| 15 | "compress/gzip" |
| 16 | "io/ioutil" |
| 17 | "sync" |
| 18 | |
| 19 | "github.com/golang/protobuf/proto" |
| 20 | "google.golang.org/protobuf/reflect/protodesc" |
| 21 | "google.golang.org/protobuf/reflect/protoreflect" |
| 22 | "google.golang.org/protobuf/runtime/protoimpl" |
| 23 | |
| 24 | descriptorpb "github.com/golang/protobuf/protoc-gen-go/descriptor" |
| 25 | ) |
| 26 | |
| 27 | // Message is proto.Message with a method to return its descriptor. |
| 28 | // |
| 29 | // Deprecated: The Descriptor method may not be generated by future |
| 30 | // versions of protoc-gen-go, meaning that this interface may not |
| 31 | // be implemented by many concrete message types. |
| 32 | type Message interface { |
| 33 | proto.Message |
| 34 | Descriptor() ([]byte, []int) |
| 35 | } |
| 36 | |
| 37 | // ForMessage returns the file descriptor proto containing |
| 38 | // the message and the message descriptor proto for the message itself. |
| 39 | // The returned proto messages must not be mutated. |
| 40 | // |
| 41 | // Deprecated: Not all concrete message types satisfy the Message interface. |
| 42 | // Use MessageDescriptorProto instead. If possible, the calling code should |
| 43 | // be rewritten to use protobuf reflection instead. |
| 44 | // See package "google.golang.org/protobuf/reflect/protoreflect" for details. |
| 45 | func ForMessage(m Message) (*descriptorpb.FileDescriptorProto, *descriptorpb.DescriptorProto) { |
| 46 | return MessageDescriptorProto(m) |
| 47 | } |
| 48 | |
| 49 | type rawDesc struct { |
| 50 | fileDesc []byte |
| 51 | indexes []int |
| 52 | } |
| 53 | |
| 54 | var rawDescCache sync.Map // map[protoreflect.Descriptor]*rawDesc |
| 55 | |
| 56 | func deriveRawDescriptor(d protoreflect.Descriptor) ([]byte, []int) { |
| 57 | // Fast-path: check whether raw descriptors are already cached. |
| 58 | origDesc := d |
| 59 | if v, ok := rawDescCache.Load(origDesc); ok { |
| 60 | return v.(*rawDesc).fileDesc, v.(*rawDesc).indexes |
| 61 | } |
| 62 | |
| 63 | // Slow-path: derive the raw descriptor from the v2 descriptor. |
| 64 | |
| 65 | // Start with the leaf (a given enum or message declaration) and |
| 66 | // ascend upwards until we hit the parent file descriptor. |
| 67 | var idxs []int |
| 68 | for { |
| 69 | idxs = append(idxs, d.Index()) |
| 70 | d = d.Parent() |
| 71 | if d == nil { |
| 72 | // TODO: We could construct a FileDescriptor stub for standalone |
| 73 | // descriptors to satisfy the API. |
| 74 | return nil, nil |
| 75 | } |
| 76 | if _, ok := d.(protoreflect.FileDescriptor); ok { |
| 77 | break |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | // Obtain the raw file descriptor. |
| 82 | fd := d.(protoreflect.FileDescriptor) |
| 83 | b, _ := proto.Marshal(protodesc.ToFileDescriptorProto(fd)) |
| 84 | file := protoimpl.X.CompressGZIP(b) |
| 85 | |
| 86 | // Reverse the indexes, since we populated it in reverse. |
| 87 | for i, j := 0, len(idxs)-1; i < j; i, j = i+1, j-1 { |
| 88 | idxs[i], idxs[j] = idxs[j], idxs[i] |
| 89 | } |
| 90 | |
| 91 | if v, ok := rawDescCache.LoadOrStore(origDesc, &rawDesc{file, idxs}); ok { |
| 92 | return v.(*rawDesc).fileDesc, v.(*rawDesc).indexes |
| 93 | } |
| 94 | return file, idxs |
| 95 | } |
| 96 | |
| 97 | // EnumRawDescriptor returns the GZIP'd raw file descriptor representing |
| 98 | // the enum and the index path to reach the enum declaration. |
| 99 | // The returned slices must not be mutated. |
| 100 | func EnumRawDescriptor(e proto.GeneratedEnum) ([]byte, []int) { |
| 101 | if ev, ok := e.(interface{ EnumDescriptor() ([]byte, []int) }); ok { |
| 102 | return ev.EnumDescriptor() |
| 103 | } |
| 104 | ed := protoimpl.X.EnumTypeOf(e) |
| 105 | return deriveRawDescriptor(ed.Descriptor()) |
| 106 | } |
| 107 | |
| 108 | // MessageRawDescriptor returns the GZIP'd raw file descriptor representing |
| 109 | // the message and the index path to reach the message declaration. |
| 110 | // The returned slices must not be mutated. |
| 111 | func MessageRawDescriptor(m proto.GeneratedMessage) ([]byte, []int) { |
| 112 | if mv, ok := m.(interface{ Descriptor() ([]byte, []int) }); ok { |
| 113 | return mv.Descriptor() |
| 114 | } |
| 115 | md := protoimpl.X.MessageTypeOf(m) |
| 116 | return deriveRawDescriptor(md.Descriptor()) |
| 117 | } |
| 118 | |
| 119 | var fileDescCache sync.Map // map[*byte]*descriptorpb.FileDescriptorProto |
| 120 | |
| 121 | func deriveFileDescriptor(rawDesc []byte) *descriptorpb.FileDescriptorProto { |
| 122 | // Fast-path: check whether descriptor protos are already cached. |
| 123 | if v, ok := fileDescCache.Load(&rawDesc[0]); ok { |
| 124 | return v.(*descriptorpb.FileDescriptorProto) |
| 125 | } |
| 126 | |
| 127 | // Slow-path: derive the descriptor proto from the GZIP'd message. |
| 128 | zr, err := gzip.NewReader(bytes.NewReader(rawDesc)) |
| 129 | if err != nil { |
| 130 | panic(err) |
| 131 | } |
| 132 | b, err := ioutil.ReadAll(zr) |
| 133 | if err != nil { |
| 134 | panic(err) |
| 135 | } |
| 136 | fd := new(descriptorpb.FileDescriptorProto) |
| 137 | if err := proto.Unmarshal(b, fd); err != nil { |
| 138 | panic(err) |
| 139 | } |
| 140 | if v, ok := fileDescCache.LoadOrStore(&rawDesc[0], fd); ok { |
| 141 | return v.(*descriptorpb.FileDescriptorProto) |
| 142 | } |
| 143 | return fd |
| 144 | } |
| 145 | |
| 146 | // EnumDescriptorProto returns the file descriptor proto representing |
| 147 | // the enum and the enum descriptor proto for the enum itself. |
| 148 | // The returned proto messages must not be mutated. |
| 149 | func EnumDescriptorProto(e proto.GeneratedEnum) (*descriptorpb.FileDescriptorProto, *descriptorpb.EnumDescriptorProto) { |
| 150 | rawDesc, idxs := EnumRawDescriptor(e) |
| 151 | if rawDesc == nil || idxs == nil { |
| 152 | return nil, nil |
| 153 | } |
| 154 | fd := deriveFileDescriptor(rawDesc) |
| 155 | if len(idxs) == 1 { |
| 156 | return fd, fd.EnumType[idxs[0]] |
| 157 | } |
| 158 | md := fd.MessageType[idxs[0]] |
| 159 | for _, i := range idxs[1 : len(idxs)-1] { |
| 160 | md = md.NestedType[i] |
| 161 | } |
| 162 | ed := md.EnumType[idxs[len(idxs)-1]] |
| 163 | return fd, ed |
| 164 | } |
| 165 | |
| 166 | // MessageDescriptorProto returns the file descriptor proto representing |
| 167 | // the message and the message descriptor proto for the message itself. |
| 168 | // The returned proto messages must not be mutated. |
| 169 | func MessageDescriptorProto(m proto.GeneratedMessage) (*descriptorpb.FileDescriptorProto, *descriptorpb.DescriptorProto) { |
| 170 | rawDesc, idxs := MessageRawDescriptor(m) |
| 171 | if rawDesc == nil || idxs == nil { |
| 172 | return nil, nil |
| 173 | } |
| 174 | fd := deriveFileDescriptor(rawDesc) |
| 175 | md := fd.MessageType[idxs[0]] |
| 176 | for _, i := range idxs[1:] { |
| 177 | md = md.NestedType[i] |
| 178 | } |
| 179 | return fd, md |
| 180 | } |