thrift之TTransport层的堵塞的套接字I/O传输类TSocket

本节将介绍第一个实现具体传输功能的类TSocket，这个类是基于TCP socket实现TTransport的接口。下面具体介绍这个类的相关函数功能实现。
　　1.构造函数
　　分析一个类的功能首先看它的定义和构造函数实现，先看看它的定义：

[cpp] view plain copy print ?

1. class TSocket : public TVirtualTransport<TSocket> { ......}  

　　由定义可以看书TSocket继承至虚拟传输类，并且把自己当做模板参数传递过去，所以从虚拟传输类继承下来的虚拟函数（如read_virt）调用非虚拟函数（如read）就是TSocket自己实现的。
　　TSocket类的构造函数有4个，当然还有一个析构函数。四个构造函数就是根据不同的参数来构造，它们的声明如下：

[cpp] view plain copy print ?

1. TSocket();//所有参数都默认  
2. TSocket(std::string host, int port);//根据主机名和端口构造一个socket  
3. TSocket(std::string path);//构造unix域的一个socket  
4. TSocket(int socket);//构造一个原始的unix句柄socket  

　　四个构造函数分别用于不同的情况下来产生不同的TSocket对象，不过这些构造函数都只是简单的初始化一些最基本的成员变量，而没有真正的连接socket。它们初始化的变量基本如下：

[cpp] view plain copy print ?

1. TSocket::TSocket() :  
2.   host_(""),  
3.   port_(0),  
4.   path_(""),  
5.   socket_(-1),  
6.   connTimeout_(0),  
7.   sendTimeout_(0),  
8.   recvTimeout_(0),  
9.   lingerOn_(1),  
10.   lingerVal_(0),  
11.   noDelay_(1),  
12.   maxRecvRetries_(5) {  
13.   recvTimeval_.tv_sec = (int)(recvTimeout_/1000);  
14.   recvTimeval_.tv_usec = (int)((recvTimeout_%1000)*1000);  
15.   cachedPeerAddr_.ipv4.sin_family = AF_UNSPEC;  
16. }  

　　大部分简单的参数都采用初始化列表初始化了，需要简单计算的就放在函数体内初始化，其他几个都是这种情况。下面需要单独介绍一下的是unix domain socket。
　　socket API原本是为网络通讯设计的，但后来在socket的框架上发展出一种IPC机制，就是UNIX Domain Socket。虽然网络socket也可用于同一台主机的进程间通讯（通过loopback地址127.0.0.1），但是UNIX Domain Socket用于IPC更有效率：不需要经过网络协议栈，不需要打包拆包、计算校验和、维护序号和应答等，只是将应用层数据从一个进程拷贝到另一个进程。这是因为，IPC机制本质上是可靠的通讯，而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口，类似于TCP和UDP，但是面向消息的UNIX Domain Socket也是可靠的，消息既不会丢失也不会顺序错乱。
　　UNIX Domain Socket是全双工的，API接口语义丰富，相比其它IPC机制有明显的优越性，目前已成为使用最广泛的IPC机制，比如X Window服务器和GUI程序之间就是通过UNIX Domain Socket通讯的。
　　使用UNIX Domain Socket的过程和网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address family指定为AF_UNIX，type可以选择SOCK_DGRAM或SOCK_STREAM，protocol参数仍然指定为0即可。
　　UNIX Domain Socket与网络socket编程最明显的不同在于地址格式不同，用结构体sockaddr_un表示，网络编程的socket地址是IP地址加端口号，而UNIX Domain Socket的地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。
　　打开连接函数open
　　首先看这个函数的代码实现，如下：

[cpp] view plain copy print ?

1. void TSocket::open() {  
2.   if (isOpen()) {//如果已经打开就直接返回  
3.     return;  
4.   }  
5.   if (! path_.empty()) {//如果unix路径不为空就打开unix domian socket  
6.     unix_open();  
7.   } else {  
8.     local_open();//打开通用socket  
9.   }  
10. }  

　　Open函数又根据路径为不为空（不为空就是unix domain socket）调用相应的函数来继续打开连接，首先看看打开unix domain socket，代码如下：

[cpp] view plain copy print ?

1. void TSocket::unix_open(){  
2.   if (! path_.empty()) {//保证path_不为空  
3.     // Unix Domain SOcket does not need addrinfo struct, so we pass NULL  
4.     openConnection(NULL);//调用真正的打开连接函数  
5.   }  
6. }  

