rpc

1. Golang RPC

• server

import (
	"fmt"
	"net"
	"net/http"
	"net/rpc"
)

type Panda int

func (this *Panda) Getinfo(argType int, replyType *int) error {
	fmt.Println("Parameter passed by the remote call:", argType)

	*replyType = 1 + argType

	return nil
}

func main() {
	pd := new(Panda)
	// Register the service. Register exposes all public methods of pd.
	rpc.Register(pd)
	rpc.HandleHTTP()
	ln, err := net.Listen("tcp", "127.0.0.1:10086")
	if err != nil {
		fmt.Println("Listen failed")
	}
	http.Serve(ln, nil)
}

• client

import (
	"fmt"
	"net/rpc"
)

func main() {
	cli, err := rpc.DialHTTP("tcp", "127.0.0.1:10086")
	if err != nil {
		fmt.Println("Network connection failed")
	}

	var val int
	// Remote function call: method, input argument, output argument
	err = cli.Call("Panda.Getinfo", 123, &val)
	if err != nil {
		fmt.Println("call failed")
	}
	fmt.Println("Remote call result:", val)
}

2. gRPC

• hello_server.proto

syntax = "proto3";

option go_package = ".;my_grpc_proto";

service HelloServer {
    rpc SayHello (HelloRequest) returns (HelloResponse) {
    }
}

message HelloRequest {
    string name = 1;
}

message HelloResponse {
    string message = 1;
}

• Generate the Go file

protoc --go_out=./ *.proto

• server

package main

import (
	"fmt"
	"google.golang.org/grpc"
	"my_demo/proto_test/grpc/protobuf"
	"net"

	"context"
)

const (
	post = "127.0.0.1:18881"
)

// The object must correspond to the service defined in the proto file.
type server struct{}

// Implement the RPC SayHello interface.
func (this *server) SayHello(ctx context.Context, in *protobuf.HelloRequest) (*protobuf.HelloResponse, error) {
	return &protobuf.HelloResponse{Message: "hello" + in.Name}, nil
}

func main() {
	// Create the network listener.
	ln, err := net.Listen("tcp", post)
	if err != nil {
		fmt.Println("Network error", err)
	}

	// Create a gRPC server handle.
	srv := grpc.NewServer()
	// Register the server struct with the gRPC service.
	protobuf.RegisterHelloServerServer(srv, &server{})

	// Listen for gRPC requests.
	err = srv.Serve(ln)
	if err != nil {
		fmt.Println("Network startup error", err)
	}
}

• client

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"my_demo/proto_test/grpc/protobuf"
)

const (
	post = "127.0.0.1:18881"
)

func main() {
	// Connect the client to the server.
	conn, err := grpc.Dial(post, grpc.WithInsecure())
	if err != nil {
		fmt.Println("Failed to connect to server", err)
	}

	defer conn.Close()

	// Obtain the gRPC client handle.
	c := protobuf.NewHelloServerClient(conn)

	// Remotely call the SayHello interface.
	r1, err := c.SayHello(context.Background(), &protobuf.HelloRequest{Name: "panda"})
	if err != nil {
		fmt.Println("could not get Hello server ..", err)
		return
	}
	fmt.Println("HelloServer resp: ", r1.Message)
}