C++实现gRPC异步双向流式的客户端和服务端（一）

已于 2024-08-26 11:41:37 修改
阅读量231 收藏 5
点赞数 6
分类专栏： gRPC 文章标签： c++ 开发语言
于 2024-08-26 11:33:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wodet/article/details/141559268
版权

客户端有几点说明
1.回调对象用的对象的函数指针，形如connected_func_=std::bind(&AsyncClientBidiStreamImpl::Connected, this, std::placeholders::_1)，没有用状态机变量控制异步回调，
因为如果用状态变量控制，连续调用两次不同api并需要传入调用对象时没法实现，比如        
obj.statu = DISCONNECT;
stream_->Finish(&status_, &obj);
obj.statu = READ_DONE;
stream_->Read(&status_, &obj);
这种写法就会有问题，变量statu的值会被第二次调用给覆盖为READ_DONE，起不到状态流转的作用了。
2.发送请求时候进行连接调用，因为我这边需求是请求地址不能提前知道，只有在请求时才能知道地址，这块实现当时遇到一些坑需要注意，连接失败重试的时候必须是新的调用对象
3.客户端是有缓存stub对象，起到重用连接的作用

Client.cpp

#include <iostream>
#include "Client.h"
#include "RpcClient.h"
#include "Common.h"
#include "LuaInterface.h"
#include "Log.h"

int32_t AsyncClientBidiStreamImpl::object_count_ = 0;

AsyncClientBidiStreamImpl::AsyncClientBidiStreamImpl(RpcClient* rpc, 
    CompletionQueue* cq, CommonService::Stub* stub,
    std::function<void(grpc::Status, CommonResponse*)> callback)
    :context_(new ClientContext),
    rpc_(rpc),
    callback_(callback),
    stub_(stub),
    cq_(cq),
    response_(),
    connected_func_(std::bind(&AsyncClientBidiStreamImpl::Connected, this, std::placeholders::_1)),
    write_done_func_(std::bind(&AsyncClientBidiStreamImpl::WriteDone, this, std::placeholders::_1)),
    read_done_func_(std::bind(&AsyncClientBidiStreamImpl::ReadDone, this, std::placeholders::_1)),
    disconnect_func_(std::bind(&AsyncClientBidiStreamImpl::Disconnect, this, std::placeholders::_1)),
    call_id_(UniqueIdGenerator::GetInstance().GetUniqueId())
{
    object_count_++;
    //ConfigSetting::InitAsyncContext(context_.get(), rpc->GetChannelMgr()->GetAsyncTimeOut());

    Start();
}

void AsyncClientBidiStreamImpl::Start()
{
    stream_ = stub_->AsyncSendBidiStreamMsg(context_.get(), cq_, &connected_func_);
    is_need_reset_ = false;
}

bool AsyncClientBidiStreamImpl::Connected(bool ok)
{
    if (ok)
    {

        is_connected = true;

        if (!stream_)
        {
            return false;
        }

        stream_->Finish(&status_, &disconnect_func_);
        stream_->Read(&response_, &read_done_func_);
        


        if(!queueReq.empty())
        {
            if (!is_writting_)
            {
                auto req = queueReq.front();

                queueReq.pop_front();

                is_writting_ = true;

                stream_->Write(req, &write_done_func_);

                LOG_DEBUG("[++xeg++]stream write 2 ...");
            }
        }
    }
    else
    {
        queueReq.clear();

        //close
        is_need_reset_ = true;
    }
    return true;
}

bool AsyncClientBidiStreamImpl::ReadDone(bool ok)
{
    if (!ok)
    {
        LOG_DEBUG("BidiStreamImpl|ReadDone() failed!!!Code:%d,Msg:%s",status_.error_code(),status_.error_message().c_str());

        //��ok == false��˵��stream�Ѿ��Ͽ�
        is_connected = false;
        return false;
    }

    int32_t ret = call_lua_func(LuaInterface::getInstance().LuaState(), sLuaCallBackFuncName, GetCallId(),(int32_t)status_.error_code(), response_.cmd(),response_.content(),response_.context());
    stream_->Read(&response_, &read_done_func_);
    return true;
}

