使用JSON-RPC编组数据时发生错误 - 我是否愚蠢？

Question

因此，我正在使用类似于以下的代码，并且无法让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. 
} 

^^这是一个失败的功能，不知道为什么？它返回一个零（和它的报告为一个零，但错误出了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 $ 

有没有人遇到过类似的 - 如果我宣布一个新的类型没有帮助扔周围要么和我没有看到一个前进的方向。

切圆，但可能相关的，我编一个围棋程序存档并建立它变成一个C程序改变接口匹配一个富而不是之前一个Foo界面，并且工作！奇怪。

Answer 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为非零值，它应该工作。