QuickStart

    It only install the basic features of rpcx. If you want to use etcd, you should add tag:

    1. go get -u -v -tags "etcd" github.com/smallnest/rpcx/...

    And if you want to use quic, you also need to add quic tag:

    1. go get -u -v -tags "quic etcd" github.com/smallnest/rpcx/...

    I recommend you to install all tags even though you won't use them so far:

    tags means:

    • quic: support quic transport
    • kcp: support kcp transport
    • zookeeper: support zookeeper register
    • etcd: support etcd register
    • consul: support consul register
    • ping: support network quality load balancing
    • reuseport: support reuseport

    You can write your service just like writing a plain Go struct:

    1. import "context"
    3. type Args struct {
    4.     A int
    5.     B int
    6. }
    8. type Reply struct {
    9.     C int
    10. }
    13. func (t *Arith) Mul(ctx context.Context, args *Args, reply *Reply) error {
    14.     reply.C = args.A * args.B
    15.     return nil
    16. }

    Now you has defined one service Arith and implemented its Mul method. we will introduce how to explore it to server and how clients to call it in next steps.

    You can use three lines to explore the above service:

    1.     s := server.NewServer()
    2.     s.RegisterName("Arith", new(Arith), "")
    3.     s.Serve("tcp", ":8972")

    You register your service with Name Arith。

    You can register service by the below:

    It uses the service type name as service name.

    1.     // #1
    2.     d := client.NewPeer2PeerDiscovery("tcp@"+*addr, "")
    3.     // #2
    4.     xclient := client.NewXClient("Arith", client.Failtry, client.RandomSelect, d, client.DefaultOption)
    5.     defer xclient.Close()
    7.     // #3
    8.     args := &example.Args{
    9.         A: 10,
    10.         B: 20,
    11.     }
    13.     // #4
    14.     reply := &example.Reply{}
    16.     // #5
    17.     err := xclient.Call(context.Background(), "Mul", args, reply)
    18.         log.Fatalf("failed to call: %v", err)
    19.     }

    #2 creates a XClient, and passes FailMode, SelectMode and default option.FailMode indicates the client how to handle call failures: retry, return fast or retry another server?SelectMode indicates the client how to select a server if there are multiple servers for one service.

    #3 defines the request： we want to get result of 10 * 20. Of course we know the result must be 200 but we will see whether reply from the server is 200.

    #4 defines the result object, it is a zero value and actually rpcx can use it to know type of the result and then unmarshal the result to it.

    #5 call the remote service and gets the result synchronously。

    You can call the service synchronously:

    1.     d := client.NewPeer2PeerDiscovery("tcp@"+*addr2, "")
    2.     xclient := client.NewXClient("Arith", client.Failtry, client.RandomSelect, d, client.DefaultOption)
    3.     defer xclient.Close()
    5.     args := &example.Args{
    6.         A: 10,
    7.         B: 20,
    8.     }
    10.     reply := &example.Reply{}
    11.     call, err := xclient.Go(context.Background(), "Mul", args, reply, nil)
    12.     if err != nil {
    13.         log.Fatalf("failed to call: %v", err)
    14.     }
    16.     replyCall := <-call.Done
    17.     if replyCall.Error != nil {
    18.         log.Fatalf("failed to call: %v", replyCall.Error)
    19.     } else {
    20.         log.Printf("%d * %d = %d", args.A, args.B, reply.C)
    21.     }

    By smallnest updated 2018-12-04 11:47:26