2

我正在努力使用Golang Protobuf APIv2。

我正在尝试封装 protobuf 消息，以便可以调用服务器上的函数；编译时未知的函数。某种形式的东西：

syntax = "proto3";

package p;

import "google/protobuf/any.proto";

option go_package = "...";

message FunctionRequest {
    string name = 1;
    google.protobuf.Any parameters = 3;
}
message FunctionResponse {
    google.protobuf.Any result = 1;
    string error = 2;

}

我的目标是使用 protobufs 来定义函数而不是直接使用例如 Go 结构。

Google SDK 很复杂，我一直找不到示例。

例如

syntax = "proto3";

package e;

option go_package = "...";

service Adder {
    rpc add(AdderRequest) returns (AdderResponse) {};
}
message AdderRequest {
    int32 a = 1;
    int32 b = 2;
}
message AdderResponse {
    int32 result = 1;
}

IIUC 这个原始文本文件不能直接使用，需要转换为描述符文件：

protoc \
--proto_path=./protos \
--descriptor_set_out=descriptor.pb \
protos/adder.proto

我假设（显然是错误的）然后我可以将其读入并将其解组为descriptorpb.FileDescriptorProto：


b, err := ioutil.ReadFile("/path/to/descriptor.pb")
if err != nil {
    log.Fatal(err)
}

fdProto := &descriptorpb.FileDescriptorProto{}
proto.Unmarshal(b, fdProto)

问题：我应该怎么做？

假设客户端将发起对Adder上述服务的调用，服务器将需要一些能够将pbany.Any参数解组为正确的类型、调用函数并反转结果的过程。

奖励问题：

  • SDK 会要求我使用protoregistry来管理这些传入类型吗？或者有没有更简单的方法？调用将包括参数和结果的函数和类型，因此应该始终可以即时编组消息。
  • 任何使用的例子protoregistry？我被看似脱节的事情弄糊涂Files了Types
4

1 回答 1

5

好的，对于主要问题：

b, err := ioutil.ReadFile("/path/to/descriptor.pb")
if err != nil {
    log.Fatal(err)
}

fds := &descriptorpb.FileDescriptorSet{}
proto.Unmarshal(b, fds)

注意aFileDescriptorSet不是 aFileDescriptorProto

我继续对脱节感到困惑Files，Types但我怀疑开发人员的意图是能够将例如从文件中获得的消息移动到类型中。

我解决了我的直接问题：

package main

import (
    "fmt"
    "io/ioutil"
    "log"

    pb ".../protos"
    "google.golang.org/protobuf/proto"
    "google.golang.org/protobuf/reflect/protodesc"
    "google.golang.org/protobuf/reflect/protoreflect"
    "google.golang.org/protobuf/reflect/protoregistry"
    "google.golang.org/protobuf/types/descriptorpb"
    "google.golang.org/protobuf/types/dynamicpb"
    "google.golang.org/protobuf/types/known/anypb"
)

var _ protodesc.Resolver = (*protoregistry.Files)(nil)

const (
    projectRoot        = "."
    descriptorFilename = "descriptor.pb" // The output from `protoc --descriptor_set_out ...`
    protoFilename      = "adder.proto"   // The protoFilename will be one (of possibly several) in desc
    packageName        = "e"
    serviceName        = "Adder"
)

var (
    // By convention, the request message to be serviceName+"Request"
    message = service + "Request"
)

func toAny(t string, m protoreflect.ProtoMessage) (*anypb.Any, error) {
    v, err := proto.Marshal(m)
    if err != nil {
        return nil, err
    }

    return &anypb.Any{
        TypeUrl: t,
        Value:   v,
    }, nil
}
func readDescriptorSetFile(name string) (*descriptorpb.FileDescriptorSet, error) {
    b, err := ioutil.ReadFile(name)
    if err != nil {
        return nil, err
    }

    fds := &descriptorpb.FileDescriptorSet{}
    proto.Unmarshal(b, fds)
    return fds, nil
}
func byPath(ff *protoregistry.Files, path string, messageName string) (protoreflect.MessageDescriptor, error) {
    fd, err := ff.FindFileByPath(path)
    if err != nil {
        return nil, err
    }

    mds := fd.Messages()
    return mds.ByName(protoreflect.Name(messageName)), nil
}
func byName(ff *protoregistry.Files, packageName string, messageName string) (protoreflect.MessageDescriptor, error) {
    d, err := ff.FindDescriptorByName(protoreflect.FullName(fmt.Sprintf("%s.%s", packageName, messageName)))
    if err != nil {
        log.Fatal(err)
    }

    md, ok := d.(protoreflect.MessageDescriptor)
    if !ok {
        return nil, fmt.Errorf("type assertion to MessageDescriptor failed: %s", d.FullName())
    }
    return md, nil
}
func unmarshal(md protoreflect.MessageDescriptor, a *anypb.Any) (*dynamicpb.Message, error) {
    m := dynamicpb.NewMessage(md)
    err := proto.Unmarshal(a.GetValue(), m)
    if err != nil {
        return nil, err
    }
    return m, nil
}
func main() {

    // protoc \
    // --proto_path=./protos \
    // --descriptor_set_out=descriptor.pb \
    // protos/adder.proto

    fds, err := readDescriptorSetFile(fmt.Sprintf("%s/%s", projectRoot, descriptorFilename))

    ff, err := protodesc.NewFiles(fds)
    if err != nil {
        log.Fatal(err)
    }

    a, err := toAny(
        fmt.Sprintf("%s.%s", packageName, message),
        &pb.AdderRequest{
            A: 39,
            B: 3,
        })
    if err != nil {
        log.Fatal(err)
    }

    {
        md, err := byPath(ff, protoFilename, message)
        if err != nil {
            log.Fatal(err)
        }
        m, err := unmarshal(md, a)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("%+v", m)
    }
    {
        md, err := byName(ff, packageName, message)
        if err != nil {
            log.Fatal(err)
        }
        m, err := unmarshal(md, a)
        if err != nil {
            log.Fatal(err)
        }
        log.Printf("%+v", m)

    }
}

注意这可能看起来很迂回，因为我有pb.AdderRequest，但我正在寻找一个解决方案，只有根据定义才可用。

注意代码复制了方法：byPath因为byName我不确定我想要哪种方法。

于 2020-05-27T16:50:35.857 回答