int AsyncClientBidiStreamImpl::AsyncSendBidiStreamMsg(CommonRequest& req)
{
    WriteMsg(req);
    return GetCallId();
}

bool AsyncClientBidiStreamImpl::WriteMsg(CommonRequest& req)
{
    queueReq.push_back(req);
    

    if(is_connected)
    {
        if(!is_writting_)
        {
            auto item = queueReq.front();

            queueReq.pop_front();

            is_writting_ = true;
            stream_->Write(item, &write_done_func_);
        }
    }
    else if (is_need_reset_)
    {

        Reset();
        return true;
    }

    return true;

}

bool AsyncClientBidiStreamImpl::WriteDone(bool ok)
{
    if (!ok)
    {
        is_connected = false;
        queueReq.clear();
        return false;
    }

    is_writting_ = false;

    if(!queueReq.empty())
    {
        auto req = queueReq.front();

        queueReq.pop_front();

        is_writting_ = true;
        stream_->Write(req, &write_done_func_);
    }

    return true;
}

bool AsyncClientBidiStreamImpl::Disconnect(bool ok)
{
    is_connected = false;
    is_need_reset_ = true;

    return false;
}

void AsyncClientBidiStreamImpl::Reset()
{

    std::unique_ptr<AsyncClientBidiStreamImpl> clone = std::make_unique<AsyncClientBidiStreamImpl>(rpc_, cq_, stub_, callback_);
    rpc_->ResetBidiStream((uint64_t)stub_,std::move(clone));
}

client.h

#pragma once
#include <condition_variable>
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
#include <queue>
#include <grpcpp/grpcpp.h>

#include "common_service.grpc.pb.h"
#include "IRpcCall.h"
#include "Log.h"

class AsyncClientBidiStreamImpl :public IRpcCall
{
public:
	AsyncClientBidiStreamImpl(RpcClient* rpc,CompletionQueue* cq, CommonService::Stub* stub,
		 std::function<void(grpc::Status, CommonResponse*)> callback);
	~AsyncClientBidiStreamImpl() override 
	{ 
		LOG_DEBUG("AsyncClientBidiStreamImpl release call:%u,object_count:%d",call_id_,--object_count_);

	}
	void Reset() override;
	int GetCallId() { return call_id_;}
	static uint32_t GetObjectCount() { return object_count_; }

	bool Connected(bool ok);
	bool WriteDone(bool ok);
	bool ReadDone(bool ok);
	bool Disconnect(bool ok);

	void Start();
	void TryCancel() { if (context_) { context_->TryCancel(); } }

	int AsyncSendBidiStreamMsg(CommonRequest& req);
private:
	bool WriteMsg(CommonRequest& req);

	std::unique_ptr<ClientContext> context_;
	CommonResponse response_;
	CompletionQueue* cq_;
	CommonService::Stub* stub_;
	grpc::Status status_;
	RpcClient* rpc_;
	NextCallFunc connected_func_;
	NextCallFunc write_done_func_;
	NextCallFunc read_done_func_;
	NextCallFunc disconnect_func_;

	std::function<void(grpc::Status, CommonResponse*)> callback_;
	std::unique_ptr<grpc::ClientAsyncReaderWriter<CommonRequest, CommonResponse>>
		stream_;
	bool coalesce_{false};
	bool is_connected{ false };
	bool is_writting_{ false };
	bool is_need_reset_{ false };
	uint32_t message_per_stream_{100};
	int32_t call_id_;

	std::deque<CommonRequest> queueReq;

	//test
	static int32_t object_count_;
};

RpcClient.h

#pragma once
#include <condition_variable>
#include <iostream>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
#include <map>
#include "Client.h"
#include "ChannelMgr.h"