　　由代码可以看出，真正实现打开连接的函数是openConnection，这个函数根据传递的参数来决定是否是打开unix domain socket，实现代码如下（这个函数代码比较多，其中除了错误部分代码省略）：

[cpp] view plain copy print ?

1. void TSocket::openConnection(struct addrinfo *res) {  
2.   if (isOpen()) {  
3.     return;//如果已经打开了直接返回  
4.   }  
5.   if (! path_.empty()) {//根据路径是否为空创建不同的socket  
6.     socket_ = socket(PF_UNIX, SOCK_STREAM, IPPROTO_IP);//创建unix domain socket  
7.   } else {  
8.     socket_ = socket(res->ai_family, res->ai_socktype, res->ai_protocol);//创建通用的网络通信socket  
9.   }  
10.   if (sendTimeout_ > 0) {//如果发生超时设置大于0就调用设置发送超时函数设置发送超时  
11.     setSendTimeout(sendTimeout_);  
12.   }  
13.   if (recvTimeout_ > 0) {//如果接收超时设置大于0就调用设置接收超时函数设置接收超时  
14.     setRecvTimeout(recvTimeout_);  
15.   }  
16.   setLinger(lingerOn_, lingerVal_);//设置优雅断开连接或关闭连接参数  
17.   setNoDelay(noDelay_);//设置无延时  
18. #ifdef TCP_LOW_MIN_RTO  
19.   if (getUseLowMinRto()) {//设置是否使用较低的最低TCP重传超时   
20.     int one = 1;  
21.     setsockopt(socket_, IPPROTO_TCP, TCP_LOW_MIN_RTO, &one, sizeof(one));  
22.   }  
23. #endif  
24.   //如果超时已经存在设置连接为非阻塞  
25.   int flags = fcntl(socket_, F_GETFL, 0);//得到socket_的标识  
26.   if (connTimeout_ > 0) {//超时已经存在  
27.     if (-1 == fcntl(socket_, F_SETFL, flags | O_NONBLOCK)) {//设置为非阻塞  
28.     }  
29.   } else {  
30.     if (-1 == fcntl(socket_, F_SETFL, flags & ~O_NONBLOCK)) {//设置为阻塞  
31.     }  
32.   }  
33.   // 连接socket  
34.   int ret;  
35.   if (! path_.empty()) {//unix domain socket  
36. #ifndef _WIN32 //window不支持  
37.     struct sockaddr_un address;  
38.     socklen_t len;  
39.     if (path_.length() > sizeof(address.sun_path)) {//path_长度不能超过最长限制  
40.     }  
41.     address.sun_family = AF_UNIX;  
42.     snprintf(address.sun_path, sizeof(address.sun_path), "%s", path_.c_str());  
43.     len = sizeof(address);  
44.     ret = connect(socket_, (struct sockaddr *) &address, len);//连接unix domain socket  
45. #else  
46.       //window不支持unix domain socket  
47. #endif  
48.   
49.   } else {  
50.     ret = connect(socket_, res->ai_addr, res->ai_addrlen);//连接通用的非unix domain socket  
51.   }  
52.   if (ret == 0) {//失败了就会执行后面的代码，用poll来监听写事件  
53.     goto done;//成功了就直接跳转到完成处  
54.   }  
55.   struct pollfd fds[1];//定于用于poll的描述符  
56.   std::memset(fds, 0 , sizeof(fds));//初始化为0  
57.   fds[0].fd = socket_;//描述符为socket  
58.   fds[0].events = POLLOUT;//接收写事件  
59.   ret = poll(fds, 1, connTimeout_);//调用poll，有一个超时值  
60.   if (ret > 0) {  
61.     // 确保socket已经被连接并且没有错误被设置  
62.     int val;  
63.     socklen_t lon;  
64.     lon = sizeof(int);  
65.     int ret2 = getsockopt(socket_, SOL_SOCKET, SO_ERROR, cast_sockopt(&val), &lon);//得到错误选项参数  
66.     if (val == 0) {// socket没有错误也直接到完成处了  
67.       goto done;  
68.     }  
69.   } else if (ret == 0) {// socket 超时  
70.     //相应处理代码省略  
71.   } else {  
72.     // poll()出错了，相应处理代码省略  
73.   }  
74.   
75.  done:  
76.   fcntl(socket_, F_SETFL, flags);//设置socket到原来的模式了（阻塞）  
77.   if (path_.empty()) {//如果是unix domain socket就设置缓存地址  
78.     setCachedAddress(res->ai_addr, res->ai_addrlen);  
79.   }  
80. }  

