grpc node 与golang通信
一 、golang 设置
1 安装protobuf
go get github.com/google/protobuf
sudo apt-get install autoconf automake libtool
./autogen.sh
./configure
make
make install
2 安装插件protoc-gen-go
go get -ugithub.com/golang/protobuf/protoc-gen-go
3 grpc-go
go get -u google.golang.org/grpc //--需要
二、 protot文件
2.1 rminfo.proto
syntax = "proto3";
package rminfo;
message RmCmdRequest{
string rm_cmd = 1;
}
message RmCmdReply {
string rm_cmd_repl = 1;
}
service RmRoute {
rpc FetchInfo(RmCmdRequest) returns (RmCmdReply) {}
}
2.2 编译
#!/bin/shprotoc --go_out=plugins=grpc:. rminfo.proto
编译后是：rminfo.pb.go
三、grpcutils代码
package grpcutils
import (
"github.com/wanchain/go-wanchain/log"
"time"
"encoding/json"
"golang.org/x/net/context"
"google.golang.org/grpc"
"rminfo"
//"errors"
"fmt"
//"strings"
)
var (
Address = "localhost:50051"
)
type HeartBeatReply struct {
Timestamp string `json:"timestamp"`
UpdateFlag string `json:"updateflag"`
}
type CmdRequest struct{
Cmd int `json:"cmd"`
Input string `json:"input"`
}
type CmdReply struct{
Cmd string `json:"cmd"`
Output string`json:"output"`
}
type HeartBeatCmdReply struct {
Cmd string `json:"cmd"`
Hbr HeartBeatReply `json:"output"`
}
func FetchRemoteNetInfo(request string) (string, error){
conn, err := grpc.Dial(Address, grpc.WithInsecure())
if err != nil {
log.Error("did not connect: %v", err)
return "",err
}
defer conn.Close()
c:=rminfo.NewRmRouteClient(conn)
ctx, cancle := context.WithTimeout(context.Background(),time.Second)
defer cancle()
r, err := c.FetchInfo(ctx,&rminfo.RmCmdRequest{RmCmd:request})
if err != nil {
log.Error("could not get fetchInfo",err)
}
//log.Printf("reply is ",r.RmCmdRepl)
return r.RmCmdRepl, err
}
func FetchNetInfo(cmd int, input string ) (string,error){
//rcReply:= CmdReply{}
rcRequest:=CmdRequest{}
rcRequest.Cmd=cmd
rcRequest.Input=input
strRequst, err := json.Marshal(rcRequest)
if err != nil {
log.Error("fail to json.Marshal")
return "", err
}
strRepl, err := FetchRemoteNetInfo(string(strRequst))
fmt.Println("strRepl ", strRepl )
if err != nil {
log.Error("fail to FetchRemoteNetInfo")
return "", err
}
fmt.Println("in FetchRmNetInfo ---------------------- 1.1", strRepl)
start := strings.Index(strRepl, "output")
if start == -1 {
return "", errors.New("in Reple, no output ")
}
strHeartBeatRepl := strRepl[start+8:len(strRepl)-1]
return strHeartBeatRepl, nil
}
func JudgeTranByRuleServ(json_str string)(string , error){
strReply , err := FetchNetInfo(2,json_str)
if err != nil {
return "", err
}else{
return strReply, nil
}
}
func LoadContract(bUpdate bool )(string, error){
strReply, err := FetchNetInfo(1,"")
if err != nil {
return "", err
}else {
return strReply, nil
}
}
func RmHeartBeat()(string, error ){
strReply, err := FetchNetInfo(0,"")
if err != nil {
return "", err
}else {
return strReply, nil
}
}
四、 client
package main
import ("fmt"
//"net"
//"log"
//"time"
//"golang.org/x/net/context"
// "google.golang.org/grpc"
"rminfo"
"grpcutils"
)
const (
//address = "localhost:50051"
//defaultName = "world"
)
func main(){
/*conn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c:=rminfo.NewRmRouteClient(conn)
ctx, cancle := context.WithTimeout(context.Background(),time.Second)
defer cancle()
r, err := c.FetchInfo(ctx,&rminfo.RmCmdRequest{RmCmd:defaultName})
if err != nil {
log.Fatalf("could not get fetchInfo",err)
}
log.Printf("reply is ",r.RmCmdRepl)*/
reply, err :=grpcutils.FetchNetInfo(0, "")
if err != nil {
fmt.Println("err != nil ", err)
}else{
//fmt.Println(reply.(*grpcutils.HeartBeatCmdReply).Hbr)
fmt.Println(reply)
}
/*reply1, err :=grpcutils.FetchNetInfo(1, "")
if err != nil {
fmt.Println("err != nil ", err)
}else{
//fmt.Println(reply.(*grpcutils.HeartBeatCmdReply).Hbr)
fmt.Println(reply1)
}
reply2, err :=grpcutils.FetchNetInfo(2, "haolifeng ")
if err != nil {
fmt.Println("err != nil ", err)
}else{
//fmt.Println(reply.(*grpcutils.HeartBeatCmdReply).Hbr)
fmt.Println(reply2)
}
*/
}
五、 golang实现的服务端
package mainimport (
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/reflection"
"fmt"
"net"
"rminfo"
"log"
"grpcutils"
"encoding/json"
)
const (
port = ":50051"
)
type server struct{}
//heartbeat := `{cmd:"0",output:"{timetampe:"12345",updateflag:"0"}"}`
var (
heartbeat = `{"cmd":"0","output":{"timestamp":"12345","updateflag":"0"}}`
rulereply = `{"cmd":"1","output":{"val": "IAIM in rulereply"}}`
contracyreply =`{"cmd":"2","output":{"ke": "I am in Judge contract"}}`
)
func (s *server) FetchInfo(con context.Context, req *rminfo.RmCmdRequest) (*rminfo.RmCmdReply, error){
fmt.Println("accept data")
cmd := req.GetRmCmd()
req11:= grpcutils.CmdRequest{}
json.Unmarshal([]byte(cmd),&req11)
fmt.Println(cmd)
switch req11.Cmd{
case 0:
fmt.Println("in 0")
return &rminfo.RmCmdReply{heartbeat},nil
case 1:
fmt.Println("in 1")
return &rminfo.RmCmdReply{rulereply},nil
case 2:
fmt.Println("in 2")
return &rminfo.RmCmdReply{contracyreply},nil
default:
return &rminfo.RmCmdReply{"hello world i am reply",},nil
}
}
func main() {
lister, err := net.Listen("tcp",port)
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
rminfo.RegisterRmRouteServer(s,&server{})
reflection.Register(s)
if err = s.Serve(lister); err != nil {
log.Fatalf("fail to server: %v", err)
}
}
六、node环境安装
npm install grpc
var PROTO_PATH = __dirname + '/../rminfo/rminfo.proto';
var grpc = require('grpc');
console.log(PROTO_PATH)
//var hello_proto = grpc.load(PROTO_PATH).helloworld;
var rminfo_proto = grpc.load(PROTO_PATH).rminfo;
function FetchInfo(call, callback) {
var reqstr = call.request["rm_cmd"]
console.log(reqstr);
var reqo = JSON.parse(reqstr)
console.log(reqo);
var cmd = reqo["cmd"]
console.log(cmd)
if (cmd == 0 ){
callback(null, {rm_cmd_repl:'{"cmd":"0","output":{"timestamp":"12345","updateflag":"0"}}'});
}
}
/**
* Starts an RPC server that receives requests for the Greeter service at the
* sample server port
*/
function main() {
var server = new grpc.Server();
server.addService(rminfo_proto.RmRoute.service, {FetchInfo: FetchInfo});
server.bind('0.0.0.0:50051', grpc.ServerCredentials.createInsecure());
server.start();
}
main();