#include <grpcpp/grpcpp.h>

#include "common_service.grpc.pb.h"

using grpc::Channel;
using grpc::ClientAsyncResponseReader;
using grpc::ClientContext;
using grpc::CompletionQueue;
using grpc::Status;

using CallBackType = std::function<void(bool)>;

class RpcClient
{
public:
	RpcClient(std::function<void(grpc::Status, CommonResponse*)>&& callback);
	virtual ~RpcClient(){}
	void Init();
	void SetCompletionQueue(CompletionQueue* cq);

	void SetChannelArgs(const std::string& name, int32_t value);
	void SetChannelMaxReceiveMessageSize(int size);
	void SetChannelMaxSendMessageSize(int size);
	void SetSyncTimeOut(uint32_t seconds);
	void SetAsyncTimeOut(uint32_t seconds);

	std::pair<int,std::string> SendMsg(const std::string& srv_addr,int32_t type,int32_t cmd,const std::string& body, const std::string& context);

	std::pair<int, std::string> SyncSendMsg(CommonService::Stub* stub,const CommonRequest& req);
	int AsyncSendMsg(CommonService::Stub* stub,const CommonRequest& req);
	int AsyncSendBidiStreamMsg(CommonService::Stub* stub,CommonRequest& req);


	void ResetBidiStream(uint64_t ptr,std::unique_ptr<AsyncClientBidiStreamImpl> newOne);

	ChannelMgr* GetChannelMgr();
protected:
	CompletionQueue* cq_;
	std::function<void(grpc::Status, CommonResponse*)> callback_;
	std::map<uint64_t,std::unique_ptr<AsyncClientBidiStreamImpl> > bidi_stream_impls_;
	std::shared_ptr<ChannelMgr> channel_mgr_{ nullptr };
};

RpcClient.cpp

#include <iostream>
#include "RpcClient.h"
#include "Common.h"


RpcClient::RpcClient(std::function<void(grpc::Status, CommonResponse*)>&& callback)
    :callback_(std::move(callback))
    , channel_mgr_(new ChannelMgr())
{}

void RpcClient::SetCompletionQueue(CompletionQueue* cq)
{
    cq_ = cq;
}

void RpcClient::Init()
{
    SetChannelArgs(GRPC_ARG_KEEPALIVE_TIME_MS, 30 * 1000);
    SetChannelArgs(GRPC_ARG_KEEPALIVE_TIMEOUT_MS, 10 * 1000);
    SetChannelArgs(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS, 1);
    SetChannelArgs(GRPC_ARG_MAX_RECONNECT_BACKOFF_MS, 10 * 1000);

    SetChannelMaxReceiveMessageSize(1024 * 1024 * 64);
    SetChannelMaxSendMessageSize(1024 * 1024 * 64);
}

void RpcClient::SetChannelArgs(const std::string& name, int32_t value)
{
    channel_mgr_->SetChannelArgs(name, value);
}

void RpcClient::SetChannelMaxReceiveMessageSize(int size)
{
    channel_mgr_->SetChannelMaxReceiveMessageSize(size);
}

void RpcClient::SetChannelMaxSendMessageSize(int size)
{
    channel_mgr_->SetChannelMaxSendMessageSize(size);
}

void RpcClient::SetSyncTimeOut(uint32_t seconds)
{
    channel_mgr_->SetSyncTimeOut(seconds);
}

void RpcClient::SetAsyncTimeOut(uint32_t seconds)
{
    channel_mgr_->SetAsyncTimeOut(seconds);
}

void RpcClient::ResetBidiStream(uint64_t ptr,std::unique_ptr<AsyncClientBidiStreamImpl> newOne)
{
    bidi_stream_impls_[ptr] = std::move(newOne);
}

ChannelMgr* RpcClient::GetChannelMgr()
{
    return channel_mgr_.get();
}

