微服务开源框架TARS的RPC源码解析 之 初识TARS C++服务端

作者:Cony

导语:微服务开源框架TARS的RPC调用包含客户端与服务端,《微服务开源框架TARS的RPC源码解析》系列文章将从初识客户端、客户端的同步及异步调用、初识服务端、服务端的工作流程四部分,以C++语言为载体,深入浅出地带你了解TARS RPC调用的原理。

什么是TARS

TARS是腾讯使用十年的微服务开发框架,目前支持C++、Java、PHP、Node.js、Go语言。该开源项目为用户提供了涉及到7 ! { ( S P S开发、运维、以及测试的一整套微服务平台P: z L - 6 o ] LaaS解决方案,帮助一个产品或者服务快速开发、部署、测试、上线。目前该框架应用在腾讯各大核心业务G t Q h [ 0 r,基于该框架部署运行的服务节点规模达到数十万。

TARS的通信模型P p A Z %中包含客户端和服务端。客户端服务端之间主要是利用RPC进行通信。本系列文章分上下两篇,对RPC调用部分进行源码解析。本文是下[ . ] x $ X篇,我们将以C++语1 s _ N t $ ?言为载体,带大家了解一下TARS的服务端。

初识m P . ! X M f R服务端

在使用TARS构建RPC服务端的时候,TARS会帮你生成一个XXXServer类,这个类是继承自Applic! O _ation类的,声明变量XXXServer g_app,以及调用函数:

g_app* P 9 B z 4 c P.main(argc, argv);
g_app.waitForShutdown();

便A , R可以开启TARS的RPC服务了。在开始剖析TARS的服U } n w E g务端代` M p s ? f /码之前,先介绍几个重要的类,让大家有一个大致的认识。

Application

正如前面所言,一个服务端就是一个Application,Application帮助用户读取配置文件a ! 1 v M 3,根据配置文件初始化代理(假如这个服务端需要调用其他服务,那么就需要初始化代理了)与服务,新建以及启动网络线程与业务线程。

TC_EpollServer

TC_Epoz o C 3 f / f | sllServer才是真正的服务端,如果把Application比作风扇,那么TC_EpollServe6 t Y w 2 /r就j H 8 u m F L M G是那个马达。J s MTC_EpollServer掌管两大模块——网络模块与业务模块,就是下面即将介绍的两个类。

NetThread

代表着网络模块,内含TC_Epoller作为IO复用,TC_# k K v 6Socket建立socket连接,ConnectionList记录众R ` z A | H多对客户端的sockD ^ I 2 M { Bet连接。任何与网络5 s & ; X相关的数据收发都与Net{ A 8 M P GThread有关。在配置文件中,利用/tars/application/ser% p Kver 下的netthread配置NetThread的z A 4 Y f / u个数

HandleGroup与Handle

代表着业务模块,Handle是执行PRC服务的一个线程,而众多Handle组成的HandleGrc r = : 2 Ooup就是同一个RPC服务的一组业务线程了。业务线程负责调用用户定义好的服务代码,并将处理结果放到发送缓存中等待网络模块发送,下文将会详细讲解业务线程如N [ 9 ! z . ,何调用用户定义的代码的,这里用到了简单的C++反射,这点在很多资料中都没有被提及。在| s c W Q i n配置文件中,利用/tars/application/server/xxxAdapter 下的threads配置一( 4 g , [ } a x个HandleGroupR = Z ; ] P ( ]中的Handle(业务线程)的个数。

BindAdapter

代表一个RPC服务实体,在配置文件中的/tars/application/servH $ @ M D @ { /er下面的xxxAdapter就是对BindAdapM M oter的配置,一个BindAdapter代表一个服务实体,看其配置就知道BindAdapter的作用是什么了,其代表一个RPC服务对外的监听套接字,还声明了连接的最大数量,接收队列的大小,业务线程数,RPC服务名,所使用的协议等。

Bi. 6 Z ^ , #ndAdapter本身可以认为是一个服务的实例,能建立真实存在的监听socket并对外服务O ; : v 7 o 7 p,与网络模块NetThread以及业务模块HandleGroup都有关联,例如,多个NetThread的第一个线~ / P r x程负责对BindAd, A V { [ _apter的lY L j W Uisten socket进行监听,有客户连接到BindAdapter的listen socket就随机在多个NetThread中选取一个,将连接放进被选中的NetThread的ConnectionList中。BindAdapter则通常会2 0 n Z H 与一组HandleGroup进行关联,该HandP N ^ U bleGroup里面的业务线程b v c t就执行BindAdapter对应t L $的服务。可见,BindAdapter与j G S网络模块以及业务模块都有所关联。

好了,介绍完这几个类之后,通过类图看看他们之间K j O的关系u 5 9 .

图(2-1)服务端相关类图

服务端TC_EpollServer管理类图中左侧的网络模块与右侧的业务模块,前者负责建立与管理% ? 9 Q i服务端的网络W ` { Z B a q关系,后者负责执行服务端的业务代码,两者通过BindAdapter构成一个整体,对外进行RPC服务。

初始化

与客户端一样,服务端也需要进2 } S } U y 4 : $行初始化,来构$ 9 l l建上面所! 9 $ d说的整体,按照上面的介绍,可以将初始化分为两模块——网络模块的初始化与业务模块的初始化。初始化的所有代码在Application的void main()以及vow i { g lid waitForQuit()中,初始化包括屏蔽pipe信号,读取配置文件等,这些将忽略不讲,主要看看其如何通过epoll与建立listen soc8 P I F m @ A Sket来构建网络部分,以及如何设置业务线程组构建业务部分。

TC_EpollServer的初始化

在初始化网络模块与业务模块之前,TC_EpollServer需要先初始n L ? D X F #化,主要代码在:

void Application::main(int argc, char *argv[])
{
......
//初始化@ b ~ H + - ] R [Servep x l 7r= b B I E P { a }部分
initializeServer();
...v & j q h m x...
}

在initializeServer()中会填充ServerConfig里面的各个静态成员变量,留待需要的时候取用。可以看到有_epollSey + y Q O ) t 9rver = new TC_EpollServer(iNetThreadNum),服务端TC_EpollServer被创建出来,而且网络线程NetThread也2 . N 4 o c O被建立出来了:

TC_Er C 5 b LpollServer::TC_Epol. ( A w 4 7 G 9 ~lServer(unsD : A !igned int iNetThreadNum)
{
if(_netThQ d B J D %readNum < 1)
{
_netThreadNum = 1;
}
//网络线程的配置数目不能15个
if(_) N $ w p ~netThreadNum > 15)
{
_netThreadNum = a h l b 15;
}
for (size_t i = 0; i < _netThreS : $ u 9 ~adNum; ++i)
{
TC_EpollServer::NetThread* nef k Z X stThreads = new TC_EpollServer::Net G o h Q ; 8 *tThread(this);
_netThreads.push_back(netThreads);
}
}

此后,其实有一个AdminAdapter被建立,但其与一般的RPC服务BindAdapter不同,这里不展开介绍。

好了,TC_EpollServer被构j y 9 + y _ (建之后,如何给他安排左(网络模块)右(业务- 2 b模块)护法呢?

网络模块初始化

在讲解网络模块之前,再认真地看看网络模块的相N V M M ]关类图:

图(2-2)网络% S n i模块类图

先看看3 | EApplicatiK e S B n m G = 6on中哪些代码与n / 8 9 5 v ) Z .网络模块的初始化有关吧:

void Application::main(int argc, char *argv[p [ X t j { [ c D])m { T & I
{
......
vector<TC_EpE z } l  K `ollServer::BindAdapterPtr> adapters;
//绑定对象和端口
bindAdapter(adapters)d | a % ^;
......
_epoC S 1llServer->createEpoll();
}
void Application::waitForShutdowni F O ^ G j()
{
waitForQuit();
......
}

网络部分的初始化,离不开建立各RPC服务的监1 & @ : j q @ t *听端口(socket,bind,listen),% ~ ` O ? X接收客户端的连接(accept),建立epoll等。那么何时何地调用这些函数呢?大致过程如下图所示:

图(2-3)网络模块的初始化

1. 创建服务实体的listeR + Bn socket

首先在Application::main()中,调用:

vector<T6 e gC_EpollServ| t e . 3er::BindAdapt) X , 7erPtr> adapters;
//绑定对象和端口
bindAdapter(adapters);

在Application::bindAdapter()建立一个个服务实体BindAdapter,通过读取配置文件中的/tars/appz T d _lication/server下面的xxxAdapter来确定服务实体BindAg | j M . 9daE ( G z upter的个数及不同服务实体的配置,然Q Z 6 ^ r G后再调用:

BindAdapterPM , ; i Etr bindAdapter = new BindAdapter(_epollServer.get());
_epollServer->bind(bindAdapter);

来确定服务实体的listen socket。可以看到,在TC_EpollSz 9 7 O &erver::bind()中:

int  TC_EpollServer::bind(TC_1 i t  [ L f K cEp- ] ~ / #  NollServer::BindAdapterPtr &lsPtr)
{
int iRet = 0;
for(siS G ^ & {ze_t i = 0;C $ m ? j @ ( V - i < _netThreads.size(); ++i)
{
if(i == 0)
{
iRet = _netThreads[i]->bind(lsPtr)2 { j 6;
}
elseM Q ~ / z ! I o
{
//当网络线程中listeners没有监听socket时,list使用adapter中设置的最大连接数作为初始化
_netThreads[i]->setListSize(lsPtr->getMaxConnsi ] # O . ` @ ?());
}
}
return iRet;
}

