muduo网络库学习笔记(五) 连接器Connector与监听器Acceptor

目录

• muduo网络库学习笔记(五) 连接器Connector与监听器Acceptor
  • Connector
    • 系统函数connect
    • 处理非阻塞connect的步骤:
    • Connetor时序图
  • Acceptor
    • 系统函数accept
    • Socket的封装
    • Acceptor的封装
    • Acceptor时序图.
  • 简单测试程序
    • Acceptor
    • Connctor
    • 运行日志

muduo网络库学习笔记(五) 连接器Connector与监听器Acceptor

标签： muduo Connector Acceptor

---

本篇继续为前面封装的EventLoop添加事件，到如今共给EventLoop添加了两个fd,Timerfd，EventFd分别用于处理定时任务和通知事件.
今天添加的Acceptor会增长另外一个fd,此fd是是一个socket，用于监听套接字链接.同时封装非组赛网络编程中的connect(2)的使用Connector.

Connector

在非阻塞网络编程中，发起链接的基本方式是调用connect(2)，当socket变得可写时代表链接创建完毕，其中要处理各类类型的错误，咱们把它封装为Connector class.
Connector 和 Acceptor 设计思路基本一致，只是Acceptor经过判断套接字是否可读来执行回调，而Connector是判断套接字是否可写来执行回调.
还有一点就是错误处理，socket可写不必定就是链接创建好了 ， 当链接创建出错时，套接口描述符变成既可读又可写,这时咱们能够经过调用getsockopt来获得套接口上待处理的错误(SO_ERROR).

其次非阻塞网络编程中connect(2)的sockfd是一次性的，一旦出错（好比对方拒绝链接），就没法恢复，只能关闭重来。但Connector是能够反复使用的， 所以每次尝试链接都要使用新的socket文件描述符和新的Channel对象。要注意的就是Channel的生命期管理了.

系统函数connect

#include <sys/types.h>          /* See NOTES */
   #include <sys/socket.h>
   
   int connect(int sockfd, const struct sockaddr *addr,
               socklen_t addrlen);

sockfd 试图制做的一个链接到被绑定到addr指定地址的套接字。
addr和addrlen 服务端地址和长度.

retrun:
成功 返回0 ， 失败 返回 -1.

处理非阻塞connect的步骤:

第一步:建立非阻塞socket,返回套接口描述符;
第二步:connect(2)开始创建链接;
第三步:判断链接是否成功创建：

A:若是connect返回0,表示链接创建成功, 若是错误为EINPROGRESS 表示链接正在进行，能够等待select()变的可写，经过getsockopt()来来获得套接口上待处理的错误(SO_ERROR),链接是否创建成功.若是链接创建成功,这个错误值将是0,若是创建链接时遇到错误,则这个值是链接错误所对应的errno值(好比:ECONNREFUSED,ETIMEDOUT等).
B: EAGAIN、EADDRINUSE、EADDRNOTAVAIL、ECONNREFUSED、ENETUNREACH 像EAGAIN 这类代表本机临时端口暂时用完的错误、能够尝试重连。
C: EACCES、EPERM、EAFNOSUPPORT、EALREADY、EBADF、EFAULT、ENOTSOCK 其余真错误像无权限，协议错误，等直接关闭套接字.

Connector正是按这个步骤处理的链接.
暴露的接口只有start()和stop()
start()执行上述connect的步骤.
stop()关闭套接字，删除注册的通道，中止进行链接.

class Connector
{
public:
  typedef std::function<void (int sockfd)> NewConnectionCallback;

  Connector(EventLoop* loop, const InetAddress& serverAddr);
  ~Connector();

  void setNewConnectionCallback(const NewConnectionCallback& cb)
  { m_newConnectionCallBack = cb; }

  void start();// can be called in any thread
  void stop(); // can be called in any thread

private:

  enum States { kDisconnected, kConnecting, kConnected };
  static const int kMaxRetryDelayMs = 30*1000;
  static const int kInitRetryDelayMs = 500;

  void connect();
  void connecting(int sockfd);

  void handleWrite();
  void handleError();

  void retry(int sockfd);
  int removeAndResetChannel();
  void resetChannel();

  void setState(States s) { m_state = s; }
  void startInLoop();
  void stopInLoop();

  EventLoop* p_loop;
  int m_retryDelayMs;
  InetAddress m_serverAddr;

  States m_state;

  std::unique_ptr<Channel> p_channel;
  NewConnectionCallback m_newConnectionCallBack;
};

Connetor时序图

Connector::Connector(EventLoop* loop, const InetAddress& serverAddr)
  :p_loop(loop),
  m_serverAddr(serverAddr),
  m_state(kDisconnected),
  m_retryDelayMs(kInitRetryDelayMs)
{
  LOG_DEBUG << "ctor[" << this << "]";
}

Connector::~Connector()
{
  LOG_DEBUG << "dtor[" << this << "]";
  assert(!p_channel);
}

void Connector::start()
{

  p_loop->runInLoop(std::bind(&Connector::startInLoop, this));
}

