Implement custom options

[kerinin]

Custom option types appear to be broken - generated types do not implement ExtensionMap. Example protobuf definition:

syntax = "proto3";

import "google/protobuf/descriptor.proto";

extend google.protobuf.MessageOptions {
  string foo = 50001;
}


message MyMessage {
  option (foo) = "bar";
}

Attempting to access the option fails:

func main() {
    m := test.MyMessage{}

    ex, err = proto.GetExtension(&m, test.E_Foo)
    fmt.Printf("MyMessage.GetExtension: %+v, %+v\n", *ex.(*string), err)
}

// ./test.go:18: cannot use &m (type *test.MyMessage) as type proto.extendableProto in argument to proto.GetExtension:
//  *test.MyMessage does not implement proto.extendableProto (missing ExtensionMap method)

GetExtension succeeds with the original descriptor types (MessageOptions etc) if the extension defines a default type, but that provides pretty limited utility.

[cv]

I just bumped into the exact same issue. Is there a workaround?

[zellyn]

ExtensionMap() was removed recently. Make sure you have the latest version of github.com/golang/protobuf/proto: it should work with both old and new generated proto code.

[danny-cassidy]

I am also not able to get custom options working correctly with proto3 in golang.

I used the same .proto file supplied in the original post and the same main() functionality. I get this error:

proto: not an extendable proto

Here is the auto-generated go file:

type MyMessage struct {
}

func (m *MyMessage) Reset()                    { *m = MyMessage{} }
func (m *MyMessage) String() string            { return proto.CompactTextString(m) }
func (*MyMessage) ProtoMessage()               {}
func (*MyMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

var E_Foo = &proto.ExtensionDesc{
    ExtendedType:  (*google_protobuf.MessageOptions)(nil),
    ExtensionType: (*string)(nil),
    Field:         50001,
    Name:          "foo",
    Tag:           "bytes,50001,opt,name=foo",
}

func init() {
    proto.RegisterType((*MyMessage)(nil), "MyMessage")
    proto.RegisterExtension(E_Foo)
}

func init() { proto.RegisterFile("example.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
    // 129 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0xad, 0x48, 0xcc,
    0x2d, 0xc8, 0x49, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x97, 0x52, 0x48, 0xcf, 0xcf, 0x4f, 0xcf,
    0x49, 0xd5, 0x07, 0xf3, 0x92, 0x4a, 0xd3, 0xf4, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, 0x0b, 0x4a,
    0xf2, 0x8b, 0x20, 0x2a, 0x94, 0x44, 0xb8, 0x38, 0x7d, 0x2b, 0x7d, 0x53, 0x8b, 0x8b, 0x13, 0xd3,
    0x53, 0xad, 0xd8, 0xbb, 0xb6, 0x4a, 0x30, 0x27, 0x25, 0x16, 0x59, 0x19, 0x73, 0x31, 0xa7, 0xe5,
    0xe7, 0x0b, 0xc9, 0xeb, 0x41, 0xf4, 0xeb, 0xc1, 0xf4, 0xeb, 0x41, 0x55, 0xfa, 0x17, 0x94, 0x64,
    0xe6, 0xe7, 0x15, 0x4b, 0x5c, 0x6c, 0x63, 0x56, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xa9, 0x4e, 0x62,
    0x03, 0xab, 0x32, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x4c, 0xa2, 0x4c, 0x3c, 0x84, 0x00, 0x00,
    0x00,
}

Let me know if I am doing anything wrong or if you need more information.

[junghoahnsc]

I have the same issue. How can I get the descriptor of a proto?
I think I have to do something like MyMessage.GetDescriptor().GetExtension(E_Foo), but I couldn't find how to do that.

[junghoahnsc]

Does anyone know whether this is supported or not? I tried to look the source tree, but I couldn't find any clue.

[bcmills]

    m := test.MyMessage{}
    ex, err = proto.GetExtension(&m, test.E_Foo)

is definitely not the way to get options for the message. They're set as extensions on the MessageOptions, not the value returned by the Descriptor method itself.

I don't think the Descriptor method is intended for public consumption. It returns a serialized, gzip-compressed FileDescriptorProto and, I believe, a path of indices to follow (via the MessageType field of FileDescriptorProto and then perhaps the NestedType field of DescriptorProto?) to get to the message type definition. It should be possible to implement an accessor for the actual DescriptorProto on top of that, but I'm not aware of anything in the proto package API that does.

Once you have the DescriptorProto — and assuming that the protocol compiler correctly preserved all of its extensions, you should be able to call GetExtension on that to access the message options.

[junghoahnsc]

Thanks for the information.

I could access MessageOptions by

1. get gzipped FileDescriptorProto and Index by MyMessage.Desctipor()
2. ungzip and Unmarshal to FileDescriptorProto
3. get DescriptorProtot from FileDescriptorProto's message_type with Index
4. Access MessageOptions by proto.GetExtension

Is this the right way to do that?
As @bcmills mentioned, Descriptor() is intended for public consumption. Is there any other safe way to do that?

[bcmills]

Yep, that sounds about right. I'm not sure it's a huge amount of work to just provide a library that does all that; I'll see what I can do this week.

[bcmills]

You should be able to use the new descriptor subpackage to extract custom options from the descriptor.

@kerinin's example should be something like:

import (
    …
    "github.com/golang/protobuf/descriptor"
)

func main() {
    m := test.MyMessage{}

    _, md := descriptor.ForMessage(&m)
    ex, err = proto.GetExtension(md, test.E_Foo)
    fmt.Printf("MyMessage.GetExtension: %+v, %+v\n", *ex.(*string), err)
}

[timleung22]

It's not working for me... fd and md returned by the ForMessage () func is always google/protobuf/descriptor.proto and DescriptorProto respectively because my proto files import that.

In my proto file Booking.proto:

package com.example
import "google/protobuf/descriptor.proto"
...

and calling ForMessage(descriptor) where descriptor is the *DescriptorProto of my message "BookingStatus", just gives me google/protobuf/descriptor.proto and DescriptorProto