将上文TC_E/ l ? @ V cpollServer的初始化时创建的网络线程组中的第一条网络线程负责创建并监听服务实体的listen socket,那样就可以避免多线程监听a / & ! C 同一个fd的惊群效应。

可以看到,接下来继续调用NetThread::bind(BindAdapterPY 7 X 8 n %tr &lsPtr),其负责做一些准备工作,实i / n际创建socket的是在NetThread::bU t c K )ind(BindAdapterPtr &3 8 = tamp;lsPtr)中执行的NetThread::bind(E [ u , d }const TC_Endpoint &ep, TC_Socket &s):

void TC_EpollServer::NetThread:m k z ] X:bind(coH { & } * j $nst TC_Endpoint &ep, TC_Socket &s)
{
int type = ep.isUnixLocal()?AF_LOCAL:AF_INET;
if(ep.isTcp())
{
s.createSocket(SOCK_STREAM, type);
}
else
{
s.createSoc| D Fket(SOCK_DGRAM, type);
}
if(ep.isUnixLocal())
{
s.bind(ep.getHost().c_str());
}
else
{
s.bind(ep.getHost(), ep.getPort());
}
if(ep.isTcp() && !ep.isUnixLocal())
{
s.listen(1024);
s.setKeepAlive();
s.setTcpNoDelay();
//不要设置close wait否则http服务回包主动关闭连接会有问题
s.setNoCloseWait();
}
s.setblock(false);
}

执行到这里,已经创建了服务实体BindAdapter的listen socket了,代码2 d b ^退回到NetThread::bi5 ^ ` k S & bnd- R O { k J(BindAdapterPtr &lsPtr)后,还可以看到NetThread记录fd其所负责监听的7 b ? C ( { YBindAdapter:z _

_listenerE O A ns[s.getfd()] = lsPtr;

下图是对创建服务实0 * v A u ,体的listen socket的流程总结

图(2-4)创建服务实体的listen socket

2. j 0 k z ] S ) @创建epoll

代码回到Application::main()中,通过执行:

_epollServer->createEpoll();

来让TC_EpollServer在其掌管的网络线程中建立epoll:

void TC_EpollServer::createEp# ; . K B [oll()
{
for(size_t i = 0; i < _n~ n 0 ^ t 6 ` wetThreads.size(); ++i)
{
_nJ @ ; L J i _etThreads[i]->createEpoll(i+1);
}
//必须先等所有网络线程调用c, O k 6 s  t *reateEpoll(),初始化list后,才能调用initUdp()
for(si~ 5 R $ze_t i = 0; i < _netTd J R 5 n s bhreaD M Y W h 1 Y ^ ads.size(); ++i)
{
_netThreads[i]->initUdp();
}
}

代码来到NetThread::createEpoll(uint32_t iIndex),这个函数可以作为网络线程NetThread的初始化函数,在函数里面建立了网络线程的内存池,创建了epoll,还将上面创建的listen socket加入epoll中,当然只有第一条网络线程才有listen socket,此外还初始化了连接管理链表ConnectionList _list。看下图对本流程的总结:

图(2-5)F U R创建epoll

3.. k / ] g O v }启动网络线程

由于NetThread是线程,需要执行其start()函数才能启动线程。而这个工作不是在Application::main()中完成,而是C # g在Application::waitForShutdown()中的Application::waitForQuit()完成,跟着下面的流程图看代码,就清楚明白了:

图(2-6)启动网络线程

业务模块的初始化

同样,与网a } g n , = D络模块一样,在讲解业务模块之前,Y 1 , H B j m先认真地看看业务模块的相关类图:

