使用 JSON-RPC 编组数据时出错 - 我是否很笨？

Posted 2023-02-16

【中文标题】使用 JSON-RPC 编组数据时出错 - 我是否很笨？

【英文标题】：Go bug when marshalling data using JSON-RPC - am I being dumb?使用 JSON-RPC 编组数据时出错 - 我是不是很笨？

【发布时间】：2015-09-05 09:00:57

【问题描述】：

所以我正在使用类似于以下的代码，并且无法让 RPC 在 FooHolder 中工作，它保存满足接口的对象。我可能遗漏了一些东西，但它看起来应该可以工作 - 使用反射包它可以正确识别类型但是当函数返回时出现问题......

package main

import (
    "log"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
    "reflect"
)

type FooInterface interface 
    DoTheBartman(in *string, out *string) error
    DoThis(in *[]string, out *[]string) error
    NoProblems(in *int, out *int) error


type Foo struct 
    wibble string


func (f *Foo) DoTheBartman(in *string, out *string) error 
    log.Println("do the bartman")
    *out = "^^[ " + *in + "]^^"
    return nil


func (f *Foo) DoThis(in *[]string, out *[]string) error 
    log.Println("Doing this")
    log.Println("Type in - ", reflect.TypeOf(in))
    log.Println("Type *in - ", reflect.TypeOf(*in))
    log.Println("Type out - ", reflect.TypeOf(out))
    log.Println("Type *out - ", reflect.TypeOf(*out))

    *out = append(*in, "Hello")

    return nil


type FooHolder struct 
    TheFoos []FooInterface


func (fh *FooHolder) GetFoos(in *[]Foo, out *[]Foo) error 
    log.Println("Getting Foos...")
    log.Println("Type in - ", reflect.TypeOf(in))
    log.Println("Type *in - ", reflect.TypeOf(*in))
    log.Println("Type out - ", reflect.TypeOf(out))
    log.Println("Type *out - ", reflect.TypeOf(*out))

    return nil // This fails but with a nil... what's up with that.

^^ 这是失败的函数，不知道为什么？它返回一个 nil（它被报告为一个 nil 但错误退出 1

func (f *Foo) NoProblems(in *int, out *int) error 
    log.Println("No Problems doing maths")
    log.Println("Type in - ", reflect.TypeOf(in))
    log.Println("Type *in - ", reflect.TypeOf(*in))
    log.Println("Type out - ", reflect.TypeOf(out))
    log.Println("Type *out - ", reflect.TypeOf(*out))

    *out = 42 - (*in)
    return nil


// This all works just fine
func startServer(f FooInterface) 
    server := rpc.NewServer()
    server.Register(f)

    l, e := net.Listen("tcp", ":8222")
    if e != nil 
        log.Fatal("listen error:", e)
    

    for 
        conn, err := l.Accept()
        if err != nil 
            log.Fatal(err)
        
        log.Println("Incoming!")

        go server.ServeCodec(jsonrpc.NewServerCodec(conn))
    


// It starts to go wrong here...
func startFooHolderServer(f *FooHolder) 
    server := rpc.NewServer()
    server.Register(f)

    l, e := net.Listen("tcp", ":8222")
    if e != nil 
        log.Fatal("listen error:", e)
    

    for 
        conn, err := l.Accept()
        if err != nil 
            log.Fatal(err)
        
        log.Println("Incoming!")

        go server.ServeCodec(jsonrpc.NewServerCodec(conn))
    


func main() 

    foo1 := &Foo

    fooHolder := &FooHolder

    fooHolder.TheFoos = append(fooHolder.TheFoos, foo1)

    // go startServer(foo1)
    go startFooHolderServer(fooHolder)

    conn, err := net.Dial("tcp", "localhost:8222")

    if err != nil 
        panic(err)
    
    defer conn.Close()

    c := jsonrpc.NewClient(conn)

    var foo []Foo
    log.Println("Type - ", reflect.TypeOf(foo))
    log.Println("Type - ", reflect.TypeOf(&foo))
    err = c.Call("FooHolder.GetFoos", foo, &foo)
    if err != nil 
        log.Fatal("RPC error:", err)
    

    // No Problems?
    var baz int
    err = c.Call("Foo.NoProblems", baz, &baz)
    if err != nil 
        log.Fatal("RPC error:", err)
    
    log.Println("Yay - baz is now", baz)

    stringArg := "Put stuff around me"
    err = c.Call("Foo.DoTheBartman", stringArg, &stringArg)
    if err != nil 
        log.Fatal("RPC error:", err)
    
    log.Println("Yay - stringArg is now", stringArg)

    // Also No Problem
    bar := append([]string"Hello", stringArg)
    log.Println("Type - ", reflect.TypeOf(bar))
    err = c.Call("Foo.DoThis", bar, &bar)
    if err != nil 
        log.Fatal("RPC error:", err)
    
    log.Println("Yay - bar is now", bar)

输出：

rpc-demo $ go run demo.go 
2015/09/05 20:48:32 Incoming!
2015/09/05 20:48:32 Type -  []main.Foo
2015/09/05 20:48:32 Type -  *[]main.Foo
2015/09/05 20:48:32 Getting Foos...
2015/09/05 20:48:32 Type in -  *[]main.Foo
2015/09/05 20:48:32 Type *in -  []main.Foo
2015/09/05 20:48:32 Type out -  *[]main.Foo
2015/09/05 20:48:32 Type *out -  []main.Foo
2015/09/05 20:48:32 RPC error:invalid error <nil>
exit status 1
rpc-demo $ 

有没有人遇到过类似的情况 - 如果我声明一个新类型并将其扔掉也无济于事，而且我看不到前进的方向。

切线，但可能相关，我编译了一个 Go 应用程序以存档并将其构建到 C 程序中，然后更改接口以匹配 Foo 而不是 Foo 接口，并且有效！很奇怪。

【参考方案1】：

这是抛出该错误的行：https://github.com/golang/go/blob/master/src/net/rpc/jsonrpc/client.go#L89

它是客户端，如果c.resp.Error != nil || c.resp.Result == nil，你可以看到它。

现在你没有返回任何错误，所以问题不在这里。

我认为问题在于您没有设置任何结果。 GetFoos 使 out 指针为零。将out 设置为非零值，它应该可以工作。

【讨论】：

我在代码中看到了这一点，但这是一条红鲱鱼。例如，将其更改为 play.golang.org/p/7rytALz-DB 仍然会产生问题（它不会在沙箱中运行，但您可以看到那里有一个非零赋值）。

重做它我可以让它在设置为play.golang.org/p/0Ve6FRhCXk时表现出来

in 是一个零切片。在第一个示例中，您将 0 个元素附加到它：仍然为零（证明：play.golang.org/p/e3LuKTRUCp）。在第二个链接中，您附加 1 个元素：不再是 nil