void Connector::startInLoop()
{
  p_loop->assertInLoopThread();
  assert(m_state == kDisconnected);

  connect();
}

void Connector::stop()
{
  p_loop->queueInLoop(std::bind(&Connector::stopInLoop, this));
}

void Connector::stopInLoop()
{
  p_loop->assertInLoopThread();

  if(m_state == kConnecting)
  {
    int sockfd = removeAndResetChannel();
    sockets::close(sockfd);
    setState(kDisconnected);
  }
}

void Connector::connect()
{
  int sockfd = sockets::createNonblockingOrDie(m_serverAddr.family());
  int ret = sockets::connect(sockfd, m_serverAddr.getSockAddr());
  int savedErrno = (ret == 0) ? 0 : errno;

  if(ret != 0) LOG_TRACE << "connect error ("<< savedErrno << ") : " << strerror_tl(savedErrno);

  switch(savedErrno)
  {
    case 0:
    case EINPROGRESS:      //Operation now in progress
    case EINTR:            //Interrupted system call
    case EISCONN:          //Transport endpoint is already connected
      connecting(sockfd);
      break;

    case EAGAIN:
    case EADDRINUSE:
    case EADDRNOTAVAIL:
    case ECONNREFUSED:
    case ENETUNREACH:
      retry(sockfd);
      LOG_SYSERR << "reSave Error. " << savedErrno;
      break;

    case EACCES:
    case EPERM:
    case EAFNOSUPPORT:
    case EALREADY:
    case EBADF:
    case EFAULT:
    case ENOTSOCK:
      LOG_SYSERR << "connect error in Connector::startInLoop " << savedErrno;
      sockets::close(sockfd);
      break;

    default:
      LOG_SYSERR << "Unexpected error in Connector::startInLoop " << savedErrno;
      sockets::close(sockfd);
      // connectErrorCallback_();
      break;
  }

}

void Connector::connecting(int sockfd)
{
  LOG_TRACE << "Connector::connecting] sockfd : " << sockfd;
  setState(kConnecting);
  assert(!p_channel);
  p_channel.reset(new Channel(p_loop, sockfd));
  p_channel->setWriteCallBack(std::bind(&Connector::handleWrite, this));
  //p_channel->setErrorCallback()

  //enableWriting if Channel Writeable ,Connect Success.
  p_channel->enableWriting();
}

void Connector::retry(int sockfd)
{
  sockets::close(sockfd);
  setState(kDisconnected);

  LOG_INFO << "Connector::retry - Retry connecting to " << m_serverAddr.toIpPort()
           << " in " << m_retryDelayMs << " milliseconds. ";

  p_loop->runAfter(m_retryDelayMs/1000.0, std::bind(&Connector::startInLoop, this));
  m_retryDelayMs = std::min(m_retryDelayMs * 2, kMaxRetryDelayMs);
}

int Connector::removeAndResetChannel()
{
  p_channel->disableAll();
  p_channel->remove();

  int sockfd = p_channel->fd();

  p_loop->queueInLoop(std::bind(&Connector::resetChannel, this));

  return sockfd;
}

void Connector::resetChannel()
{
  LOG_TRACE << "Connector::resetChannel()";
  p_channel.reset();
}

void Connector::handleWrite()
{
  LOG_TRACE << "Connector::handleWrite ";

  if(m_state == kConnecting)
  {
    int sockfd = removeAndResetChannel();
    int err = sockets::getSocketError(sockfd);

    if(err)
    {
      LOG_WARN << "Connector::handleWrite - SO_ERROR = "
               << err << " " << strerror_tl(err);
      retry(sockfd);
    }
    /*else if (sockets::isSelfConnect(sockfd))
    {

    }*/
    else
    {
      setState(kConnected);
      m_newConnectionCallBack(sockfd);
    }

  }
  else
  {
    assert(m_state == kDisconnected);
  }

}

void Connector::handleError()
{
  LOG_ERROR << "Connector::handleError States " << m_state;

  if(m_state == kConnecting)
  {
    int sockfd = removeAndResetChannel();
    int err = sockets::getSocketError(sockfd);
    LOG_TRACE << "SOCK_ERROR = " << err << " " << strerror_tl(err);
    retry(sockfd);
  }
}

Acceptor

相较于Connector更简单，只要有socket可读，便可确认链接创建.

系统函数accept

 #include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

       int accept(int sockfd, struct sockaddr addr, socklen_t addrlen);

       #define _GNU_SOURCE             /* See feature_test_macros(7) */
       #include <sys/socket.h>

       int accept4(int sockfd, struct sockaddr addr,
                   socklen_t addrlen, int flags);

sockfd socket(2)建立的文件描述符, 且已被bind(2)绑定本地地址,listen(2)使能监听.
addr 用于填充远端套接字地址, 若是不须要知道远端地址,能够添NULL.
addrlen 用于填充远端地址大小.
flags
若是flags为0  等同于 accept.

       SOCK_NONBLOCK  在新打开的文件描述符设置 O_NONBLOCK 标记。在 fcntl(2) 中保存这个标记能够获得相同的效果。

       SOCK_CLOEXEC  在新打开的文件描述符里设置 close-on-exec (FD_CLOEXEC) 标记。参看在open(2)里关于 O_CLOEXEC标记的描述来了解这为何有用。

  int connfd = ::accept4(sockfd, (struct sockaddr *)(addr),
                         &addrlen, SOCK_NONBLOCK | SOCK_CLOEXEC);
 