图(@ m a [ 32-7)业务模块K c 5相关类图

在业务模块初始化中,我们需要理清楚两个问题:业务模块如何% m )与用户填充实现的XXXServantImp建立联系,从而使请求到来的时候,Handle能够调用用户定义好的RPC方法?业~ u B P T 8 {务线程在何时何地被启动,! v Z如何等待着请求的到达?

看看Application中哪| 2 P * 7 % g些代码与业务模块的初始化有关吧:

void Application::mah 4 | N z * T F Xin(int argc, char *argv[])
{
......
vector<TC_EpollServer::BindAdapterPtr5 y j g 8> adapt4 o { J T Eers;
bindAdapter(adapters);
//业务应用的初始化
initialize(O K ( % n);
//设置H@ F *andleGroup分组,启动线程
for (size_t i =e i & @ c r ` z 0; i < adapters.size(); ++i)
{
string name = adaptu $ r 6 G C o l xers[i]->getName();
string groupName = adapters[i]->getHandleGroupName] T U 6 T U();
if(name != groupName)
{
TC_EpollServer::BindAdapterPtr ptr = _epolp W !lServer->getBindAdapter(groupName);
if (!ptr)
{
throw runtime_error("[TARS][adater `" + name + "` setHandle to group `" + groupName + "` fa[ } t Y X * jil!"$ [ E ^  c @ W k);
}
}
setHandle(adapters[i]);
}
//启动业务处理线程
_epollServer->sta6 6 1 P | O p @rtB K ! - 4Handle();
......
}

在bindAdapter(adaptec / = G Yrs)与initialize()中解决了前面提到的第一个问题,剩下的代码实现了handle业务线程组的创建与启动。

1.将BindAdapter与V 0 8 Q ! @ d用户定义的方法关联起来

如何进行关联?先看看下面的代码流程图:

图(2-8)通过ServantHelperManager关联BindAdapter与服务Servant

如何让业务线程能够调用用户自定义的代码?这里引入了ServantHelperManager,先简单剧透一下,通过ServantHelperManager作为桥梁,业务线程可以通过BindAdapter的ID= q ? ~索引到服务ID,然后通过服务ID索引到用户自定义的XXXServantImp类的N Q + / Y 0生成器,有了生成器,业务线程就可以生成XXXServantImp类并调用里面的方法了。下面一步一步分析。

在Application::main()调用的Appl! p ]ication::bindAdapter()中看到有下面的代码:

for (] ? n . R x 4 [ 9size_t i = 0; i < adapterName.size(); i++)
{4 D  & ( G F 6 9
……
string s+ o x p A t _erm f * S O L r ~vant = _conf.get("/tars/application/server/" + adapterName[i] + "<servant>");
chn ( h ( 9 0 |eckServantNameValid(servant, sPrefix6 8 A %);
ServantHelperManager::getInstance()->setAdapterServant(adapterName[i], serh [ v ]vant);
……
}

举个例子,adapterNamei为MyDemo.StringServer.StringServantAdapter,而servant为MyDemo.Str- [ YingServer.StringServantObj,这些都是在配置文} @ ] f 2件中读取M I O B的,前者是BindAdapter的ID,而后者是服务ID。在ServantHelperManager:: setAdapterSer? r _ $ ] ) H ovant()中,仅仅是执行:

void ServantHelperManager::setAdapterServant(const string &sAdaptA d 1 8 U # : 6 uer, const string &sServanq a v  & Kt)
{
_adapter_servant[sAdapter] = sServant;
_servant_adapter[sSe` W 8 4 j S } m Hrvant] = sAdapter;
}g A x ` g

而这) m . - u h ] B两个成员变量仅仅是:

    /**
* Adapter包含的Servant(Adapter名称:servant名称)
*/
map<string, string>                     _adapP V zter_servant;
/**
* Adapter包含的Servant(Servant名称:Adapter名称)
*/
map<string, string>                     _servant_adaZ H /pter;

在这里仅仅是作一个映射记录,后续可以通过BindAdapter的ID可以索引到服务的ID,通过服务的ID可以利用简单的C++反射得出用户实现的XXXServantImp类,从而得到用户实现的方法。

如何实现从服务ID到类的反8 O S射?同样需要通- N t + Y B M r过ServantHelperManager的帮助。在Application::main()中,执行完Application::bindAdapter()会执行initialize(),这是一个纯虚函数,实际会执行派生类XXXServer的函数,类似:: 5 R

void
StringServer::initialize()
{
//initialize application here:
//...
addServant<StringServantImp>(ServerConfigR & p X M _ z X V::Application + "." + ServerConfig::ServerName + ".StringServantObj");
}

代码最终会执行ServantHelperManager:: addServant<T>():

    temp4 ! M $ N alate<typename T>
void addServant(const string &id,bool check = false)
{
if(ch u / K xeck && _servant_adapte` q @ 6r.end() == _servant_adapter.find(id))
{
cerr<<"[TARS]ServantHelperManager::addServant "<< id <<" not find adapter.(maybe not c= g Q #onS ` ]f in the web): G l"<<endl;
throw runte r Iime_error("[TARS]ServantHelperManager::addServant " + id + " not find adapter.(maybe notO p S a conf in t1 e 8 X ; Phe web)");
}
_servant_creator[id] = new ServantCreation&l! 9 5 j O wt;T>();
}

其中参数const string& id是服务ID,例如上文的MyDemo.StringServer1 ( S J y.StringServantObj,T是用户填充实现的XXXServantImp类。

上面代码的_serl 4 r 9 2 E (vant_creatorid = new ServantCreation<T>()是函数的关键,_servant_creator是map<string, ServantHelperCreationPtr>,可! V J @ ? s n $ =以通过服G ( o务ID索引到ServantHelperCreationPtr,而ServantHelperCreationPtr是什么?是帮助我们生成XXXServantImp实例的类生成器,这就是简单的C++反射:

/**
* Servant
*/
class ServantHelperCreation : public TC_HandleBase
{
public:
virtual ServantPtr create(const string &s) = 0;
};
typedef TC_AutoPtr<ServantHelperCreation> ServantHelperr D y z t / k ,CreationPtr;
//////////////////////////////////////////////////////////////////////////////
/**
* Servant
*/
template<class T>
struct ServantCreation : public Ser2 k l h FvantHelperCreation
{
ServantPtr create(const string &a, = hmp;s) { T *p = new T; p->sh N ? W q ] )etName(s); return p; }
};

以上就是通过T . } p M 4 Q服务ID生成相应XXXServantImp类的简单反射技术,业务线程组里面的业务线程只需要获取到所需执行的业务的f } `BindAdapter的ID,就可以通过ServantHT ? /elperManager获得服务ID,有了服务ID就可以获取XXv c = RXServantImp类的生成器从而生成XXXServantImp类执行里面由用户定义好的RPC方法。现在重新看图z G ; m _ P H /(2-8)就大致清楚整个流程了。

2.Handle业务线程的启F m 6 y Q

剩下的部分就e Q % e & R是HandleGroup的创建,并将其与BindAdapter进行相互绑定关联,同时也需要绑定到TC_EpollServer中,随后创建/启动HandleGroup下面的Handle业务线程,启动Handle的过程涉及上文“将BindA3 ^ + 4 vdapter与用户定义的方法关联起来”提到的获取服务类生成器。先看看大致的代码流程图:

图(2-9) 业务线程组的建立流程

在这里分两部分^ } & b F,第一部分是在Application::main()中执行下列代码:

//设置HandleGroup分组,启动线程
for (size_t i = 0; i < adH i 0 I M O + T _apters.size(4 ? G X N); ++i)
{
string name = adapters[i]->getName();
string groupName = adapters[i]->getHandleGroI e o w / L IupName();
if(name != groupName)
{
TC_EpollServer::BindAdapterPtr ptr = _epollServer->getBindAdapter(groupName);
if (!ptr)
{
throw runtime_error("[TARS][adater `" + name + "` setHandle to group `" + groupName + "` fail!");
}
}
setHandle(adapters[i]);
}

遍历在配置文件中定义好的每一个BindAdapter(例如MyDemo.StringSe B u 4 v q *rver.StringSer} } jvantAdapter),并为其设置业务线程组HandleGroup,让线程组的所有线程都可以执行该BindAc Y v ^ T mdapter所对应的RPC方法q u l !。跟踪代码如下:

void Application::setHandle(TC_Epg ? y s A j oollSeF $ . ?rver::BindAB * ;dapter} ? = r iPtr&c ~ o + j r famp; adapter)
{
adapter->setHandle<ServantHandle>();
}D g  9

注意,$ j Y 4 - $ B GServantHandle是Handle的派h N a e _ o生类,就是业务处理线程类,随后来到:

template<ty& } , ] J t lpename T> void setHandle()
{
_pEpollServer->setHandleGroup<T>(_handleGroH _ u U o `upName, _iHandleNum, this);
}