　　上面这个函数代码确实比较长，不过还好都是比较简单的代码实现，没有什么很绕的代码，整个流程也很清晰，在代码中也有比较详细的注释了。下面继续看通用socket打开函数local_open（它也真正的执行打开功能也是调用上面刚才介绍的那个函数，只是传递了具体的地址信息）：

[cpp] view plain copy print ?

1. void TSocket::local_open(){  
2. #ifdef _WIN32  
3.     TWinsockSingleton::create();//兼容window平台  
4. #endif // _WIN32  
5.   if (isOpen()) {//打开了就直接返回  
6.     return;  
7.   }  
8.   if (port_ < 0 || port_ > 0xFFFF) {//验证端口是否为有效值  
9.     throw TTransportException(TTransportException::NOT_OPEN, "Specified port is invalid");  
10.   }  
11.   struct addrinfo hints, *res, *res0;  
12.   res = NULL;  
13.   res0 = NULL;  
14.   int error;  
15.   char port[sizeof("65535")];  
16.   std::memset(&hints, 0, sizeof(hints));//内存设置为0  
17.   hints.ai_family = PF_UNSPEC;  
18.   hints.ai_socktype = SOCK_STREAM;  
19.   hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG;  
20.   sprintf(port, "%d", port_);  
21.   error = getaddrinfo(host_.c_str(), port, &hints, &res0);//根据主机名得到所有网卡地址信息  
22.   // 循环遍历所有的网卡地址信息，直到有一个成功打开  
23.   for (res = res0; res; res = res->ai_next) {  
24.     try {  
25.       openConnection(res);//调用打开函数  
26.       break;//成功就退出循环  
27.     } catch (TTransportException& ttx) {  
28.       if (res->ai_next) {//异常处理，是否还有下一个地址，有就继续  
29.         close();  
30.       } else {  
31.         close();  
32.         freeaddrinfo(res0); // 清除地址信息内存和资源  
33.         throw;//抛出异常  
34.       }  
35.     }  
36.   }  
37.   freeaddrinfo(res0);//释放地址结构内存  
38. }  

　　整个local_open函数就是根据主机名得到所有的网卡信息，然后依次尝试打开，直到打开一个为止就退出循环，如果所有都不成功就抛出一个异常信息。
　　读函数read
　　在实现读函数的时候需要注意区分返回错误为EAGAIN的情况，因为当超时和系统资源耗尽都会产生这个错误（没有明显的特征可以区分它们），所以Thrift在实现的时候设置一个最大的尝试次数，如果超过这个了这个次数就认为是系统资源耗尽了。下面具体看看read函数的实现，代码如下（省略一些参数检查和错误处理的代码）：

[cpp] view plain copy print ?

