day16-重构核心库、使用智能指针
今天是该项目开源在gthub的最后一天，我这里只是将我自己对于这个项目的理解进行总结，如有错误敬请包含指正，今天会整体理一遍代码，并使用智能指针管理整个项目。
1、common
头文件
定义宏用于禁用类的拷贝构造函数、拷贝赋值运算符、移动构造函数和移动赋值运算符。这里注意对右值引用、左值引用、万能引用的理解。
之后这里定义了一些状态，用以防止在发生错误时直接崩溃（这样的程序不够健壮）：
RC_UNDEFINED：未定义的状态。
RC_SUCCESS：成功状态。
RC_SOCKET_ERROR：套接字错误。
RC_POLLER_ERROR：轮询器错误。
RC_CONNECTION_ERROR：连接错误。
RC_ACCEPTOR_ERROR：接收器错误。
RC_UNIMPLEMENTED：未实现的功能。
#define DISALLOW_COPY(cname) \cname(const cname &) = delete; \cname &operator=(const cname &) = delete;
#define DISALLOW_MOVE(cname) \cname(cname &&) = delete; \cname &operator=(cname &&) = delete;
#define DISALLOW_COPY_AND_MOVE(cname) \DISALLOW_COPY(cname); \DISALLOW_MOVE(cname);
enum RC {RC_UNDEFINED,RC_SUCCESS,RC_SOCKET_ERROR,RC_POLLER_ERROR,RC_CONNECTION_ERROR,RC_ACCEPTOR_ERROR,RC_UNIMPLEMENTED
};
2、Socket
在这里我们仅完成服务端的socket、bind、listen以及accept，客户端的socket以及connect。
头文件
首先在头文件中禁用了类的拷贝构造函数、拷贝赋值运算符、移动构造函数和移动赋值运算符。之后依此就是构造析构函数，设置套接字文件描述符 fd_ 的值，返回当前套接字文件描述符 fd_ 的值，获取与当前连接的对端地址，获取 socket 接收缓冲区中的数据大小，创建 socket，绑定 socket 到指定的 IP 和端口，将 socket 设置为监听状态，接受客户端连接请求，发起与服务器的连接请求，设置 socket 为非阻塞模式，检查 socket 是否为非阻塞模式。
class Socket {public:DISALLOW_COPY_AND_MOVE(Socket);Socket();~Socket();void set_fd(int fd);int fd() const;std::string get_addr() const;RC Create();RC Bind(const char *ip, uint16_t port) const;RC Listen() const;RC Accept(int &clnt_fd) const;RC Connect(const char *ip, uint16_t port) const;RC SetNonBlocking() const;bool IsNonBlocking() const;size_t RecvBufSize() const;private:int fd_;
};
实现
实现上我们一步一步来看如何完成的。
构造析构函数，没啥好说的对属性初始化和释放资源：
Socket::Socket() : fd_(-1) {}Socket::~Socket() {if (fd_ != -1) {close(fd_);fd_ = -1;}
}
设置获取fd_属性：
void Socket::set_fd(int fd) { fd_ = fd; }int Socket::fd() const { return fd_; }
获取与当前连接的对端地址，getpeername用来获取与某个套接字关联的外地协议地址。
std::string Socket::get_addr() const {struct sockaddr_in addr;memset(&addr, 0, sizeof(addr));socklen_t len = sizeof(addr);if (getpeername(fd_, (struct sockaddr *)&addr, &len) == -1) {return "";}std::string ret(inet_ntoa(addr.sin_addr));ret += ":";ret += std::to_string(htons(addr.sin_port));return ret;
}
接下来是将socket设置为无阻塞模式以及判断是否为无阻塞状态，首先通过fcntl(fd_, F_GETFL)获取socket的属性并设置为O_NONBLOCK，之后将socket通过fcntl(fd_, F_SETFL, …)写入到属性中。
RC Socket::SetNonBlocking() const {if (fcntl(fd_, F_SETFL, fcntl(fd_, F_GETFL) | O_NONBLOCK) == -1) {perror("Socket set non-blocking failed");return RC_SOCKET_ERROR;}return RC_SUCCESS;
}
bool Socket::IsNonBlocking() const { return (fcntl(fd_, F_GETFL) & O_NONBLOCK) != 0; }
获取接收缓冲区的大小，通过ioctl获取文件描述符socket接收缓冲区中的待读取数据大小。
size_t Socket::RecvBufSize() const {size_t size = -1;if (ioctl(fd_, FIONREAD, &size) == -1) {perror("Socket get recv buf size failed");}return size;
}
创建一个套接字socket。
RC Socket::Create() {assert(fd_ == -1);fd_ = socket(AF_INET, SOCK_STREAM, 0);if (fd_ == -1) {perror("Failed to create socket");return RC_SOCKET_ERROR;}return RC_SUCCESS;
}
用于在指定的 IP 地址和端口上绑定 socket 。创建地址sockaddr_in并将套接字socket通过bind绑定到对应地址上。
RC Socket::Bind(const char *ip, uint16_t port) const {assert(fd_ != -1);struct sockaddr_in addr;memset(&addr, 0, sizeof(addr));addr.sin_family = AF_INET;addr.sin_addr.s_addr = inet_addr(ip);addr.sin_port = htons(port);if (::bind(fd_, (struct sockaddr *)&addr, sizeof(addr)) == -1) {perror("Failed to bind socket");return RC_SOCKET_ERROR;}return RC_SUCCESS;
}
开始将套接字转变为被动连接监听的套接字。
RC Socket::Listen() const {assert(fd_ != -1);if (::listen(fd_, SOMAXCONN) == -1) {perror("Failed to listen socket");return RC_SOCKET_ERROR;}return RC_SUCCESS;
}
从处于 established 状态的连接队列头部取出一个与服务器进行连接。
RC Socket::Accept(int &clnt_fd) const {// TODO: non-blockingassert(fd_ != -1);clnt_fd = ::accept(fd_, NULL, NULL);if (clnt_fd == -1) {perror("Failed to accept socket");return RC_SOCKET_ERROR;}return RC_SUCCESS;
}
将服务器的IP以及端口作为参数传入，建立同服务器的连接。
RC Socket::Connect(const char *ip, uint16_t port) const {// TODO: non-blockingstruct sockaddr_in addr;memset(&addr, 0, sizeof(addr));addr.sin_family = AF_INET;addr.sin_addr.s_addr = inet_addr(ip);addr.sin_port = htons(port);if (::connect(fd_, (struct sockaddr *)&addr, sizeof(addr)) == -1) {perror("Failed to connect socket");return RC_SOCKET_ERROR;}return RC_SUCCESS;
}
3、Poller
不要忘记Poller在整个项目上的作用是Epoll，一个多路复用 I/O 事件通知接口。其是由一颗红黑树和一个双向链表构成的，处理流程如下：
1、通过 epoll_ctl 函数向 epoll 实例注册一个文件描述符及其感兴趣的事件，文件描述符和事件类型会被存储在 epoll 的红黑树上。
2、当内核检测到某个注册的文件描述符上发生了感兴趣的事件（如可读、可写等），这个文件描述符会被添加到一个内部的双向链表中，这个链表专门存储那些已经就绪的文件描述符。
3、当应用程序调用 epoll_wait 时，epoll 会检查这个双向链表，将其中的就绪事件返回给应用程序。
头文件
可以看到仍旧将类设置为禁止类复制和类移动，通过对树上事件的注册、更新以及删除方法看到我们的操作是针对Channel的，Channel是一个包含事件套接字和事件类型的类。Poll是调用 epoll_wait获得事件的方法。这里实现了Linux和macOS两种方法。
class Poller {public:DISALLOW_COPY_AND_MOVE(Poller);Poller();~Poller();RC UpdateChannel(Channel *ch) const;RC DeleteChannel(Channel *ch) const;std::vector<Channel *> Poll(long timeout = -1) const;private:int fd_;#ifdef OS_LINUXstruct epoll_event *events_{nullptr};
#endif#ifdef OS_MACOSstruct kevent *events_;
#endif
};
实现
首先是构造/析构函数，注意万物皆是文件这句话，所以epoll也有属于自己的socket，在构造和析构的过程中不要忘了释放，创建epoll中还要初始化分配关于events_ 的空间，他就是那个双向链表。
Poller::Poller() {fd_ = epoll_create1(0);ErrorIf(fd_ == -1, "epoll create error");events_ = new epoll_event[MAX_EVENTS];memset(events_, 0, sizeof(*events_) * MAX_EVENTS);
}Poller::~Poller() {if (fd_ != -1) {close(fd_);}delete[] events_;
}
通过epoll_wait将树上的事件读入到就绪事件链表中，之后根据发生的事件类型将就绪事件的类型进行记录。注意，只有发生与预期事件相关的事件时才会将事件加入就绪队列中。
std::vector<Channel *> Poller::Poll(int timeout) {std::vector<Channel *> active_channels;int nfds = epoll_wait(fd_, events_, MAX_EVENTS, timeout);ErrorIf(nfds == -1, "epoll wait error");for (int i = 0; i < nfds; ++i) {Channel *ch = (Channel *)events_[i].data.ptr;int events = events_[i].events;if (events & EPOLLIN) {ch->SetReadyEvents(Channel::READ_EVENT);}if (events & EPOLLOUT) {ch->SetReadyEvents(Channel::WRITE_EVENT);}if (events & EPOLLET) {ch->SetReadyEvents(Channel::ET);}active_channels.push_back(ch);}return active_channels;
}
获取事件的socket，并将预期的事件类型进行记录，当然如果该事件不存在在红黑树上，我们需要将事件记录到红黑树上。注意是epoll_event中data部分的ptr指向Channel，所以需要Channel中的期待类型来更新epoll_event中的事件类型，之后pool根据这个。
获取事件的socket，并将通道从红黑树上删除，将通道是否在树上的标志位置false。
void Poller::UpdateChannel(Channel *ch) {int sockfd = ch->GetSocket()->fd();struct epoll_event ev {};ev.data.ptr = ch;if (ch->GetListenEvents() & Channel::READ_EVENT) {ev.events |= EPOLLIN | EPOLLPRI;}if (ch->GetListenEvents() & Channel::WRITE_EVENT) {ev.events |= EPOLLOUT;}if (ch->GetListenEvents() & Channel::ET) {ev.events |= EPOLLET;}if (!ch->GetExist()) {ErrorIf(epoll_ctl(fd_, EPOLL_CTL_ADD, sockfd, &ev) == -1, "epoll add error");ch->SetExist();} else {ErrorIf(epoll_ctl(fd_, EPOLL_CTL_MOD, sockfd, &ev) == -1, "epoll modify error");}
}void Poller::DeleteChannel(Channel *ch) {int sockfd = ch->GetSocket()->fd();ErrorIf(epoll_ctl(fd_, EPOLL_CTL_DEL, sockfd, nullptr) == -1, "epoll delete error");ch->SetExist(false);
}
之后是在macOS上的代码，逻辑相似就是库函数的调用有差别。
#ifdef OS_MACOSPoller::Poller() {fd_ = kqueue();assert(fd_ != -1);events_ = new struct kevent[MAX_EVENTS];memset(events_, 0, sizeof(*events_) * MAX_EVENTS);
}
Poller::~Poller() {if (fd_ != -1) {close(fd_);fd_ = -1;}
}
std::vector<Channel *> Poller::Poll(long timeout) const {std::vector<Channel *> active_channels;struct timespec ts;memset(&ts, 0, sizeof(ts));if (timeout != -1) {ts.tv_sec = timeout / 1000;ts.tv_nsec = (timeout % 1000) * 1000 * 1000;}int nfds = 0;if (timeout == -1) {nfds = kevent(fd_, NULL, 0, events_, MAX_EVENTS, NULL);} else {nfds = kevent(fd_, NULL, 0, events_, MAX_EVENTS, &ts);}for (int i = 0; i < nfds; ++i) {Channel *ch = (Channel *)events_[i].udata;int events = events_[i].filter;if (events == EVFILT_READ) {ch->set_ready_event(ch->READ_EVENT | ch->ET);}if (events == EVFILT_WRITE) {ch->set_ready_event(ch->WRITE_EVENT | ch->ET);}active_channels.push_back(ch);}return active_channels;
}
RC Poller::UpdateChannel(Channel *ch) const {struct kevent ev[2];memset(ev, 0, sizeof(*ev) * 2);int n = 0;int fd = ch->fd();int op = EV_ADD;if (ch->listen_events() & ch->ET) {op |= EV_CLEAR;}if (ch->listen_events() & ch->READ_EVENT) {EV_SET(&ev[n++], fd, EVFILT_READ, op, 0, 0, ch);}if (ch->listen_events() & ch->WRITE_EVENT) {EV_SET(&ev[n++], fd, EVFILT_WRITE, op, 0, 0, ch);}int r = kevent(fd_, ev, n, NULL, 0, NULL);if (r == -1) {perror("kqueue add event error");return RC_POLLER_ERROR;}return RC_SUCCESS;
}
RC Poller::DeleteChannel(Channel *ch) const {struct kevent ev[2];int n = 0;int fd = ch->fd();if (ch->listen_events() & ch->READ_EVENT) {EV_SET(&ev[n++], fd, EVFILT_READ, EV_DELETE, 0, 0, ch);}if (ch->listen_events() & ch->WRITE_EVENT) {EV_SET(&ev[n++], fd, EVFILT_WRITE, EV_DELETE, 0, 0, ch);}int r = kevent(fd_, ev, n, NULL, 0, NULL);if (r == -1) {perror("kqueue delete event error");return RC_POLLER_ERROR;}return RC_SUCCESS;
}
#endif
4、Channel
Channel主要是将事件的socket和事件类型进行联系，并加入相应的回调函数，即Channel中包含了事件的socket、状态、处理、轮询等信息。他就是一个集大成socket。
头文件
同样禁止了复制移动类构造函数。其中包含了需要Channel注册的事件循环EventLoop，事件socket，期待事件类型，就绪事件类型以及对应的读写回调函数。
class Channel {public:DISALLOW_COPY_AND_MOVE(Channel);Channel(int fd, EventLoop *loop);~Channel();void HandleEvent() const;void EnableRead();void EnableWrite();int fd() const;short listen_events() const;short ready_events() const;bool exist() const;void set_exist(bool in = true);void EnableET();void set_ready_event(short ev);void set_read_callback(std::function<void()> const &callback);void set_write_callback(std::function<void()> const &callback);static const short READ_EVENT;static const short WRITE_EVENT;static const short ET;private:int fd_;EventLoop *loop_;short listen_events_;short ready_events_;bool exist_;std::function<void()> read_callback_;std::function<void()> write_callback_;
};
实现
简单的构造和析构函数，析构函数中调用的EventLoop中的DeleteChannel应该是Poller中的DeleteChannel，将事件从树上删除。
Channel::Channel(int fd, EventLoop *loop) : fd_(fd), loop_(loop), listen_events_(0), ready_events_(0), exist_(false) {}Channel::~Channel() { loop_->DeleteChannel(this); }
根据不同的就绪事件类型调用不同的事件处理函数，注意根据Poller中，如果事件类型不为EPOLLIN、EPOLLOUT、EPOLLET中任何一种，那么事件不会设置就绪事件类型，在这里也就不会调用任何处理函数。
void Channel::HandleEvent() const {if (ready_events_ & READ_EVENT) {read_callback_();}if (ready_events_ & WRITE_EVENT) {write_callback_();}
}
将事件期待的类型进行设置，并通过EventLoop调用Poller中的UpdateChannel。
void Channel::EnableRead() {listen_events_ |= READ_EVENT;loop_->UpdateChannel(this);
}void Channel::EnableWrite() {listen_events_ |= WRITE_EVENT;loop_->UpdateChannel(this);
}