Rust网络编程(5)-grpc

grpc应用，本文非当前重点，仅粗略过了一遍

概述

1. gRPC默认使用protocol buffers序列化机制，grpc和protobuf不在此处讲解
2. grpc允许定义4类服务方法：
   1. 单向RPC，即客户端发送一个请求给服务器端，从服务器端获取一个应答，就像一次普通的函数调用
   2. 服务器端流式rpc，即客户端发送一个请求给服务器端，可以获取一个数据流用来读取一系列服务器端发来的消息，客户端从返回的数据流里一直读取到没有更多消息为止
   3. 客户端流式RPC,即客户端用提供的一个数据流写入并发送一系列消息给服务器端，一旦客户端完成消息写入，就等待服务器端读取这些消息并返回应答。
   4. 双向流式RPC，即两边都可以分别通过一个读写数据流来发送一系列消息。这两个数据流操作是相互独立的，所以客户端和服务器端能按其希望的任意顺序读写，例如：服务器端可以在写应答前等待所有的客户端消息，或者它可以先读一个消息再写一个消息，或者是读写相结合的其它方式。每个数据流里消息的顺序会被保持。

1. 依赖

[dependencies]
protobuf = "2"
grpc = "0.7.1"
grpc-protobuf = "0.7.1"
futures = "0.3.*"
tls-api = "0.3.*"

[build-dependencies]
protoc-rust-grpc = "0.7.1"

2. foobar.proto

syntax = "proto3";

package foobar;

service FooBarService {
   rpc record_cab_location(CabLocationRequest) returns (CabLocationResponse);
   rpc get_cabs(GetCabRequest) returns (GetCabResponse);
}

message CabLocationRequest {
   string name = 1;
   Location location = 2;
}

message CabLocationResponse {
   bool accepted = 1;
}

message GetCabRequest {
   Location location = 1;
}

message GetCabResponse {
   repeated Cab cabs = 1;
}

message Cab {
   string name = 1;
   Location location = 2;
}

message Location {
   float latitude = 1;
   float longitude = 2;
}

3. build.rs

将proto文件生成对应的rs文件

extern crate protoc_rust_grpc;

fn main() {
   protoc_rust_grpc::Codegen::new()
           .out_dir("src")
           .input("foobar.proto")
           .rust_protobuf(true)
           .run()
           .expect("protoc-rust-grpc");
}

4. lib.rs

// extern crate protobuf;
// extern crate grpc;
// extern crate tls_api;
// extern crate grpc_protobuf;
pub mod foobar;
pub mod foobar_grpc;

5. bin/server

use std::thread;
use use_grpc::foobar_grpc::*;
use use_grpc::foobar::*;

struct FooBarServer;

impl FooBarService for FooBarServer {
    fn record_cab_location(&self,
                           _o: grpc::ServerHandlerContext,
                           req: grpc::ServerRequestSingle<CabLocationRequest>,
                           resp: grpc::ServerResponseUnarySink<CabLocationResponse>)
                           -> grpc::Result<()>
    {
        let mut r = CabLocationResponse::new();
        println!("Record cab {} at {}, {}",
                 req.message.get_name(),
                 req.message.get_location().latitude,
                 req.message.get_location().longitude);

        r.set_accepted(true);
        resp.finish(r)
    }

    fn get_cabs(&self,
                _o: grpc::ServerHandlerContext,
                _req: grpc::ServerRequestSingle<GetCabRequest>,
                resp: grpc::ServerResponseUnarySink<GetCabResponse>)
                -> grpc::Result<()>
    {
        let mut r = GetCabResponse::new();

        let mut location = Location::new();
        location.latitude = 40.7128;
        location.longitude = -74.0060;

        let mut one = Cab::new();
        one.set_name("Limo".to_owned());
        one.set_location(location.clone());

        let mut two = Cab::new();
        two.set_name("Merc".to_owned());
        two.set_location(location.clone());

        let vec = vec![one, two];
        let cabs = ::protobuf::RepeatedField::from_vec(vec);

        r.set_cabs(cabs);

        resp.finish(r)
    }
}

fn main() {
    let mut server = grpc::ServerBuilder::new_plain();
    server.http.set_port(9001);
    server.add_service(FooBarServiceServer::new_service_def(FooBarServer));
    let _server = server.build().expect("Could not start server");
    loop {
        thread::park();
    }
}

6. bin/client

use use_grpc::foobar::*;        //use_grpc为当前包的名字，如果名字不一样需要修改
use use_grpc::foobar_grpc::*;   //use_grpc为当前包的名字，如果名字不一样需要修改
use futures::executor;

use grpc::ClientStubExt;


fn main() {
    let client =
        FooBarServiceClient::new_plain("127.0.0.1",
                                       9001,
                                       Default::default())
            .unwrap();

    let mut req = CabLocationRequest::new();
    req.set_name("foo".to_string());

    let mut location = Location::new();
    location.latitude = 40.730610;
    location.longitude = -73.935242;
    req.set_location(location);

    let resp = client
        .record_cab_location(grpc::RequestOptions::new(), req)
        .join_metadata_result(); //future
    let resp = executor::block_on(resp);
    match resp {
        Err(e) => panic!("{:?}", e),
        Ok((_, r, _)) => println!("{:?}", r),
    }

    let mut nearby_req = GetCabRequest::new();
    let mut location = Location::new();
    location.latitude = 40.730610;
    location.longitude = -73.935242;
    nearby_req.set_location(location);

    let nearby_resp = client
        .get_cabs(grpc::RequestOptions::new(), nearby_req)
        .join_metadata_result(); //返回future
    let nearby_resp = executor::block_on(nearby_resp);
    match nearby_resp {
        Err(e) => panic!("{:?}", e),
        Ok((_, cabs, _)) => println!("{:?}", cabs),
    }
}

总结

本文编辑完毕