std::pair<int, std::string> RpcClient::SendMsg(const std::string& srv_addr,int32_t type,int32_t cmd,const std::string& body, const std::string& context)
{
    std::pair<int, std::string> result;
    std::shared_ptr<CommonService::Stub> pStub = channel_mgr_->FetchOrCreateStub(srv_addr);
    if (pStub == nullptr)
    {
        LOG_ERROR("[++xeg++]create stub fail , addr:%s",srv_addr.c_str());

        return std::pair<int, std::string>();
    }

    if (type == (int)ESYN_UNARY)
    {
        CommonRequest req;
        req.set_cmd(cmd);
        req.set_content(body);
        req.set_context(context);

        result = SyncSendMsg(pStub.get(),req);

    }
    else if (type == (int)EASYN_UNARY)
    {
        CommonRequest req;
        req.set_cmd(cmd);
        req.set_content(body);
        req.set_context(context);
        result = { AsyncSendMsg(pStub.get(),req),"" };
    }
    else if (type == (int)EASYN_BIDI_STREAM)
    {
        CommonRequest req;
        req.set_cmd(cmd);
        req.set_content(body);
        req.set_context(context);

        result = { AsyncSendBidiStreamMsg(pStub.get(),req), ""};
    }
    return result;
}

std::pair<int, std::string> RpcClient::SyncSendMsg(CommonService::Stub* stub,const CommonRequest& req)
{
    auto call = std::make_unique<SyncClientUnaryImpl>(stub, channel_mgr_);
    std::string outStr;
    grpc::Status st;

    CommonResponse response = call->SyncSendMsg(req,st);

    if(st.ok())
    {
        response.SerializeToString(&outStr);
        return { call->GetCallId(), outStr };
    }
    else
    {
        //打印errorcode，错误处理等

        return { -1 , "" };
    }

    
    
}

int RpcClient::AsyncSendMsg(CommonService::Stub* stub,const CommonRequest& req)
{
    AsyncClientUnaryImpl* call = new AsyncClientUnaryImpl(cq_, stub, channel_mgr_);
    call->AsyncSendMsg(req);
    return call->GetCallId();
}



int RpcClient::AsyncSendBidiStreamMsg(CommonService::Stub* stub, CommonRequest& req)
{
    if (stub == nullptr)
    {
        return 0;
    }

    auto it = bidi_stream_impls_.find((uint64_t)stub);
    if (it != bidi_stream_impls_.end()) 
    {
        LOG_DEBUG("reuse stub");
    }
    else 
    {
        
        bidi_stream_impls_[(uint64_t)stub] = std::make_unique<AsyncClientBidiStreamImpl>(this, cq_, stub, callback_);

        LOG_DEBUG("create new stub");

    }

    bidi_stream_impls_[(uint64_t)stub]->AsyncSendBidiStreamMsg(req);
    return bidi_stream_impls_[(uint64_t)stub]->GetCallId();
}

ChannelMgr.cpp的关键接口如下

std::shared_ptr<CommonService::Stub> ChannelMgr::FetchOrCreateStub(const std::string& name)
{
	auto it = stubs_.find(name);
	if (it != stubs_.end()) {
		LOG_DEBUG("Get Old Stub ok!");
		return it->second;
	}
	else 
	{
		LOG_DEBUG("Create New Stub in %s",name.c_str());

		std::shared_ptr<Channel> channel = grpc::CreateCustomChannel(
			ParseEndPointName(name),
			grpc::InsecureChannelCredentials(),
			GetChannelArgs());
		std::shared_ptr<CommonService::Stub> stub = CommonService::NewStub(channel);
		return stubs_.emplace(name, std::move(stub)).first->second;
	}
	return nullptr;
}

IRpcCall.h

#pragma once
#include <algorithm>
#include <forward_list>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>

#include <grpcpp/grpcpp.h>
#include <grpcpp/alarm.h>
#include "common_service.grpc.pb.h"