flags 会对返回的fd  connfd  设置SOCK_NONBLOCK | SOCK_CLOEXEC 标记.

若是用于监听的文件描述符没有设置nonblocking标志，且监听队列上没有挂起的链接, accept()会阻塞直到有新的链接到来. 若是此socket设置了nonblocking标记,accept() 会当即返回失败并设置 error 为 EAGAIN or EWOULDBLOCK.

Socket的封装

Socket类封装一个套接字 fd 析构的时候close 管理套接字的生命期.

class Socket{
public:
  explicit Socket(int sockfd) : m_sockfd(sockfd) { }
  ~Socket();

  int fd() const { return m_sockfd; }
 
  void bindAddress(const InetAddress& localaddr);
  void listen();
  int accept(int sockfd, struct sockaddr_in6* addr);

  int accept(InetAddress* peeraddr);

private:
  const int m_sockfd;
};

Acceptor的封装

Acceptor的数据成员包含Socket和Channel，Acceptor的Socket是服务端的监听socket，Channel用于观察此socket上的readable事件.并回调Acceptor:: handleRead()，handleRead()会调用accept(2)来接受新链接， 并回调用户callback。

class Acceptor{
public:
  typedef std::function<void (int sockfd, const InetAddress&)> NewConnectionCallBack;

  Acceptor(EventLoop* loop, const InetAddress& listenAddr, bool reuseport = true);
  ~Acceptor();

  void listen();
  bool listenning() const { return m_listenning; } // get listen status.

  void setNewConnectionCallBack(const NewConnectionCallBack& cb) { m_newConnectionCallBack = cb; }

private:
  void handleRead(); //处理新到的链接.

  EventLoop* p_loop;
  Socket m_acceptSocket;
  Channel m_acceptChannel;
  NewConnectionCallBack m_newConnectionCallBack;
  bool m_listenning;
  int m_idleFd;
};

Acceptor时序图.

Acceptor::Acceptor(EventLoop* loop, const InetAddress& listenAddr, bool reuseport)
  :p_loop(loop),
  m_acceptSocket(sockets::createNonblockingOrDie(listenAddr.family())),
  m_acceptChannel(loop, m_acceptSocket.fd()),
  m_listenning(false),
  m_idleFd(::open("/dev/null", O_RDONLY | O_CLOEXEC))
{
  assert(m_idleFd >= 0);
  m_acceptSocket.setReuseAddr(true);
  m_acceptSocket.setReuseAddr(reuseport);
  m_acceptSocket.bindAddress(listenAddr);
  m_acceptChannel.setReadCallBack(
    std::bind(&Acceptor::handleRead, this));
}

Acceptor::~Acceptor()
{
  m_acceptChannel.disableAll();
  m_acceptChannel.remove();
  ::close(m_idleFd);
}

void Acceptor::listen()
{
  p_loop->assertInLoopThread();
  m_listenning = true;
  m_acceptSocket.listen();
  m_acceptChannel.enableReading();
}

void Acceptor::handleRead()
{
  p_loop->assertInLoopThread();
  InetAddress peerAddr;
  int connfd = m_acceptSocket.accept(&peerAddr);
  if(connfd >= 0)
  {
    if(m_newConnectionCallBack)
    {
      m_newConnectionCallBack(connfd, peerAddr);
    }
    else
    {
      sockets::close(connfd);
    }
  }
  else
  {
    LOG_SYSERR << "in Acceptor::handleRead";
    if(errno == EMFILE)
    {
      ::close(m_idleFd);
      m_idleFd = ::accept(m_acceptSocket.fd(), NULL, NULL);
      ::close(m_idleFd);
      m_idleFd = ::open("/dev/null", O_RDONLY | O_CLOEXEC);
    }
  }

简单测试程序

Acceptor

void newConnetion(int sockfd, const InetAddress& peeraddr)
{
  LOG_DEBUG << "newConnetion() : accepted a new connection from";
  ::sockets::close(sockfd);
}

int main()
{
  InetAddress listenAddr(8888);
  EventLoop loop;
  Acceptor acceptor(&loop, listenAddr);
  acceptor.setNewConnectionCallBack(newConnetion);
  acceptor.listen();

  loop.loop();

}

Connctor

EventLoop* g_loop;

void newConnetion(int sockfd)
{
  LOG_DEBUG << "newConnetion() : Connected a new connection.";
  sockets::close(sockfd);
  g_loop->quit();
}

int main()
{
  EventLoop loop;
  g_loop = &loop;

  InetAddress serverAddr("127.0.0.1", 8888);
  Connector client(&loop, serverAddr);
  client.setNewConnectionCallback(newConnetion);
  client.start();

  loop.loop();

}

运行日志