1. uint32_t TSocket::read(uint8_t* buf, uint32_t len) {  
2.   int32_t retries = 0;//重试的次数  
3.   uint32_t eagainThresholdMicros = 0;  
4.   if (recvTimeout_) {//如果设置了接收超时时间，那么计算最大时间间隔来判断是否系统资源耗尽  
5.     eagainThresholdMicros = (recvTimeout_*1000)/ ((maxRecvRetries_>0) ? maxRecvRetries_ : 2);  
6.   }  
7.  try_again:  
8.   struct timeval begin;  
9.   if (recvTimeout_ > 0) {  
10.     gettimeofday(&begin, NULL);//得到开始时间  
11.   } else {  
12.     begin.tv_sec = begin.tv_usec = 0;//默认为0，不需要时间来判断是超时了  
13.   }  
14.   int got = recv(socket_, cast_sockopt(buf), len, 0);//从socket接收数据  
15.   int errno_copy = errno; //保存错误代码  
16.   ++g_socket_syscalls;//系统调用次数统计加1  
17.   if (got < 0) {//如果读取错误  
18.     if (errno_copy == EAGAIN) {//是否为EAGAIN  
19.       if (recvTimeout_ == 0) {//如果没有设置超时时间，那么就是资源耗尽错误了！抛出异常  
20.         throw TTransportException(TTransportException::TIMED_OUT, "EAGAIN (unavailable resources)");  
21.       }  
22.       struct timeval end;  
23.       gettimeofday(&end, NULL);//得到结束时间，会改变errno，所以前面需要保存就是这个原因  
24.       uint32_t readElapsedMicros =  (((end.tv_sec - begin.tv_sec) * 1000 * 1000)//计算消耗的时间  
25.                                      + (((uint64_t)(end.tv_usec - begin.tv_usec))));  
26.       if (!eagainThresholdMicros || (readElapsedMicros < eagainThresholdMicros)) {  
27.         if (retries++ < maxRecvRetries_) {//重试次数还小于最大重试次数  
28.           usleep(50);//睡眠50毫秒  
29.           goto try_again;//再次尝试从socket读取数据  
30.         } else {//否则就认为是资源不足了  
31.           throw TTransportException(TTransportException::TIMED_OUT, "EAGAIN (unavailable resources)");  
32.         }  
33.       } else {//推测为超时了  
34.         throw TTransportException(TTransportException::TIMED_OUT, "EAGAIN (timed out)");  
35.       }  
36.     }  
37.     if (errno_copy == EINTR && retries++ < maxRecvRetries_) {//如果是中断并且重试次数没有超过  
38.       goto try_again;//那么重试  
39.     }  
40.     #if defined __FreeBSD__ || defined __MACH__  
41.     if (errno_copy == ECONNRESET) {//FreeBSD和MACH特殊处理错误代码  
42.       return 0;  
43.     }  
44.     #endif  
45. #ifdef _WIN32  
46.     if(errno_copy == WSAECONNRESET) {//win32平台处理错误代码  
47.       return 0; // EOF  
48.     }  
49. #endif  
50.   return got;  
51. }  

　　整个读函数其实没有什么特别的，主要的任务就是错误情况的处理，从这里可以看出其实实现一个功能是很容易的，但是要做到稳定和容错性确实需要发很大功夫。
　　写函数write
　　写函数和读函数实现差不多，主要的代码还是在处理错误上面，还有一点不同的是写函数写的内容可能一次没有发送完毕，所以是在一个while循环中一直发送直到指定的内容全部发送完毕。代码实现如下：

[cpp] view plain copy print ?

1. void TSocket::write(const uint8_t* buf, uint32_t len) {  
2.   uint32_t sent = 0;//记录已经发送了的字节数  
3.   while (sent < len) {//是否已经发送了指定的字节长度  
4.     uint32_t b = write_partial(buf + sent, len - sent);//调部分写入函数  
5.     if (b == 0) {//发送超时过期了  
6.       throw TTransportException(TTransportException::TIMED_OUT, "send timeout expired");  
7.     }  
8.     sent += b;//已经发送的字节数  
9.   }  
10. }  
11. 上面的函数还没有这种的调用send函数发送写入的内容，而是调用部分写入函数write_partial写入，这个函数实现如下：  
12. uint32_t TSocket::write_partial(const uint8_t* buf, uint32_t len) {  
13.   uint32_t sent = 0;  
14.   int flags = 0;  
15. #ifdef MSG_NOSIGNAL   
16.   //使用这个代替SIGPIPE 错误，代替我们检查返回EPIPE错误条件和关闭socket的情况  
17.   flags |= MSG_NOSIGNAL;//设置这个标志位  
18. #endif   
19.   int b = send(socket_, const_cast_sockopt(buf + sent), len - sent, flags);//发送数据  
20.   ++g_socket_syscalls;//系统调用计数加1  
21.   if (b < 0) { //错误处理  
22.     if (errno == EWOULDBLOCK || errno == EAGAIN) {  
23.       return 0;//应该阻塞错误直接返回  
24.     }  
25.     int errno_copy = errno;//保存错误代码  
26.     if (errno_copy == EPIPE || errno_copy == ECONNRESET || errno_copy == ENOTCONN) {  
27.       close();//连接错误关闭掉socket  
28.     }  
29.   }  
30.   return b;//返回写入的字节数  
31. }  

　　这个写入的实现逻辑和过程也是非常简单的，只是需要考虑到各种错误的情况并且相应的处理之。
　　其他函数
　　TSocket类还有一些其他函数，不过功能都比较简单，比如设置一些超时和得到一些成员变量值的函数，哪些函数一般都是几句代码完成了。