真正创建业务线程组HandleGroup以及组内的线程,并将线程组与BF / } M q Y 3 i OindAdapter,TC_EpollServer关联起来的代码在TC_EpollSerA t V Y # V @ver:: setHandleGroup()中:

/**
* 创建一个handle对象组,如果已经存在则X F 8直接返回
* @param name
* @return HandlePtr
*/
template<class T&gt A + 0 Mt; void setHandleGroup(const string& g} x 0roupName, int32_t handleNum, BindAdapterPtr adapter)
{
map&l) H W 0 n z At;string, HandleGroupPtr>::iterator it = _handleGroups.find(groupName);
if7 ~  B & ! F a (it == _handleGroups.end())
{
HandleGroupPtr hg = new HandleGroup();
hg-- Q L E i 5 A c %>name =} L n / c B C ; groupName;
adapter->_handleGroup = hg;
for (int32_t i = 0; i < handleNum5 @ X , F; ++i)
{
HandlePtr handle = new T();
handle->setEpollO ] 8 r 3 aServer(this);
handle->setHandleGroup(hg);
hg->handles.push_back(handle);
}
_handleGroups[groupName] = hg;
it = _handleGroups.find(groupName);
}
it->second->adapters[adapter->getName()] = adapter;
adapter->_handleGroup = it->s s K z 3 LsecondX 0 Y H t ) t ) o;
}

在这里,可以看到业务线程组的创建:Handle] o = [ 4 gGroupPtr hg = new HandleGroup();业务线程的创建:HandlePtr handle = new T()(T{ 8 : 6 M } b S是ServantHandle);建立关系,例如BindAdapter与HandleGroup的相互关联:b 0 a Rit->second->adaptersadapter->gl X ; = k O D ^etName() = adapter和adapter->_handleGroup = it->second。执行完上面的代码4 O v 2 m #,就可以得到B l 6下面的类图了:

图(2-10)再看业务模块相关类图

这里再通过函数流程图简单复习一下上述代码的流程,主要内容均在TC_EpollServer:: setHandleGroup()中:

图(2-11)建立业务模块

随着函F ( B F数的层层退出,代码重新来到Application::main()中,随后V 9 D C = l o *执行:

//启动业务处理线程
_epollSe( Y + ? ^ ) g lrver->startH0 2 D I $ | ]andle();

在TC_EpollServer::startHandle()中,遍历TC_Epoll~ 2 C Server控制的业务模块HandleGroup中的所有业务线程组,并遍历组内的各个Handle,执行其start()方法进行线程的启动:

void TC_EpollServer::stan / b 9 Vrt? # ! RHandle()
{
if (!_handleStarted)
{
_h2 ] $ ; &andleSta{ 7 %rt+ t F f K s * A eed = true;
for (auto& kv : _handleGroups)
{
auto& hds = kv.second->handles;
for (auto&aw w e (mp; handle : hds)
{
if (!handle->p  #isAlive())
handle->starv 0 A U % lt();
}
}
}
}

由于Handle是继承自TC_Thread的,在执行Handlef t o # M p p::start()中,会执行虚函数Handle:m R c i 7 B k H w:run(),在Handle::run()中主要是执行两个函数,一个是ServantHandle::initialize(),另一个# = q Z S是Handle::handleImp():

void TC_EpollServer::Handle::run()
{
initialize();
handleImp();
}

ServantHandle::initialize()的主要作用是取g F ` C O R o 1得用户实现的RPC方法,其实现原理与o ` ] ]上文(“6 E u 62.2.3业务模块的初始化”中的第1小点“将BindAdapter与用户定义的方法关联起来”)提及的一样,借助与其关联的BindAdapter的ID号,以及ServantHelpManager,来查找到用户填充实现的XXXServantImp类的生成器并生成XXXServantImp类的实例,将这个实例与服务名构成pair <string, ServantPtr>变量,放进map<string, Serc k E 6vantPtr> ServantHandlU A ne:: _servants中,等待业务线程Handle需要执行用户自定义方法的时候,从map<string, ServantPtr> ServantHandle:: _servants中查找:

void ServantHandle::initialize7 = O @ 4()
{
map<string, TC_EpollServer::BindAdapterPtr>_ R p ] X 1 3 }::iterator adpit;
// 获取本Handle所关联的BinB f [ j udAdapter
map<string, TC_EpollServer::BindAdapterPtr>& adapters = _handleGroup->adapters;
// 遍历所有BindAdapter
for (adpit = adapters.@ 8 G 9 f i +begin(); adpit != adapters.end(); ++adpit)
{
// 借助ServantH& * 7 g w 5 K | relperManager来获取服务指针——XXXServantImp类的指针
ServantPtf l 1 N Tr servant = Servant% 7 u ^Hel? ~ {  +perManager::getInstance()->create(adpit->first);
// 将指针放进map<string, SeY ( = J { P d $rvantPtr> ServantHandle:: _servants中
if (servant)
{
_servants[servant->getName()] = servant;
}
else
{
TLOGERROR("[TARS]ServantHandle initialize createServant ret nuJ h Ell, for adapter `" + adpit->first + "`" << endl);
}R P k f
}m 5 % 3
......
}

而Handle::handleImp()的主要作用是使业务线程阻塞在等待在条件变量上,在这里,可以看到_handleGroup->monitor.timedWait(_iWaitTime)函数,阻! X m A ^ b塞等待在条件变量上:

void TC_EpollServer::Handle::handleImp()
{
......
struct timespec ts;
while (!getEpollServer() 6 3->isTerminate())
{
{
TC_ThreadLock::Lock lock(_handleGroup->b r [monitor);
if (allA5 y & # h / Z ~ ldapterIsEmpty() && allFilterIsEmpty())
{
_hand d e TleP + ?Group->monitor.timedWait(_iWaitTime);
}
}
}
......6 c b 8 S d @
}

HandlI V n (e线程通过条件变量来让所有业务线程阻塞等待被唤醒 ,因为本章是介绍初始化,因此代码解读到这里先告一段落,稍后再详解服务端中的业P J ] & a 6 D务线程Handle被唤醒后,Y 4 w I N如何通过map<string, ServantPtr&g* h Z h Ht; ServantHandleG $ - ; f %:: _servants查找并执行业务。现在通过函数流程图复习一下上述的代码流程:

图(2-12)启动Handle业务线程

服务端的工作

经过了初始化工作后,服务端就进入工作状态了,服务端的工作线程分为两类,正如前面所介绍的网络线程与业务线程,网C d K S络线程负责接受客户端的连接与收发数据,而业务线程则只关注I I 3 6执行用户所定义的PRS { : 9 &C方法,两种线程在初始化的时候都已经执行starV ) e @ I zt()启动了。

大部分服务器都是按照accept()->read()->write()->close()的流程执行的,大致工作流程图如下图所示:

图(2-13)普通服务器工作流程

TARS的服务端也不例外。

判定逻辑采用Epoll IO复用模型实现,每一条网络线程NetThread都有一个TC_Epoller来做事件的收集、侦听、分发。

正如前面所介绍,只有第一条网络线l m 4 C o T程会执行连接的监听工作,接受新的连接之后,就会构造一个Connection实例,并选择处理这个连接的网络线程。

请求被读入后,将暂存在接收队列中,并通知业务线程进行处理,在这里,业务线程终于登场了,处理完请求后,将结果放到发送z c } n r ( d队列。

发送队列有数据,自然需要通知网络线b I &程进行发送,接收到发送通知的网络线程会将响应发往客户端。

TARS服务器的工作流程大致就是如此,如上图所示的普通服务器工作流程没有多大的区别,下面将按着接受客户端连接,读入RPC请求,处理RPC请求,发送RPC响应四部分逐一介绍介绍服务端的工作。

接受客户端连接

讨论服务器接受请求,很明显是从网络线程(而( T ]且是网络线程U U , 2 H K组的第一条网X * h j s o L络线程)的NetThread:h : e | O , 8 ~:run(7 C F + # J)开始分析,在上面说到的创建TC_Epoller并将监听fd放进, ! F {TC_Epoller的时候,执行的是:J U u U ) Q

_epoller.adx p H nd(kv.first, H64(EL I J KT_LISTEN) | kv.first, EPOLLIN);

那么从epoll_wait()返回的时候,eJ i I z 5 F l Dpoll_event中( c ( M的联合体epoll_data将会是(ET_LISTEN | listen socket’fd),从中获取高32位,就是ET_LISTEN,然后执行下v } ? 6 , M ?面switch中case ET_LISTEN的分支

try
{
const epoll_event &v x N;ev = _epoller^ j c 0.get(i);
uint32_t h = ev.data.u64 >> 32;
switch(h)
{
case ET_LISTEN:
{
//监听端口有请求
auto it = _listeners.find(ev.da[ f `ta.u32);
if( it != _listeners.end())
{
if(ev.events & EPOLLIN)
{
bool ret;
do
{
ret = accept(ev.data.u32);
}while(ret);
}
}Q * l U R 4 f b
}
break;
case ET_CLOSE:
//关闭请求
break;
case ET_NO] R U BTIFY:
//发送通知
.....y ] n ^ 3.
break;
case ET_NET:
//网络请求
......
break;
default:
assert(true);
}
}

而ret = accept(e7 D T Q b + k ,v.data.u32)的整个函数流程如下图所示(ev.data.u32就是被T 6 6 $ Z H激活的BindAdapter对应的监听socket的m q w ; 3 ] q 3 Nfd):

图(2-14)服务端accept一位客户端

在讲解之前,先复习一下网络线程相关类图,以及通过图解对accept有: 2 M C C l个大致的印象:

图(2-15)网络模块类图
图(2-16)服务端接受一个客户端连接

好了,跟着图(2-14),现在从NetThread::run()的NetThread::accept(int fd)讲起。

1.accept 获取客户端socket

进入NetThreadJ / H ` ( { P x J::accept(int fd),可以看到代码执行了:

//接收连接
TC_Socket s;
s.init(fd, false, AF_INET);
int iRetCode = s.accept(cs, (struct sockaddr *e a L / S d  .) &stSockAddr, iSockAddrSize);

通过TC_Socket::accept(),调用系统函数accept()接受了客户端的辛辛苦苦三次握手来的socket连接,然后对客户端的IP与端口进行打印以及检查,并分析对应的BindAdapter是否过载,过载则关闭连接。随后对客户端socket进行设置:

cs.setblock(false);
cs.setKeepAl r H 3 ! ` Elive();
cs.setTcpNoDeq - 2 9 jlay();
cs.setCloseWaitDefault();

到此,对应图(2-16)的第一步——接受客户端连接(流程如下图所示),已经完成。

图(2-17)accept客户端

2.为客户端socket创建Connection

接下来O y $ } | V T是为新来的客户端socket创建一个Connection,在I ; $ z &NetThread::accept(int fd)中,创建Connection的代码如下:

i% [ 7 t e s s `nt timeout = _listeners[fd]->getEndp . g v g N ! 8 Yoint. ) n [ 7().getTimeout()/1000;
Connect7 2 4 z h y {ionO s N l - 4 + $ *cPtrA 0 K K k z 7 P 6 = new Connec/ O dtion(_listee ( oners[fd].get(), fd, (timeout &t ~ f +lt; 2 ? 2 : timeout), cs.getfd(),f v ( ip, port);

构造函数中的参数依次是,这次新Z ~ ^ $ m m客户端所对应的BindAdapter指针,BindAdapter对应的listen socket的fd,超时时间,客户端4 # L e 3 y ,socket的fd,客户端的ip以及端口。在Connection的构造函数中,通过fd也关联其TC_Socket:

// 服务连接
Connection::Connectioh W q k { z Rn(TC` / d y y {_EpollServA X C % 2er::BindAdapter *pBindAdapter, int lfd, int timeout, int fd, constq 4 o } 4 g ~ % string& ip, uint16_; / W g { Z ht port)
{
......
_sockz i P.init(fd, trueR y Y, AF_INET);
}

那么n e . $ ( T E x关联TC_Socke5 ; 5 It; = 4 c q之后,通过Connection实例就可以操作的客户端socket了。至此,对应图(2-16)的第二步——为客户端socket创建Connection就完成了(流程如下图所示)。

图(2-18)创建Connection

3.为Connection选择一条网络线程

最后,就是为这个Connection选择一个网络线程,将其加入网络线程对应的ConnectionList,在NetThread::accept(int fd)中,执行:

//addTcpConnecti^ 6 % i . on(cPtr);
_epollServer->addConnectionA R (cPtr, cs.getfd(), TCP_CONNECT* g } a } M  4ION);

TC_EpollServer::addConnection()的代f , .码如下所示:

void TC_EpollServer::addConnection(TC_EpollServer::NetThread::Connection * cy } f WPtr, int fd, int iType)
{
TC_EpollServer::NetThread* netThread = getNetThreadOfFd(fd);
if(iType == 0)
{
netThread->addTcpConnection(cPtr);
}
else
{
netThread->addUdpConnection(cPtr);
}
}

看到,先为Connection* cPtr选择网络线程,在流程图中,被选中的网络线程称为Chosen_NetThread。选网络线程的函数是TC_EpollServer::getNetThreadOfFd(int fd),根据客户端socket的fd求余数得到,具体代码如下:

NetThread*h 6 N k getNetThreadOfFd(int fd)
{
return _netThreads[fd % _netThreads.size()];
}

接着调用被选中线程的NetThr4 - D Sead:| f | o:addTcpConnection()方法(或者

NetThread::addUdpConnection(b y u t c ; 4),这里只介绍TCP的方法),将Connection加入^ 2 Q B 7 8被选中网V y 2 7 L o R 5 /络线程的ConnectionList中,最后会执行_epoller.add(cPtr->getfd(), cPtr->_ @ ) x L G 4;getId(), EPOLLIN | EPOLLOUT)将客户端socket的fd加入本网络线程的TC_EpoM D 0ller中,让本网络线程负责对本客户端的数据收发。至此对应图(N % V X d 8 ! h k28)的第三步就执6 Y , W行完毕了(具体流程如下图所示)。

图(2-19p @ u)为Connection选择一个网络线程

接收RPC请求

讨论服务器接收RPC请求,同样从网络线程的Nea f 2 8 x 9 g BtThread::run()开始分析r - = U # a,上面是进入swH J C + ; 6 Bitch中的case ET_LISTEN分支来接受客户端的连接,那么现在就是进入cas; o D 3 2 P D 3e ET_NET分支了,为什么是case ET_NET分支v 0 & Z呢?因为上面提到,将客户端sX t z M +ocket的fd* U 0 2 b ,加入TC_Epoller来监听其读写,采用的是_epoller.add(cPtr->getfd(), cPtr-&m B $ _ P w A cgt;getId(), EPOLLIN | EPP % 8 l z q s )OLLOUT),传递给函数的第二个参数是32F & B $ K ]位的整形cPtr->g[ 9 2 s e [etId(),而L 3 [ i D函数的第二个参数要求必须是64位v v D 1 0 S n W的整型,因此,这个参数将会是高32位是0,低32位是cPtr->getId()的64位整形。而第二个参数的作用是当该注册的事件引起epoll_wait()退出的时候,会作为激活事件epoll_event 结构体中的64位联合体epoll_data_t data返回给用户。因此,看下面NetThread::run()代码:i @ Q /

try
{
const epoll_event &ev = _epoller.get(i);
uint32_t h = ev.dat2 E X L h g Ia.u64 >> 3o S R2;
switch(h)
{
case ET_LISTEN:
……
bry ^ # ~ L o s Weak;
case ET_CLOSE:
//关闭请求
break;
caK k f i 8 Dse ET_NOTIFY:
//发送通知M J @
......
break;
case ET_NET:
//网络请求
processNet(ev);
break;
default:
assert(true);
}
}

代码中的h是64位联合体epoll_data_t data的高32位,经? Z F / C过上面分析,i w j客户端socket若因为接收到数据而引起epoll_wait()退出的话,epoll_data_t data的高32位是0,低32位是cPtr->getId(),因此h将会是0。而ET_NET就是0,因此客户端socket有数据来到的话,会执行case ET_NET分支Z X U + P X &。下面看看执行case ET_NET分支的函数流程图。

图(2-20)服务端接收RPC请求流程图

1.获取激活了的连接Connection

收到R2 * } [ F z z q aPCC & ,请求,进入到NetThread::processNet(),服务器需要知道是哪一个客户端socket被激活了,因此在Nex t K O e = mtThread::processF 1 4 A Y gNet()中执行:

void TC_EpollServer::NetThread::processNet(const epoll_ev3 x ( bent &ev)
{
uint32_w } B g s 8 /t uid = ev.data.u32;
Connection *cPtr = getConnectionPtr(uid);
......
}

正如z $ t上面说的,epoll_data_t data的高32位是0,% / X D 4低32位是cPtr->getId(),那么获取到uid之后,通过NetThread:x . W p J B @ D +:getConnectionPtr()就可以从ConnectionList中返回此时此刻所需L & f ) }要读取RPC请求的Connection了。之后对获取的Connection进行简单的检查工作,并看看epoll_event::events是否是EPOLLERR或者EPOLLHUP(具体流程如下图所示)。

图(2-21)获取收到数据的Connection

2.接收客户端请求,放进线程安全队列中

接着,就需要接收客户端的请求数据了r d . l * 5,有数据接收意味着epoll_event::events是EPOLLIN,看下面代码,主要是NetThread::recvBuffer()读取RPC请求数据,以及以及Connection:: insertRecvQueue(s 4 h p W v v)唤醒业务线程发送数据。

if(ev.events & EPOLLIN)               //有数据需要读取
{
recv_queue::qup j R ` # 9eue_type vRecvData;
int ret = recvBuffer(cPtr, vRecvData);
if(ret < 0)
{
delConnection(cPtr,true,EM_CLIENT_CLOSE);
retu` J M ! o & 9 /rn;
}
if(!B l V [  V t y CvRes $ # Z r % +cvData.empty())
{
cPtr-&E 4 . + p i @gt;insertRecvQueue(vRecvData);
}
}

先看看NetThread::recvBuffer(),首先服务端会先创建一个线程安全队列来承载接收到的数据recv_queue::f X j S 6quen 4 H [ue_type vRecvData,再将刚刚获取的Connection cPt$ $ l & 3 u ~ w $r以及recv_queue::queue_type vRecvData作为参数调用NetThread::recvBuffer(cr B GPtr, vRecvData)。

而NetThread::recvBuffer()进一步调用Con} j ` ~ g | e Onection::recv()函数:

int  NetThread::recvBuffer(NetThread::Connection *cPtr, recv_queue::queue_ty(  6 } D &pe &v)
{
ret2 U + K ~ 0 @ U gurn cPtr-&R } b i x S ; : gt;recv(v);
}

Connection::recv()会依照不同的传输层协议(若UDP传输,lfd==-1),执行不同的接收方法,例如TCP会执行:

iBytesReceived = ::read(_sock.getfd(), (void*)bA @ W M _uffer, sizeof(buffer))

根据数据接收情况,如收到FIN分节,errno==EAGAIN等执行不同的动作。若收到s 9 * r x f u真实的请求信息包,会将接收到的数据放在string Connection::_ra ] t ] v 6 yecvbuffer中,然后调= F K y s y l 3用Connection:: parseProtocol()。

在Connection:: parseProtocol()中会回调协议解析函数对接收到的数据进行检验,检验通过后,会构造线程安全队列中的元素l 8 n Z HtagRecvData* recv,并将其放进线程安全队列中:

tagRecvData* recv = new tagRecvDatB Q * E ` #a();
recv->buffer           = std::1 D d i j k K L /move(ro);
recv-k a o 1 4>ip               = _ip;
recv->port             = _port;
recv->recvTimeStamp    = TNOWMS;
recv-&t % s 9 ! % 3gt;uid              = getId();
recv->isOverload       = false;
recv-~ T w 5 $ `  t>isClosed         = false;
recv6 D Q r->fd               = getfd();
//收到完整的包才算
t: h 6 Lhis->_bEmptyConn = false;
//收到完整包
o.push_back(recv);

到此,RPC请求数据已经被完全获取并放置在线程安全队列中(具体过程如下图所示)。

图(2-22)接收客户请求

3.p G G + k D 0 M {线程安全队列非空,唤醒业务线程发送

代码运行至此,线程安全队列里面终于有RPC请求包数据了,可以唤醒业务线程Handle进行处理了,代码回到NetThread::processNe: H ) y t Et(),只要线程安全队列非空,就执行Connection:: insertRecvQueue():

void NetThread::processNet(const epoll_event &ev)
{
......
if(ev.events & EPOLLX + kIN)               //) C s有数据需要读取
{
......
if(!vRecvData.empty())
{
cPtrC ; ; & $->insertRecvQueue(vRecvDa) H i {ta);
}
}
......
}

在Connection:: insertRecvQueue()中,会先对BindAdapterm + c *进行过载判断,分为未过载y T i o,半过载以及全过载三种情况。若全过载会丢弃线程安全队列中的所有RPC请求数据,否则会执行BindAdapter::| v g * _ 3 ZinsertRecw v ]vQueue. Z w E g M $()。

在BindAdapter::insertRecvQueue()中,代码主要有两个动作,第一个是将获取到的RPCY F . 请求包放进BindAdapter的接收队列——recv_queue _rbuffer中:

_rbuffer.push_back(vtRecvData)

第二个是唤醒等待条件_ z X ] a变量的HandleGroup线, E 9 a N程组:

_handleGroup->monitor.notify()

现在,服务端的网络线程在接收R0 ) i Q K ` r vPC请求数据后,终于唤醒了业务线程(具体流程看下图所示),接下来轮到业务模块登场,看! Y Q ? S M看如何处理RPC请求了。

图(2-23)唤醒业务线程

处理RPi ; l e _C请求

与前文接收到请求数据后,唤醒业务线程组HandleGroup(就是刚刚才介6 w a Z g F绍完的_h@ 8 & 2 [ C A }andleGroup->G t [ : ] a y K;monitor.notify())遥相呼应的地方是在“k I K2.2.3业务模块的初始化”第2小点“Handle业务线程的启动”中提到的,在Handle::handl u e p + Y = m heImp()函数中的_handleGroup->monitor.timedWait(_iWaitTime)。通过条件变量,业务线程组HandleGroup里] = ] w面的业务线程一起阻塞等待着网络线0 6 I程对其发起唤醒。现在,t 7 {终于对条件变= G - Y j # = ? 2量发起通知了,接下来将会如何处理请求呢?在这里,需要先对2.2.3节进行复习,了解到A q Y K N ~SerK ! l P b ~ v / &vantHandle::_K B _ - K o Fservants里面究竟承载着什么。

好了,处理RPC请求分为三步:Z t N n 6 z ) |构造请求上下文,调用用户实现的方法处理请求,将响应数据包push到! V ! E q C o线程安全队列中并通知网络线程,具体函数流程如下图所示,现在进一步分析:

图(2-24)服务端处理RPC请求流程图

1.获取请求数据构造请求上下文

当业务线程从条件变量上被唤醒之后,从其负责的BindAds Q J d ! - o jap i q Upter中获取请求数据:adapter->waitForRecv| Q GQueue(recv, 0),在BindAdapter::waitForRecvQueue()中,将从线程安全队列recvqueue BindAdapter::f [ B rbuffer中获取数据:

bool BindAdapter::waitForRecvQueue(tagRecvData* &amW l I Y m H 2  1p;recv, uint32_t iWaitTime)
{
bool bRet = false;
bRet = _rbuffer.pop_front(recv, iWaitTime);
if(!bRet)
{
return bR^ / Q a c Xet;
}
return bRet;
}

还记得在哪里将数据压入线程安全队列的吗?对,就在7 b p ` ) j N 9 !“2.3.2接收RPC请求”的第3点“线程安全队列非空o O [ A,唤醒业务线程发送”中。

G x q 2 7 c F O B着,调用ServantHandle::handle()对接收到的RPC请求数据进行处理。

处理的第一步正如本节小标题所示——构造请求上下文,用的是Serv[ 2 & f cantHandle::createCurrent():

void ServantHZ { ,andle::handle(const TC_EpollServer::tagRecvData &stRecvData)
{
TarsCurrentPtr current = createCurrent(stRecvData);
......
}

在ServantHandle::createCurrent()中,先new出TarsCurrent实例,然后调用其initialize()方法,在TarsCurrent::initialize(const TC_EpollSe! o ] u R 4 ~ m 6rver::tagRecvData &stRecvData, int64_t be8 z f F `ginTime)中,将RPC请求包的内容Q l E z g H _放进请求上下文TarsCurrC y 3 ) o 0 ^ oentPtr ce x ` f k } surrent中,后续只需关注这个请求上下文即G } ^可。另外可以稍微关注一下,若采用TARS协议会使用TarsCurrent::initialize(const string &sRecvBuffer)将请求包的内容放进请求~ R A = ? 9 | G上下文中,否则直接采用memcpy()系统调用来拷贝内容。下面稍微总结一下这小节的流z P B G程:

图(2-25)构造请求上下文

2.处理请求(只介绍TARS协议)

当获取到请求上下文之后,就需要对其进行处理了。

void ServantHandle::l N S c Y = 0 G ]handle(const TC_EpollServer::tagRecvData &stRecvData)
{
// 构造请求上下文
TarsCurrentPtr currj - w k  Went = createCurrent(stRecvData);
if (!current) return;
// 处理请求
if (current->getBindAd I B mapter()-&f o c q ? S k ) 2gt;isTarsProtocol())
{
handleTarsProtocol& : m 7 S ] ,(current);
}
el! M 3se
{
handleNoTarsProtocol(current);
}
}

本R . wPC框架支持TARS协议与非TARS协议,下面只会介绍对TARS协议j L [ 2 v的处理,对于非TARS协议,分析流程也是差不多,对非TARS协议协议感兴趣的读者可以对比着来分析非TARS协议部分。在介绍之前,先看看服务相关的继承体系,下面不要] E k混淆这三个类了:

图(2-26)服务类继承体系

好了,现在重点放在SeE z z Y f &rvantHand 6 % - 0 qdle::handleTarsProtocoQ m P d b h o .l(const TarsCurrenV w 0 p C 9 q /tPtr t)函数上面。先贴代码:

void ServantHas 7 + Andle::handleTarsProtocol(const TarsCurrv m ? j :entPtr &currenM t ; K 0 A i xt)
{
// 1-对请求上下文current进行预X H 1处理
// 2-寻找合适的服务servant
map<string, ServantPtr>::iterator sit = _servants.find(current->getServantNam} l p p j w u Se()) | A C . 8 F G c);
if (sit == _servants.end())
{
current->sendResponse(TARSSERVERNOSERVANTERR);
return;
}
intg w O $ N S ret = TARSSERVERUNKNOWNERR;
string sResultDesc = "";
vector<char> buffer;
try
{
//3-业务逻辑处理
ret = sit-&g! Y P W , mt;s{ P T 9 4econd->dispatch(current, buffer);
}
catch(TarsDecodeExcept0 ^ $ 0 :ion &ex)
{
……
}
catch(TarsEncodeException &ex)
{
……
}
catch(exception &ex)
{
……
}
catch(O : R V B x H...)
{
……
}
//回送响应,第3小点再分析吧
……
}

进入函数中,会先对请求上下文进行预处理,例如set调用合法性检查,染色处理等。随后,就依据上下文中的服务名来获取服务对象:map<string, ServantPtr>::iterator sit = _servants.find(current->getServantName()),_servants在“2.2.3业务模块的初始化”D V O b第2小点“Hc q a : Pandle业g _ w 1 = .务线a ~ z Q程的k 6 J : R y * u (启动”中被赋予内容,其key是服务ID(或者叫服务名)o C % 5 E,value是用户实现的服务XXXServantImp实例指针。

随后就可以利用XXXSerx 6 * s r - )vantImp实例指针来执行RPC请求了:ret = sit->second->dispatch(current, buffer),在Servant:: dispat2 _ [ W %ch()(如图(2-26)因为XXXServantImp是继承自XXXServant,而XXXServant继承自Servant5 h X a & 8,所以实际是执行Servant的方法)中,使用不同的协议会有不同的处理方F F + } Z 3 h式,这里只介绍TARS协议的,调用了XXXServant::onDispatcE Z r { R Vh(tars::TarF k 1sCurrentPtr _current, vector<S s A;char> &_sRe6 ( sponses m N E n V p 0 Buffer)方法:

int Servant::disp ; U 8 4 Fatch(TarsCurrentPtr curreM e 0 # @ Fnt, vec- T L H 2 ; O c ytor<( 1 d ? G e _ ` uchar&g% 5 8 x j ~ y gt; &amx % M 6p;buffer)
{
int ret = TARSSERVERUNKN* o q } } [ @ (OWNERRP 9 I * 3 O;
if (current->getFuncName() ={ ` s y ^ k= "tars_ping"t n 6 R)
{
//略
}
else i? g P E Wf (!current->getBindA[ | K Ddapter()5 f G j . q ~->C M w u;isTarsProtocol())
{
//略
}
else
{
TC_LockT<TC_ThreadRecMutex> lock(*this);
ret = onDispatch(current, buffer);
}
return ret;
}

XXXServant类就是执行Tars2Cpp的时候生t r # n @ % h p成的,会依据用户定义的tars文件来生成相应的纯虚函数,以及onDispatch()方法,该方法的动作有:

  • 1.找出在本服务类中与请求数据相对应的函数;
  • 2.解码请求数据中的函数参数;
  • 3.执行XXXServantImp类中用户定义的相应RPC方法;
  • 4.编7 Z 3 t L - * S p码函数执行后0 . F Q R x L的结果;
  • 5.return* t ) 6 C 1 s S V tars::TARm V Q OSSEA 5 = 6 ? 0 * & |RVERSUCCESS。

上述步骤是按照默: T V Q ` !认的服务端自动回复的思路去阐述,在实际中,用户可以关闭自动回复功能(如:current->se: B F 8 H 7 , EtResp q ] e pponse(false)),并自行发送回复(如:serl ) A % e X H y yvant-&g9 ) g m = P @ 7t;async_resp; ) P h Z ! Uonse_XXXAsync(current, ret, rStr))。到此,服务端已经执行了RPC方法,下面稍微总结一下本小节的内容:

图(2-27)处理TARS协议的请求

3.将响应数据包push到线程安全队列中并通知网络线程

处理完RPC请求,执行完RPC方法之后,需要将结果(下面代码中的buffer)回送给客户端:

void ServantHaT ; @ V  0ndle::handleTarsProtocol(const TarsCurren+ d J *tPtr &Z b e e P @ Samp;current)
{
// 1-对请求上下文current进行预处理
// 2-寻找合适的服务servant
//3-业务X c e @ E ^ F -逻辑处理
//回Z I .送响应,本节分析
if (current->isResponse())
{
current->senN  , b {dResponse(ret, buffer,H  9 / , ) t m Ty % , 0 Y $ KarsCure G T 6rent::TARS_STATUS(), sResultDesc);
}
}

由于业/ C & J V -务与网络是独立开来的,网络线程收到请求包之后利用条件变量来通知业务线程,而业务线程才有什么方式来通知网络线程呢?由前面可知,网络线程是阻塞在epoll中的,因此需要利用epoll来通知网络线程。这次先看图解总结,再分析代码:

图(2-28)数据pus # u vsh到队列中并通T e m知网络线程

在ServantHandle::handleTarsProtocol()中,最后的一步就是回送响应包。数据包的回送经历的步骤是:编码响应信息——找出与接收请求信息的网络线程,因为我们需要通知他来干活x 4 j $ f——将响应包放进该网络线程的发送队列——利用epoll的特性唤醒网络线程,我们重点看看NetThread::send():

void TC_EpollServer::NetTg Q K % R L h R Rhread::send(uint32_t uid, const string &s, const string &ip, uint16_t port)
{
if(_bTerminate)
{
return;
}
tagSendData* send = new tagSendData();
send->uid = uid;
send->v G ; a K i Kcmd = 's';
send->bufferW 4 2 % h r  = s;
send->ip = ip;
se2 _  Jnd->port = port;
_sbuffer.push_back(send)) 0 m ( N x 4 $ I;
//通知epoll响应, 有数据要发送
_epoller.mod(_notify.getfd(), H64(ET_NOTIFY), EP{ [ g H O w # #OLLOUT);
}

到此,服务器中的业务模块已经完成他的使命,后续将响应数据发给客户端是网络模块的工作了。

发送RPC响应

获取了请求b W k t O T .,当然需要回复响应,从上面知道业9 J [ ` j # ) c 3务模块通过_epolly f s z [ c V per.mod(_notify.getfd(), H64(EJ B +T_NOTIFY), EPOLLOUT)通知网络线程的,再加上之前分析“2.3.1接受客户端请连接”以及“2.3.2接收RPC请求”的经验,我们知道,这里必须从NetThread::run()开始讲起,而且是进t N /入case ET_NOTIF` 1 I B : = l = 9Y分支:

try
{
const epoll_event &ev = _epoller.get(i);
uint32_t h = ev.data.u64 >> 32;
switch(h)
{
case ET_LISTEN:
……
break;
case ET_CLOSE:
//关闭请求
break;
case ET_NOTIFY:
//发送通知
processPipe();
break;^  ^
case ET_NET:
//网络请求
……
break;
default:
assert(true);
}
}r d d n - { t

在NetThread::procef s _ W % ZssPipe()中,先从线程安全队列中取响应信息包:_sBufQueue.dl ? Aequeue(sendp, false),这里与“2.3.3处理RPC请求”的第3小点“将响应数据包push到线程安全队列中并通知网络线程”遥相呼应。然后从响应信息中取得与请求R s * X $信息相对应的那个Connection的uid,利用uid获取Connection:Connection *cPtr = getConnectionPtr(sendp->uid)。由于Connection是聚合了TC_Socket的,后续通过Connectio! _ H R a 2 ] Tn将响应数据回送给客户端,具体流程如下图所示:

图(2Y . % Y-29)服务端向客户z f U = M端返回响应数据

服务端工作总结

这里用图解总结一下服务端的工作过程:

图(2-30)服务端工作图

总结

TAU ? JRv G 7 C }S可以在考虑到易用性和高性能的同时快速构建系统并自动生= Q G s成代码,帮助开发人员和企业以微服务的方式快速构建自己稳定可靠的分布式应用,从而令开发人员只关注业务$ r H g D U C逻辑,提高运营效率。多语言L e X L 7 X y、敏捷5 d 5 B研发、高可用和高效运营的特性使 TARS 成为企业级产品。

《微服务开源框架TA ; r * 7RS的RPC源B ~ Z $ / @码解析》系列文章分上下两篇,对RPC调用部分进行源码解析。本文是下篇,我们带大家了解了一下TARS的5 | ^ Q l服务端。欢迎阅读上篇《初识TARS C++客户端》


TARS微服务助您数字化转型,欢迎访问:

TARS官网W ( R & H # 6 v 4:https://TarsCloud.org

TARS源码:https://github.com/TarsCloud

获取《TARS官方培训电子书》:https://wj.qq.co+ { /m/s2/6570357/3adb/

或扫码获取:

qr