参考资料：
http://blog.csdn.net/zhangxy221/article/details/6595376
https://wenku.baidu.com/view/1b7ce142a8956bec0975e383.html
主要是学习epoll之后，想测试下epoll性能。已经实际项目中应该有的接口等问题。所以做了一个棋牌的demo.
根据参考资料。和个人精力。省去网关，集成到中心服务器中。记录下学习细节。
第一版非分布式完成，第二版分布式开发，太耗费时间在测试和服务客户端2端的不同细节上，中断，所以记录下，以便有空继续完成。
1）大致模型。服务端c++,客户端c#
短链接登录，-》分配sessionkey ,->得到key,进行长连接到网关（中心服），-》服务推送房间信息。-》用户占座，-》检测是否可以开始游戏-》对所有可以开始的游戏。进行分配gamekey
->通知游戏服初始化游戏数据-》游戏服发送数据给中心服，-》转发给客户-》客户出牌（或者发送聊天信息）-》中心服根据消息类型转发给游戏服，或者广播消息。-》游戏服根据出牌信息，或者超时后，由自动出牌方法，出牌。
以此触发，推送最新玩家卡牌信息（通过到网关（中心服）给客户）。-》游戏结束通知中心服，更新玩家信息。和牌局结果。
2）服务端的网络模块 epoll
非阻塞，lt模式，由模块外保存缓存数据。 发送缓存满而失败的话，另外保存了发送失败缓存，监听模式由in转为out. 简单采用keeplive 来做心跳检测。
3）数据的接受和发送。
accept 之后，记录socket的key.发送检查KEY,以免数据发串。消息对于socket是顺序处理和发送。
数据的序列化开始并没有，直接自己定义消息格式，后面采用protobuff.
4)线程模式，采用 一循环事件一线程，实现接口。而消息的处理指定线程数量，处理消息队列，简单的条件等待读模式。
5）客户端的读写模式。
为了熟悉异步，没有使用现成的异步调用，而是用新线程回调委托的方式，实现异步委托
总结和改进：
epoll的性能应该是没有问题。主要改进在缓存的处理上，可以采用环形缓冲区，
由于已经是非阻塞多路复用，所以感觉不是很高的并发，整个服务端，几个线程应该是可以的。
epoll一个线程。日志一个线程，主线程。固定个位数的线程，分批处理消息（每个线程按socket的接受缓存整条处理，以便消息的顺序，应该也可以对每条消息编号，）
map 的使用还是要适当使用，log2 的性能比 vector 毕竟对于大数据是很高的提升。
epollserver.h
#ifndef LSU_EPOLLSERVER_H_INCLUDED #define LSU_EPOLLSERVER_H_INCLUDED #include <string> #include <map> #include <functional> #include <queue> #include <chrono> #include "lsu_iloopevent.h" #include "lsu_epoll_buff.h" extern "C" { namespace LSU_NET { enum enum_sock_recv { enum_sock_recv_ok=0, enum_sock_recv_close=-1, enum_sock_recv_error=-2, }; enum enum_sock_Send { enum_sock_Send_ok=0, enum_sock_Send_block=-1, enum_sock_Send_error=-2, }; class ScoketInfo { public: ScoketInfo()=default; ScoketInfo(int _fd); int fd; enum_sock_recv recvstatus; enum_sock_Send sendstatus; int createtime; int lastUpdate; }; class EpollServer:public LSU_LOOPEVENT::IEventLoop { public: EpollServer(const std::string& _ip,int _port,int waitTimeout, const std::function<void(const std::string&)>& _OnNotice, const std::function<void(const std::vector<FDMsg>&)>& _onrecv, const std::function<std::vector<FDMsg>()>& _onsend, const std::function<void(const std::vector<FDMsg>&)>& _OnFailSend, const std::function<std::vector<FDMsg>(int fd)>& _OnCanSend ); void Start(); bool IsStart(); void Close(); bool IsClosed(); private: int CreateListenFD(); int AddEpollEvent(int _eventSourceFD,uint32_t _events); int DelEpollEvent(int _eventSourceFD); int MODEpollEvent(int _eventSourceFD,uint32_t _events); void TimeOutScoket(); void DeleteLink(int fd); std::string serverIP; int serverPort; int waitTimeout; std::function<void(const std::string&)> OnNotice; std::function<void(const std::vector<FDMsg>&)> OnReceive; std::function<std::vector<FDMsg>()>OnSend; std::function<void(const std::vector<FDMsg>&)> OnFailSend; std::function<std::vector<FDMsg>(int fd)>OnCanSend; const int listenQueneCount=256; const static int MAX_EVENTS=64; const int recvBuffSize=1024*20; const int closeTimeout=20; const int kl_start=60; const int kl_times=6; const int kl_seconds=10; int listenFD; int epollManageFD; int localSockP[2]; epoll_event ev_allEvents[MAX_EVENTS]; std::map<int,ScoketInfo> allClientFD; bool shouldloop=true; bool stop=false; int loopTimePoint; const int to_close_ok=10;//接受到fin信号的超时 const int to_close_block=60;//接受到fin信号的超时 const int to_ok_ok=60*60;//客户端无任何动作的超市 const int to_ok_block=30*60; }; int Create_Bind_TCPv4_Socket(const std::string& _ip,int _port); int set_tcp_keepAlive(int fd,int start,int interval,int count); } } #endif // LSU_EPOLLSERVER_H_INCLUDED
epollserver.cpp
#include <stdio.h>//perror #include <fcntl.h> #include <unistd.h>//close. #include <time.h> #include <arpa/inet.h>//INET_PTON #include <chrono> #include <algorithm> #include <poll.h> #include <sys/epoll.h> #include <sys/errno.h> #include <ctime> #include <sys/socket.h>//{socket_type.h}:socket,AF_INET,SOCK_STREAM,PF_INET #include <netdb.h>//{<netinet/in.h>}:IPPROTO_TCP #include <sys/errno.h> #include <netinet/tcp.h> #include <memory.h> #include <set> #include <exception> #include "lsu_epollserver.h" #include "lsu_time.h" #include "lsu_helper.h" using namespace std; using namespace LSU_HELPER; using namespace LSU_TIME; //多县城下面,必须开超时论寻.避免只有一个用户的尴尬. //用户发玩.消息放入 发送去.但是epoll,已经 素在在wait了. //因为是服务段,被动关闭.客户段,必须一部接受.才 不会 阻塞在 接受上.或者客户段,协议好,收到期望消息,就再次关闭,不必要在论需. //否则最好单独做个段链接模式,以便及时响应fin. namespace LSU_NET { ScoketInfo::ScoketInfo(int _fd) { fd=_fd; recvstatus=enum_sock_recv_ok; sendstatus=enum_sock_Send_ok; createtime=LSU_TIME::Getlocaltimeint(); lastUpdate=LSU_TIME::Getlocaltimeint(); } //ShowMsg,OnReceive,OnSend,OnFailSend,OnCanSend); EpollServer::EpollServer(const std::string& _ip,int _port,int _waitTimeout, const std::function<void(const std::string&)>& _OnNotice, const std::function<void(const std::vector<FDMsg>&)>& _onrecv, const std::function<std::vector<FDMsg>()>& _onsend, const std::function<void(const std::vector<FDMsg>&)>& _OnFailSend, const std::function<std::vector<FDMsg>(int fd)>& _OnCanSend ): serverIP(_ip),serverPort(_port),waitTimeout(_waitTimeout),OnNotice(_OnNotice),OnReceive(_onrecv),OnSend(_onsend), OnFailSend(_OnFailSend),OnCanSend(_OnCanSend) { localSockP[0]=-1; localSockP[1]=-1; bzero(ev_allEvents,sizeof(epoll_event)*MAX_EVENTS); loopTimePoint=Getlocaltimeint(); } int EpollServer::CreateListenFD() { return Create_Bind_TCPv4_Socket(serverIP,serverPort); } int EpollServer::AddEpollEvent(int _eventSourceFD,uint32_t _events) { epoll_event ev_reginfo; bzero(&ev_reginfo,sizeof(ev_reginfo)); ev_reginfo.events=_events; ev_reginfo.data.fd=_eventSourceFD; return epoll_ctl(epollManageFD,EPOLL_CTL_ADD,_eventSourceFD,&ev_reginfo); } int EpollServer::DelEpollEvent(int _eventSourceFD) { epoll_event ev_reginfo;//bugs:根据手册,早系统会有bug,所以还是传一个指针而不是0. bzero(&ev_reginfo,sizeof(ev_reginfo)); ev_reginfo.data.fd=_eventSourceFD; return epoll_ctl(epollManageFD,EPOLL_CTL_DEL,_eventSourceFD,&ev_reginfo); } int EpollServer::MODEpollEvent(int _eventSourceFD,uint32_t _events) { epoll_event ev_reginfo; bzero(&ev_reginfo,sizeof(ev_reginfo)); ev_reginfo.events=_events; ev_reginfo.data.fd=_eventSourceFD; return epoll_ctl(epollManageFD,EPOLL_CTL_MOD,_eventSourceFD,&ev_reginfo); } void EpollServer::Start() { //try{ //Create Listen SOCKET int flag=0; listenFD=CreateListenFD(); if(listenFD==-1) { OnNotice(string(strerror(errno))); return; } //listen socket flag=listen(listenFD,listenQueneCount); if(flag==-1) { OnNotice(string(strerror(errno))); return; } //create epoll server epollManageFD=epoll_create1(0); if(epollManageFD==-1) { close(listenFD);//并未多线程读取直接 close. OnNotice(string(strerror(errno))); return; } //create loacl socket flag= socketpair(AF_UNIX,SOCK_STREAM,0,localSockP); if(-1==flag) { close(listenFD);//并未多线程读取直接 close. close(epollManageFD);//并未多线程读取直接 close. OnNotice(string(strerror(errno))); return; } //注册监听描述符' flag= AddEpollEvent(listenFD,EPOLLIN); if(-1==flag) { close(listenFD);//并未多线程读取直接 close. close(epollManageFD);//并未多线程读取直接 close. OnNotice(string(strerror(errno))); return; } //注册本进程socket pair,0外部输入.1,由epoll监听. flag= AddEpollEvent(localSockP[1],EPOLLIN); if(-1==flag) { close(listenFD);//并未多线程读取直接 close. close(epollManageFD);//并未多线程读取直接 close. close(localSockP[0]); close(localSockP[1]); OnNotice(string(strerror(errno))); return; } OnNotice("Epoll start working!"); int nfds=0; vector<FDMsg> recvData;//接受到的信息，批量发送。 while(shouldloop) { //开始监听,1)监听描述符,2)本地socket 3)监听描述符所连接的新描述符 nfds= epoll_wait(epollManageFD,ev_allEvents,MAX_EVENTS,waitTimeout); if(nfds==-1) { //需要重连接? OnNotice(ErrorDesc(errno,"wait -1")); } else { for(int i=0; i<nfds; ++i) { //处理请求链接. if(ev_allEvents[i].data.fd==listenFD&&ev_allEvents[i].events==EPOLLIN) { //需要非阻塞处理,提高效率? int clientFD=accept(listenFD,0,0); if(-1==clientFD) { OnNotice(ErrorDesc(errno,"accept error")); } else { //非阻塞,存活检测. OnNotice(NormalDesc("accept ok.")+CastStr(clientFD)); int val=fcntl(clientFD,F_GETFL,0); fcntl(clientFD,F_SETFL,val|O_NONBLOCK); set_tcp_keepAlive(clientFD,kl_start,kl_times,kl_seconds); flag=AddEpollEvent(clientFD,EPOLLIN); if(-1==flag) { close(clientFD); OnNotice(ErrorDesc(errno,"addevent")); } else { //如果存在必须先删除。可以不处理。已有数据，因为是多县城。处理不会彻底的。 //因为已经存在createtime这个全局的key.和每条信息以及fd关联 //消息的组合会匹配createtime.发送也会检测createtime. //同一个fd编号。不可能会在一秒内重复建立。 if(allClientFD.find(clientFD)!=allClientFD.end()) { OnNotice(NormalDesc(CastStr(clientFD)+": exist,before reconnect .but not delete?")); allClientFD.erase(clientFD); } ScoketInfo si(clientFD); allClientFD.insert(map<int,ScoketInfo>::value_type(clientFD,si)); OnNotice(NormalDesc("success conn")); } } } //处理进程内信号。 else if(ev_allEvents[i].data.fd==localSockP[1]&&ev_allEvents[i].events==EPOLLIN) { shouldloop=false; } //处理阻塞转发送事件 else if(ev_allEvents[i].events==EPOLLOUT) { int sendfd=ev_allEvents[i].data.fd; vector<FDMsg> sendQueue= OnCanSend(sendfd); if(allClientFD.find(sendfd)!=allClientFD.end()) { for(int i=0;i<sendQueue.size();++i) { if(allClientFD[sendfd].createtime!=sendQueue[i].fdcreatetime) { continue; } else { flag=send(sendfd,sendQueue[i].data.c_str(),sendQueue[i].data.size(),0);//会发\0? if(-1==flag) { //要不客户不通。短线。。断掉。 //要不素赛。素赛的可能是。用户不接受。但这个发送非常频繁。在转向关注发送期间的数据，居然填满缓存。 DeleteLink(sendfd); OnNotice(NormalDesc("resend fail just colse it"+CastStr(sendfd))); break; } } } //if all ok. OnNotice(NormalDesc("resend ok")); allClientFD[sendfd].sendstatus=enum_sock_Send_ok; allClientFD[sendfd].lastUpdate=Getlocaltimeint(); if(allClientFD[sendfd].recvstatus!=enum_sock_recv_close) { OnNotice(NormalDesc("resend ok and start to recv."+CastStr(sendfd))); MODEpollEvent(sendfd,EPOLLIN); } } else { DeleteLink(sendfd); OnNotice(NormalDesc("set delete.but event exist?"+CastStr(sendfd))); } } //处理接受的数据. else { int myEventFD=ev_allEvents[i].data.fd; if(allClientFD.find(myEventFD)==allClientFD.end()) { ScoketInfo si(myEventFD); allClientFD.insert(map<int,ScoketInfo>::value_type(myEventFD,si)); OnNotice(NormalDesc("noway,a unconnected client?")); } else { allClientFD[myEventFD].lastUpdate=Getlocaltimeint(); } char recvChar[recvBuffSize]; string recvMsg; for(;;) { bzero(recvChar,recvBuffSize); int reclen= recv(myEventFD,recvChar,recvBuffSize,0); if(reclen>0) { recvMsg+=string(recvChar,reclen); } //用户至少半关闭链接 else if(reclen==0) { allClientFD[myEventFD].recvstatus=enum_sock_recv_close; break; } else if(reclen==-1) { //数据收完 if(errno==EAGAIN || errno==EWOULDBLOCK) { allClientFD[myEventFD].recvstatus=enum_sock_recv_ok; break; } else if(errno==EINTR) { continue; } //客户断网,或者崩溃(keep alive 会自动请求进行到这里。) else { recvMsg=""; allClientFD[myEventFD].recvstatus=enum_sock_recv_error; break; } } } if(allClientFD[myEventFD].recvstatus==enum_sock_recv_ok) { if(recvMsg!="") { FDMsg tempdb; tempdb.data=recvMsg; tempdb.fd=myEventFD; tempdb.fdcreatetime=allClientFD[myEventFD].createtime; recvData.push_back(tempdb); } allClientFD[myEventFD].lastUpdate=Getlocaltimeint(); OnNotice(NormalDesc(CastStr(myEventFD)+": recv ok.data:"+recvMsg)); } else if(allClientFD[myEventFD].recvstatus==enum_sock_recv_close) { if(recvMsg!="") { FDMsg tempdb; tempdb.data=recvMsg; tempdb.fd=myEventFD; tempdb.fdcreatetime=allClientFD[myEventFD].createtime; recvData.push_back(tempdb); } DelEpollEvent(myEventFD); allClientFD[myEventFD].lastUpdate=Getlocaltimeint(); OnNotice(NormalDesc(CastStr(myEventFD)+": recv ok.cliete want to close.data:"+recvMsg)); } else if(allClientFD[myEventFD].recvstatus==enum_sock_recv_error) { DeleteLink(myEventFD); OnNotice(ErrorDesc(errno,CastStr(myEventFD)+": recv.")); } } } } if(recvData.size()>0) { OnReceive(recvData); OnNotice(NormalDesc("push recv to buff.count of recv size:"+CastStr(recvData.size()))); recvData.clear(); } //处理发送. vector<FDMsg> SendQueue=OnSend(); if(SendQueue.size()>0) { OnNotice(NormalDesc("start send.size:"+CastStr(SendQueue.size()))); vector<FDMsg> failSend; for(size_t i=0; i<SendQueue.size(); ++i) { int sendfd=SendQueue[i].fd; int sendfdcreatet=SendQueue[i].fdcreatetime; if(allClientFD.find(sendfd)!=allClientFD.end()) { //时间戳不对。 if(sendfdcreatet!=allClientFD[sendfd].createtime) { OnNotice(NormalDesc(CastStr(sendfd)+": error createtime.do't send.")); continue; } //如果之前此链接有错误。直接跳过。 if(allClientFD[sendfd].sendstatus==enum_sock_Send_error) { OnNotice(NormalDesc(CastStr(sendfd)+": before has error.skip and discard.")); continue; } //如果是阻塞链接。放入阻塞队伍。进行下过。以免浪费时间，或者中途又可以，导致逻辑更复杂。干脆直接关注发送事件。 else if(allClientFD[sendfd].sendstatus==enum_sock_Send_block) { failSend.push_back(SendQueue[i]); OnNotice(NormalDesc(CastStr(sendfd)+": before has blocked.skip and put failqueue.")); continue; } flag=send(sendfd,SendQueue[i].data.c_str(),SendQueue[i].data.size(),0);//会发\0? if(-1==flag) { if(errno==EINTR || errno==EAGAIN || errno==EWOULDBLOCK) { allClientFD[sendfd].sendstatus=enum_sock_Send_block; allClientFD[sendfd].lastUpdate=Getlocaltimeint(); MODEpollEvent(SendQueue[i].fd,EPOLLOUT);//关注接收,转为关注发送,不再进行接收了.发都发不出去.不接收. failSend.push_back(SendQueue[i]); OnNotice(NormalDesc(CastStr(sendfd)+": send block.skip and put failqueue.")); } else { //allClientFD[sendfd].sendstatus=enum_sock_Send_error; //allClientFD[sendfd].lastUpdate=Getlocaltimeint(); DeleteLink(sendfd); OnNotice(ErrorDesc(errno,CastStr(sendfd)+": send error.close55 it")); } } else { allClientFD[sendfd].sendstatus=enum_sock_Send_ok; allClientFD[sendfd].lastUpdate=Getlocaltimeint(); OnNotice(NormalDesc(CastStr(sendfd)+": send ok.data:"+string(SendQueue[i].data.c_str(),SendQueue[i].data.size()))); } } else { OnNotice(NormalDesc(CastStr(sendfd)+": not in set.do't send.")); } //如果开启段链接模式.那么直接 } if(failSend.size()>0) { OnFailSend(failSend); } } //超时链接处理。 int looptimenow=Getlocaltimeint(); if(looptimenow-loopTimePoint>15) { TimeOutScoket(); loopTimePoint=looptimenow; } } stop=true; OnNotice("Server closed!"); //通知阻塞在读取接收缓存上的线程,重新检测状态 OnReceive(vector<FDMsg>()); close(epollManageFD); } bool EpollServer::IsStart() { return shouldloop; } void EpollServer::Close() { send(localSockP[0],"close",5,0); } bool EpollServer::IsClosed() { return stop; } void EpollServer::DeleteLink(int fd) { DelEpollEvent(fd); shutdown(fd,SHUT_RDWR);//回应客户端,关闭tcp链接. close(fd);//本地清除文件描述符和socket 的资源. allClientFD.erase(fd); OnNotice(NormalDesc("deletelink it"+CastStr(fd))); } //这里明显效率可以改善 ，可以加几个链表。分别表示不同的超市类型链接。并按时间排序。检测到表的某个地方就可以。 //而不是循环每个链接。但是要做数据间的同步。就简单点吧. void EpollServer::TimeOutScoket() { OnNotice("start loop"); int timenow=Getlocaltimeint(); auto it=allClientFD.begin(); vector<int> delfd; for(it;it!=allClientFD.end();++it) { ScoketInfo sockinfo=it->second; int socketfd=sockinfo.fd; if(sockinfo.recvstatus==enum_sock_recv_close&&sockinfo.sendstatus==enum_sock_Send_ok&&timenow-sockinfo.lastUpdate>to_close_ok) { OnNotice("close ok"+CastStr(socketfd)); delfd.push_back(socketfd); } else if(sockinfo.recvstatus==enum_sock_recv_close&&sockinfo.sendstatus==enum_sock_Send_block&&timenow-sockinfo.lastUpdate>to_close_block) { OnNotice("close block"+CastStr(socketfd)); delfd.push_back(socketfd); } else if(sockinfo.recvstatus==enum_sock_recv_ok&&sockinfo.sendstatus==enum_sock_Send_ok&&timenow-sockinfo.lastUpdate>to_ok_ok) { OnNotice("ok ok"+CastStr(timenow)+CastStr(sockinfo.lastUpdate)); delfd.push_back(socketfd); } else if(sockinfo.recvstatus==enum_sock_recv_ok&&sockinfo.sendstatus==enum_sock_Send_block&&timenow-sockinfo.lastUpdate>to_ok_block) { OnNotice("ok block"); delfd.push_back(socketfd); } } for(int i=0;i<delfd.size();++i) { DeleteLink(delfd[i]); } } //global fun. fail: return -1; int Create_Bind_TCPv4_Socket(const std::string& _ip,int _port) { int socketFD=-1; socketFD=socket(PF_INET,SOCK_STREAM,IPPROTO_IP); if(socketFD<0) { return -1; } sockaddr_in mySockAddr; bzero(&mySockAddr,sizeof(mySockAddr)); inet_pton(AF_INET,_ip.c_str(),&mySockAddr.sin_addr); mySockAddr.sin_family=AF_INET; mySockAddr.sin_port=htons(_port); int flag=bind(socketFD,(sockaddr*)&mySockAddr,sizeof(mySockAddr)); if(flag==-1) { return -1; } return socketFD; } int set_tcp_keepAlive(int fd,int start,int interval,int count) { int keepAlive = 1; if (fd < 0 || start < 0 || interval < 0 || count < 0) return -1; if(setsockopt(fd,SOL_SOCKET,SO_KEEPALIVE,(void*)&keepAlive,sizeof(keepAlive)) == -1) { return -1; } if(setsockopt(fd,SOL_TCP,TCP_KEEPIDLE,(void *)&start,sizeof(start)) == -1) { return -1; } if(setsockopt(fd,SOL_TCP,TCP_KEEPINTVL,(void *)&interval,sizeof(interval)) == -1) { return -1; } if(setsockopt(fd,SOL_TCP,TCP_KEEPCNT,(void *)&count,sizeof(count)) == -1) { return -1; } return 0; } } //4)send_ok. s_ok ,1)close:yes,block:yes=>s_ok 2)close:yes,block:no => s_ok 3) colse:no,block:yes=>s_ok. e_in. 4)close:no,block:no=>s_ok
proto 消息格式。
package GAMEMSG; enum MsgType { enum_Login_Request = 10001; enum_Login_Response = 10002; enum_Logout_Request = 10003; enum_Reflesh_Rooms_Request=10004; enum_Reflesh_Rooms_Response=10005; enum_Stool_Info_Push=10006; enum_SitDown_Request=10007; enum_Game_Info_Push=10008; enum_SendCards_Request=10009; enum_Chat_Request=10010; enum_Chat_Push=10011; enum_GameOver_Push=10012; } message Message { required MsgType Msg_Type = 1; required MsgContent Msg_Content=2; } message MsgContent { optional LoginRequest Login_Request = 1; optional LoginResponse Login_Response = 2; optional LogoutRequest Logout_Request=3; optional RefleshRoomsRequest Reflesh_Rooms_Request = 4; optional RefleshRoomsResponse Reflesh_Rooms_Response = 5; optional StoolInfoPush Stool_Info_Push=6; optional SitDownRequest SitDown_Request=7; optional GameInfoPush Game_Info_Push=8; optional SendCardsRequest SendCards_Request=9; optional ChatRequest Chat_Request=10; optional ChatPush Chat_Push=11; optional GameOverPush GameOver_Push=12; } message LoginRequest { required bytes User_Name = 1; required bytes PassWord = 2; } message LoginResponse { required bytes User_Name = 1; required bytes User_Key = 2; required int32 Check_Ret=3; } message LogoutRequest { required bytes User_name=1; required bytes User_key=2; } message RefleshRoomsRequest { required bytes Check_key=1; } message RefleshRoomsResponse { repeated RoomInfo Room_Info=1; } message StoolInfoPush { required int32 Room_id=1; repeated bytes Player_name=2; } message SitDownRequest { required bytes User_name=1; required bytes User_key=2; required int32 Room_id=3; required int32 Desk_id=4; required int32 Stool_id=5; } message SendCardsRequest { required bytes User_name=1; required bytes User_key=2; required bytes Game_key=3; repeated int32 Send_cards=4; } message GameInfoPush { required bytes Game_key=1; required int32 Stool_id=2; required int32 Who_turn=3; required int32 Who_pre=4; repeated CardInfo My_Cards=5; repeated CardInfo Pre_Cards=6; repeated bytes Player_list=7; required int32 Left_Second=8; } message ChatRequest { required bytes Game_key=1; required bytes Player_Name=2; required bytes Chat_msg=3; } message ChatPush { required bytes Game_key=1; required bytes Player_Name=2; required bytes Chat_msg=3; } message GameOverPush { required bytes Game_key=1; required bytes Winer_Name=2; } message RoomInfo { required int32 Room_id=1; required bytes Room_name=2; required int32 Desk_count=3; required int32 Stool_count=4; required int32 Room_type=5; } message CardInfo { required int32 Card_No=1; required int32 Card_Color=2; required int32 Card_Used=3; }
c++发送消息样例
GAMEMSG::Message msg; msg.set_msg_type(MsgType::enum_Reflesh_Rooms_Response); GAMEMSG::MsgContent *pcontent=msg.mutable_msg_content(); GAMEMSG::RefleshRoomsResponse *prrr= pcontent->mutable_reflesh_rooms_response(); MODEL::RoomDAL dal_room; map<int,MODEL::room> allrooms= dal_room.GetList(); for(size_t i=0;i<allrooms.size();++i) { GAMEMSG::RoomInfo *oneRoom= prrr->add_room_info(); oneRoom->set_room_id(allrooms[i].room_id); oneRoom->set_room_name(allrooms[i].room_Name); oneRoom->set_room_type(allrooms[i].room_type); oneRoom->set_desk_count(allrooms[i].desk_count); oneRoom->set_stool_count(allrooms[i].stool_count); } ret=PortoBufHandle::AddSize(msg);
c++处理消息了样例
vector<shared_ptr<GAMEMSG::Message>> doingMsgs= PortoBufHandle::ParseData(msg,pendMsg); if(pendMsg.size()>0) { EchoFun(LSU_HELPER::CastStr(fd)+"pending:"+pendMsg); GlobalBuff.UpdatePendBuff(fd,createtime,pendMsg); } for(size_t i=0;i<doingMsgs.size();++i) { GAMEMSG::MsgType mType=doingMsgs[i]->msg_type(); GAMEMSG::MsgContent mContent=GAMEMSG::MsgContent(); mContent=doingMsgs[i]->msg_content(); string protomsg; if(mType==GAMEMSG::MsgType::enum_Reflesh_Rooms_Request) { GAMEMSG::RefleshRoomsRequest realmsg=mContent.reflesh_rooms_request(); protomsg= RoomProcess::room_Request(realmsg); } else if(mType==GAMEMSG::MsgType::enum_Login_Request)
c#下的protobuf 的书写样式。
GAMEMSG.Message msg=GAMEMSG.Message.CreateBuilder() .SetMsgType(GAMEMSG.MsgType.enum_Login_Request) .SetMsgContent(GAMEMSG.MsgContent.CreateBuilder() .SetLoginRequest(GAMEMSG.LoginRequest.CreateBuilder() .SetUserName(ByteString.CopyFromUtf8(name)) .SetPassWord(ByteString.CopyFromUtf8(psw)) .Build()) .Build()) .Build(); byte[] bytes = msg.ToByteArray(); byte[] sendbyte= BLL2.msgHelper.AddSize(bytes);