Beispiel #1
0
func TestHTTPClient(t *testing.T) {
	ts := httptest.NewServer(jsonrpc2.HTTPHandler(nil))
	// Don't close because of https://github.com/golang/go/issues/12262
	// defer ts.Close()
	client := jsonrpc2.NewHTTPClient(ts.URL)
	defer client.Close()

	var in [2]int
	var got, want int

	in, want = [2]int{1, 2}, 3
	err := client.Call("Svc.Sum", in, &got)
	if err != nil {
		t.Errorf("Call(%v), err = %v", in, err)
	}
	if got != want {
		t.Errorf("Call(%v) = %v, want = %v", in, got, want)
	}

	in = [2]int{2, 3}
	err = client.Notify("Svc.Sum", in)
	if err != nil {
		t.Errorf("Notify(%v), err = %v", in, err)
	}

	in, want = [2]int{3, 4}, 7
	err = client.Call("Svc.Sum", in, &got)
	if err != nil {
		t.Errorf("Call(%v), err = %v", in, err)
	}
	if got != want {
		t.Errorf("Call(%v) = %v, want = %v", in, got, want)
	}
}
Beispiel #2
0
func BenchmarkJSONRPC2_http(b *testing.B) {
	ts := httptest.NewServer(jsonrpc2.HTTPHandler(nil))
	// Don't close because of https://github.com/golang/go/issues/12262
	// defer ts.Close()
	client := jsonrpc2.NewHTTPClient(ts.URL)
	defer client.Close()
	benchmarkRPC(b, client)
}
Beispiel #3
0
// - for each of these servers:
//   * TCP server without context
//   * TCP server with context
//   * HTTP server with context
// - call these methods:
//   * Sum()
//   * Name()
//   * NameCtx()
//   * TODO batch call all
func TestContext(t *testing.T) {
	// Server provide a TCP transport without context.
	serverTCPNoCtx, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	defer serverTCPNoCtx.Close()
	go func() {
		for {
			conn, err := serverTCPNoCtx.Accept()
			if err != nil {
				return
			}
			go jsonrpc2.ServeConn(conn)
		}
	}()

	// Server provide a TCP transport with context.
	serverTCP, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	defer serverTCP.Close()
	go func() {
		for {
			conn, err := serverTCP.Accept()
			if err != nil {
				return
			}
			ctx := context.WithValue(context.Background(), remoteAddrContextKey, conn.RemoteAddr())
			go jsonrpc2.ServeConnContext(ctx, conn)
		}
	}()

	// Server provide a HTTP transport with context.
	http.Handle("/", jsonrpc2.HTTPHandler(nil))
	serverHTTP, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	defer serverHTTP.Close()
	go http.Serve(serverHTTP, nil)

	// Client use TCP transport without context.
	clientTCPNoCtx, err := jsonrpc2.Dial("tcp", serverTCPNoCtx.Addr().String())
	if err != nil {
		t.Fatal(err)
	}
	defer clientTCPNoCtx.Close()

	// Client use TCP transport with context.
	clientTCP, err := jsonrpc2.Dial("tcp", serverTCP.Addr().String())
	if err != nil {
		t.Fatal(err)
	}
	defer clientTCP.Close()

	// Client use HTTP transport with context.
	clientHTTP := jsonrpc2.NewHTTPClient("http://" + serverHTTP.Addr().String() + "/")
	defer clientHTTP.Close()

	cases := []struct {
		client     *jsonrpc2.Client
		clientName string
		method     string
		arg        interface{}
		want       interface{}
	}{
		{clientTCPNoCtx, "clientTCPNoCtx",
			"CtxSvc.Sum", [2]int{3, 5}, 8.0},
		{clientTCP, "clientTCP",
			"CtxSvc.Sum", [2]int{3, 5}, 8.0},
		{clientHTTP, "clientHTTP",
			"CtxSvc.Sum", [2]int{3, 5}, 8.0},
		{clientTCPNoCtx, "clientTCPNoCtx",
			"CtxSvc.Name", NameArg{"First", "Last"}, map[string]interface{}{
				"Name": "First Last",
			}},
		{clientTCP, "clientTCP",
			"CtxSvc.Name", NameArg{"First", "Last"}, map[string]interface{}{
				"Name": "First Last",
			}},
		{clientHTTP, "clientHTTP",
			"CtxSvc.Name", NameArg{"First", "Last"}, map[string]interface{}{
				"Name": "First Last",
			}},
		{clientTCPNoCtx, "clientTCPNoCtx",
			"CtxSvc.NameCtx", NameArg{"First", "Last"}, map[string]interface{}{
				"Name":           "First Last",
				"TCPRemoteAddr":  "",
				"HTTPRemoteAddr": "",
			}},
		{clientTCP, "clientTCP",
			"CtxSvc.NameCtx", NameArg{"First", "Last"}, map[string]interface{}{
				"Name":           "First Last",
				"TCPRemoteAddr":  "127.0.0.1",
				"HTTPRemoteAddr": "",
			}},
		{clientHTTP, "clientHTTP",
			"CtxSvc.NameCtx", NameArg{"First", "Last"}, map[string]interface{}{
				"Name":           "First Last",
				"TCPRemoteAddr":  "",
				"HTTPRemoteAddr": "127.0.0.1",
			}},
	}
	for _, v := range cases {
		var res interface{}
		err := v.client.Call(v.method, v.arg, &res)
		if err != nil {
			t.Errorf("%s.Call(%q) = %v", v.clientName, v.method, err)
		}
		if !reflect.DeepEqual(v.want, res) {
			t.Errorf("%s.Call(%q):\n\n\texp: %#v\n\n\tgot: %#v\n\n", v.clientName, v.method, v.want, res)
		}
	}
}
Beispiel #4
0
func Example() {
	// Server export an object of type ExampleSvc.
	rpc.Register(&ExampleSvc{})

	// Server provide a TCP transport.
	lnTCP, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		panic(err)
	}
	defer lnTCP.Close()
	go func() {
		for {
			conn, err := lnTCP.Accept()
			if err != nil {
				return
			}
			ctx := context.WithValue(context.Background(), RemoteAddrContextKey, conn.RemoteAddr())
			go jsonrpc2.ServeConnContext(ctx, conn)
		}
	}()

	// Server provide a HTTP transport on /rpc endpoint.
	http.Handle("/rpc", jsonrpc2.HTTPHandler(nil))
	lnHTTP, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		panic(err)
	}
	defer lnHTTP.Close()
	go http.Serve(lnHTTP, nil)

	// Client use TCP transport.
	clientTCP, err := jsonrpc2.Dial("tcp", lnTCP.Addr().String())
	if err != nil {
		panic(err)
	}
	defer clientTCP.Close()

	// Client use HTTP transport.
	clientHTTP := jsonrpc2.NewHTTPClient("http://" + lnHTTP.Addr().String() + "/rpc")
	defer clientHTTP.Close()

	// Custom client use HTTP transport.
	clientCustomHTTP := jsonrpc2.NewCustomHTTPClient(
		"http://"+lnHTTP.Addr().String()+"/rpc",
		jsonrpc2.DoerFunc(func(req *http.Request) (*http.Response, error) {
			// Setup custom HTTP client.
			client := &http.Client{}
			// Modify request as needed.
			req.Header.Set("Content-Type", "application/json-rpc")
			return client.Do(req)
		}),
	)
	defer clientCustomHTTP.Close()

	var reply int

	// Synchronous call using positional params and TCP.
	err = clientTCP.Call("ExampleSvc.Sum", [2]int{3, 5}, &reply)
	fmt.Printf("Sum(3,5)=%d\n", reply)

	// Synchronous call using positional params and HTTP.
	err = clientHTTP.Call("ExampleSvc.SumAll", []int{3, 5, -2}, &reply)
	fmt.Printf("SumAll(3,5,-2)=%d\n", reply)

	// Asynchronous call using named params and TCP.
	startCall := clientTCP.Go("ExampleSvc.MapLen",
		map[string]int{"a": 10, "b": 20, "c": 30}, &reply, nil)
	replyCall := <-startCall.Done
	fmt.Printf("MapLen({a:10,b:20,c:30})=%d\n", *replyCall.Reply.(*int))

	// Notification using named params and HTTP.
	clientHTTP.Notify("ExampleSvc.FullName", NameArg{"First", "Last"})

	// Synchronous call using named params and TCP with context.
	clientTCP.Call("ExampleSvc.FullName2", NameArg{"First", "Last"}, nil)

	// Synchronous call using named params and HTTP with context.
	clientHTTP.Call("ExampleSvc.FullName3", NameArg{"First", "Last"}, nil)

	// Correct error handling.
	err = clientTCP.Call("ExampleSvc.Err1", nil, nil)
	if err == rpc.ErrShutdown || err == io.ErrUnexpectedEOF {
		fmt.Printf("Err1(): %q\n", err)
	} else if err != nil {
		rpcerr := jsonrpc2.ServerError(err)
		fmt.Printf("Err1(): code=%d msg=%q data=%v\n", rpcerr.Code, rpcerr.Message, rpcerr.Data)
	}

	err = clientCustomHTTP.Call("ExampleSvc.Err2", nil, nil)
	if err == rpc.ErrShutdown || err == io.ErrUnexpectedEOF {
		fmt.Printf("Err2(): %q\n", err)
	} else if err != nil {
		rpcerr := jsonrpc2.ServerError(err)
		fmt.Printf("Err2(): code=%d msg=%q data=%v\n", rpcerr.Code, rpcerr.Message, rpcerr.Data)
	}

	err = clientHTTP.Call("ExampleSvc.Err3", nil, nil)
	if err == rpc.ErrShutdown || err == io.ErrUnexpectedEOF {
		fmt.Printf("Err3(): %q\n", err)
	} else if err != nil {
		rpcerr := jsonrpc2.ServerError(err)
		fmt.Printf("Err3(): code=%d msg=%q data=%v\n", rpcerr.Code, rpcerr.Message, rpcerr.Data)
	}

	// Output:
	// Sum(3,5)=8
	// SumAll(3,5,-2)=6
	// MapLen({a:10,b:20,c:30})=3
	// FullName2(): Remote IP is 127.0.0.1
	// FullName3(): Remote IP is 127.0.0.1
	// Err1(): code=-32000 msg="some issue" data=<nil>
	// Err2(): code=-32603 msg="bad HTTP Status: 415 Unsupported Media Type" data=<nil>
	// Err3(): code=42 msg="some issue" data=[one two]
}