GO and GRPC: create protobuff classes "on flight"

Question

I'm new to GRPC and I cant resolve one problem. Is it possible to create protobuff files when app is already running? For example, I recive from user a json like this:

"protobuf_file": "protobuf.proto", // File will be also recieved from user
"service_name": "Unary",
"method_name": "GetServerResponse",
"request_data_serializer_name": "MessageRequest",
"body": "grpc_request_data.json", // File will be also recieved from user

Here I have a .proto file, name of service, method and message from it and another json with data to fill a message. Now I have to open connection and call desired method with provided data.

TY !

P.S. .proto file (from getting stated guide) will be:

syntax = "proto3";

package protobuf_all_modes;

service Unary {
 rpc GetServerResponse(MessageRequest) returns (MessageResponse) {}
}

message MessageRequest {
 string message = 1;
}

message MessageResponse {
 string message = 1;
 int32 random_int32 = 2;
}

and second json will be:

{
    "message": "hello World!"
}

I don't know were to look for solution. Will be grateful for any advice

Answer 1

If someone face same problem, there is a very good library - https://pkg.go.dev/github.com/jhump/[email protected]/dynamic and a subpackage https://pkg.go.dev/github.com/jhump/[email protected]/dynamic/grpcdynamic Code snippet will be: parser

func NewGrpcObject(operation *BaseOperation) *GrpcObject {
    fns, err := protoparse.ResolveFilenames([]string{"./"}, operation.ProtoFile) // prase .proto file
    if err != nil {
        log.Error(err)
    }

    parser := protoparse.Parser{}
    fds, err := parser.ParseFiles(fns...)
    if err != nil {
        log.Error(err)
    }
    descriptor := fds[0] // In my case there will be only one .proto
    pkg := descriptor.GetPackage()
    serviceDescriptor := descriptor.FindService(pkg + "." + operation.ServiceName) // name of service descriptor will be with package name first
    methodDescriptor := serviceDescriptor.FindMethodByName(operation.MethodName)
    requestDescriptor := methodDescriptor.GetInputType() // You can get types for request and response
    responseDescriptor := methodDescriptor.GetOutputType()

    return &GrpcObject{
        RequestDesc: requestDescriptor,
        MethodDesc: methodDescriptor,
        ResponseDesc: responseDescriptor,
    }
}

caller

// connect 
        conn, _ := grpc.Dial(operation.Host, grpc.WithTransportCredentials(credentials.NewTLS(c.TLSClientConfig.NewTLSConfig())))
        stub = grpcdynamic.NewStub(conn)

// call
    message := dynamic.NewMessage(operation.GrpcObject.RequestDesc) // from parser
    message.UnmarshalJSON(operation.Body) // here a JSON to fill message

    resp, err := stub.InvokeRpc(ctx, operation.GrpcObject.MethodDesc, message)
    if err != nil {
        // handle err
    }
    respMessage := dynamic.NewMessage(operation.GrpcObject.ResponseDesc) // descriptor from parser
    respMessage.ConvertFrom(resp) // convert message from raw response

Answer 2

Yes, in order to create protobuf files from arbitrary json, you will need some sort of proto library. protojson is a good one to use here, but in order to use it, you will need the definition of proto file in your application. See https://pkg.go.dev/google.golang.org/protobuf/encoding/protojson and the argument type, proto.Message.