using grpc::ServerContext;
using grpc::CompletionQueue;
using grpc::ServerCompletionQueue;
using grpc::ServerAsyncResponseWriter;
using grpc::ServerAsyncReader;
using grpc::ServerAsyncWriter;
using grpc::ServerAsyncReaderWriter;
using grpc::Status;
using grpc::Alarm;

using NextCallFunc = std::function<bool(bool)>;

class IRpcCall
{
public:
    IRpcCall() {_callID = 0;}
    virtual ~IRpcCall() {_callID = 0;};
    virtual void Reset() = 0;             // start this back at a clean state
    virtual void Response(CommonResponse& resp,bool reset) {};

protected:
    uint64_t _callID;
};

wodet
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
grpc c++ 异步双向流与`pure virtual method called`
范安崇的博客
09-01 1039
grpc c++ grpc c++ 版本用的人相对少些 实际使用下，确实给 c++ 网络编程带来便利 不少读者对 grpc c++ 缺乏深入了解，以为这是一个同步的库，效率会很低 且官方也没有提供非常易懂的完全高效异步的例子，导致给使用者造成困惑与误解 笔者在编写异步双向流的 grpc 服务器中，从官方例子与 issue 中，终于写出了完美健壮的例子 特记一二 主要问题 编写异步双向流服务器，会遇到以下问题： 官方只提供了一元异步的例子 官方部分例子过于草率，应答处理直接开线程，可能会吓走大批用户 客户端
grpc---双向流式
鲁花花生油
08-01 1413
上一篇我们写了服务端端流式的grpc的调用过程，这篇接上篇写一下双向流式grpc。
c++中grpc简单使用---函数介绍及其代码演示
Nieweishan的博客
07-24 1453
表示一个 gRPC 通道，客户端通过这个通道与服务端进行通信。：创建一个 gRPC 通道。target是服务端地址，例如 “localhost:50051”。是可选的通道参数，例如超时时间、压缩方式等。：表示 gRPC 通道的参数，例如超时时间、压缩方式等。：表示一个 gRPC 客户端上下文，用于存储请求和响应的相关信息。：表示 gRPC 请求的状态，包括请求是否成功、错误代码和错误信息等。：表示 gRPC 存根选项，用于配置 gRPC 存根的行为。
gRPC C++ 异步双向流例子 -支持多线程与连续发送消息
范安崇的博客
05-18 3080
grpc_async_bidirectional_stream_example github 地址：https://github.com/fananchong/grpc_async_bidirectional_stream_example 例子基于线上稳定、高效跑了 1 年以上的 gRPC C++ 库网络框架 最开始作为测试，实验性放到 github 抓虫 使用的是异步双向流 简化编码，在异步双向流基础上，引入 echo 型编码设计模式 类似如下： 实现对应类方法：bool Msg_TestService
grpc双向流式调用——构建一个简单的流数据分析器
程序员Sunny的博客
08-13 6014
本文地址： 传送门： grpc实战——构建一个简单的名称解析服务 grpc实战——服务端流式调用 grpc实战——客户端流式调用 本实例源码 关于grpc，之前已经基于循序渐进的原则和大家聊过简单调用，服务端流式调用和客户端流式调用。那么我们今天聊的grpc应该就是双向流式调用了。相对之前的有所复杂，但是其实有了前面服务端流式调用和客户端流式调用的基础，双向流式调用其实只是两者的结合...
C++ gRPC双向流异步客户端处理
qq_36583051的博客
11-10 1705
参考：C++ GRPC ClientAsyncReaderWriter: how to check if data is available for read? - Stack Overflow cpp-samples/streaming_transcribe_singlethread.cc at main · GoogleCloudPlatform/cpp-samples · GitHub 如何同时从gRPC中读取和写入： https://stackoverflow.com/question
c++grpc实现代码c++grpc实现代码
10-14
c++grpc实现代码
C++实现gRPC异步双向流式的客户端和服务端（二）
最新发布
wodet的专栏
08-27 212
gRPC C++ 异步流式服务器封装实现
基于c++实现grpc服务端
axylp123的专栏
09-02 1925
【代码】基于c++实现grpc服务端。
C++ grpc实现异步回射服务器
len_yue_mo_fu的博客
10-17 1863
在上一篇博客中我使用grpc实现了一个同步的回射服务器，点击查看 废话不多说，直接上代码 echo_async_sample_server.cc #include <iostream> #include <memory> #include <string> #include <thread> #include <mutex> #incl...
c++客户端 grpc_gRPC应用C++
weixin_40006133的博客
12-21 1412
1． gRPC简述RPC，远程方法调用，就是像调用本地方法一样调用远程方法。gRPC是Google实现的一种RPC框架，基于HTTP/2标准设计，带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特。这些特性使得其在移动设备上表现更好，更省电和节省空间占用。目前提供 C、Java 和 Go 语言版本，分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C...
grpc库vs2015编译及示例
08-08
grpc库vs2015编译，grpc示例客户端及服务器，bin文件夹中已包含如何由proto文件生成代码的批处理bat。示例工程debug下需改为"多线程调试 DLL (/MDd)"，release下改为"多线程 DLL (/MD)"。此库为32位版本。
C++实现grpc异步服务器
Coder_MrLee的博客
07-23 2861
一、下载grpc包、protobuf包等 https://github.com/grpc/grpc
gRPC的通信方式服务端流式/客户端流式，双向流式传输方法
GoppViper的博客
10-23 3713
文章目录grpc异步服务器/客户端双向流式传输方法GRPC介绍GRPC的通信方式:简单模式（Simple RPC）服务端数据流模式（Server-side streaming RPC）客户端数据流模式（Client-side streaming RPC）双向数据流模式（Bidirectional streaming RPC）GRPC的双向数据流模式内容提要简要图服务器客户端结尾 grpc异步服务器/客户端双向流式传输方法 GRPC介绍 gRPC (https://grpc.io) 是一个由Google开发
15. 【gRPC系列学习】gRPC四种通信模式：一元RPC、客户端流RPC、服务端流RPC、双向流RPC
菜鸟的博客
12-22 1080
gRPC四种通信模式
深入理解 gRPC 的服务端流式与客户端流式通信模式
gRPC 基于 HTTP2 协议，实现了全双工、流式、异步通信，可在各种环境中高效地进行远程服务调用。 ## 1.2 gRPC 的优势和特点 gRPC 相较于传统的 RESTful API 或者 SOAP 等通信方式具有许多优势和特点： - **高性能...
【C++使用grpc】
hai_qin的博客
05-15 401
某项目需求，需要给客户提供c++的grpc使用demo，且要用MFC开发前端界面。在整个过程中，除了MFC使用了一个未注册的空间导致界面无法启动（无法进入OnInitDialog函数）外，大部分问题集中在grpc的编译。，按照readme的提示一步步进行编译，但是过程中较长，且中途还涉及一些第三方库的编译。由于项目时间需要我放弃了这种方式，转而使用vcpackage工具直接从微软下载编译好的grpc库。如果时间充足，可以自行去官网下载。
gRPC：以 C++为例
you_fathe的博客
12-06 7765
以C++的实例介绍了 grpc 的相关内容
grpc流式传输示例（c++)
qq_42734954的博客
12-16 2892
grpc是结合protobuf的远程调用框架，服务端和客户端均支持同步和异步模式。同步模式下，服务器的service函数会阻塞，且当前线程不能再服务其它的client,类似于多线程模式，一个线程服务一个client,可通过ResourceQuota设置最大线程数；异步模式下，grpc提供类似poll方式管理事件，用户注册事件，并接收通知，一个线程管理一个CompletionQueue，通过轮询管理clients，线程模型可以用户自定义，在追求性能的情况下官方推荐异步模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值