【muduo】net篇---TcpConnection

最新推荐文章于 2024-08-16 23:42:55 发布
最新推荐文章于 2024-08-16 23:42:55 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： # Muduo网络库 文章标签： muduo tcpconnection
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daaikuaichuan/article/details/87822822
版权

  TcpConnection类主要负责封装一次TCP连接，向Channel类注册回调函数（可读、可写、可关闭、错误处理），将来当Channel类上的事件发生时，调用相应的回调函数进行数据收发或者错误处理。

  TcpConnection是使用shared_ptr来管理的类，因为它的生命周期模糊。TcpConnection表示已经建立或正在建立的连接，建立连接后，用户只需要在上层类如TcpServer中设置连接到来和消息到来的处理函数，继而回调TcpConnection中的 setConnectionCallback和setMessageCallback函数，实现对事件的处理。用户需要关心的事件是有限的，其他都由网络库负责。

  TcpConnection中封装了InputBuffer和OutputBuffer，用来表示应用层的缓冲区。在发送数据时，如果不能一次将Buffer中的数据发送完毕，它还会继续关注Channel中的可写事件，当sockfd可写时，会再次发送。

#include <muduo/net/TcpConnection.h>
#include <muduo/base/Logging.h>
#include <muduo/base/WeakCallback.h>
#include <muduo/net/Channel.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/Socket.h>
#include <muduo/net/SocketsOps.h>

#include <errno.h>

using namespace muduo;
using namespace muduo::net;

void muduo::net::defaultConnectionCallback(const TcpConnectionPtr& conn)
{
  LOG_TRACE << conn->localAddress().toIpPort() << " -> "
            << conn->peerAddress().toIpPort() << " is "
            << (conn->connected() ? "UP" : "DOWN");
}

void muduo::net::defaultMessageCallback(const TcpConnectionPtr&, Buffer* buf, Timestamp)
{
  buf->retrieveAll();
}

TcpConnection::TcpConnection(EventLoop* loop,
                             const string& nameArg,
                             int sockfd,
                             const InetAddress& localAddr,
                             const InetAddress& peerAddr)
  : loop_(CHECK_NOTNULL(loop)),
    name_(nameArg),
    state_(kConnecting),
    reading_(true),
    socket_(new Socket(sockfd)),
    channel_(new Channel(loop, sockfd)),
    localAddr_(localAddr),
    peerAddr_(peerAddr),
    highWaterMark_(64*1024*1024)
{
  // 向Channel对象注册可读事件
  channel_->setReadCallback(std::bind(&TcpConnection::handleRead, this, _1));
  channel_->setWriteCallback(std::bind(&TcpConnection::handleWrite, this));
  channel_->setCloseCallback(std::bind(&TcpConnection::handleClose, this));
  channel_->setErrorCallback(std::bind(&TcpConnection::handleError, this));
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this << " fd=" << sockfd;
  socket_->setKeepAlive(true);
}

TcpConnection::~TcpConnection()
{
  LOG_DEBUG << "TcpConnection::dtor[" <<  name_ << "] at " << this
            << " fd=" << channel_->fd()
            << " state=" << stateToString();
  assert(state_ == kDisconnected);
}

bool TcpConnection::getTcpInfo(struct tcp_info* tcpi) const
{
  return socket_->getTcpInfo(tcpi);
}

string TcpConnection::getTcpInfoString() const
{
  char buf[1024];
  buf[0] = '\0';
  socket_->getTcpInfoString(buf, sizeof buf);
  return buf;
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 发数据是主动的，用户一般可用TcpConnection::send() 
来发送数据，最终会调到TcpConnection::sendInLoop()。如果数据不能一次
发完，则打开channel的写事件开关，分开几次发。
*********************************************************************/
void TcpConnection::send(const void* data, int len)
{
  send(StringPiece(static_cast<const char*>(data), len));
}

// 实际调用的是sendInLoop，在IO线程中去调用，保证安全性
void TcpConnection::send(const StringPiece& message)
{
  if (state_ == kConnected)
  {
    if (loop_->isInLoopThread())
    {
      sendInLoop(message);
    }
    else
    {
      void (TcpConnection::*fp)(const StringPiece& message) = &TcpConnection::sendInLoop;
      loop_->runInLoop(std::bind(fp, this, message.as_string()));
    }
  }
}

void TcpConnection::send(Buffer* buf)
{
  if (state_ == kConnected)
  {
    if (loop_->isInLoopThread())
    {
      sendInLoop(buf->peek(), buf->readableBytes());
      buf->retrieveAll();
    }
    else
    {
      void (TcpConnection::*fp)(const StringPiece& message) = &TcpConnection::sendInLoop;
      loop_->runInLoop(std::bind(fp, this, buf->retrieveAllAsString()));
    }
  }
}

void TcpConnection::sendInLoop(const StringPiece& message)
{
  sendInLoop(message.data(), message.size());
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 实际的发送数据函数。
*********************************************************************/
void TcpConnection::sendInLoop(const void* data, size_t len)
{
  loop_->assertInLoopThread();
  ssize_t nwrote = 0;
  size_t remaining = len;
  bool faultError = false;
  if (state_ == kDisconnected)
  {
    LOG_WARN << "disconnected, give up writing";
    return;
  }
  // 如果当前channel没有写事件发生，或者发送buffer已经清空，那么就不通过缓冲区直接发送数据
  if (!channel_->isWriting() && outputBuffer_.readableBytes() == 0)
  {
    // 发送数据
    nwrote = sockets::write(channel_->fd(), data, len);
    if (nwrote >= 0)
    {
      // 记录下没发完的数据大小
      remaining = len - nwrote;
      // 如果发完了，回调写完成函数
      if (remaining == 0 && writeCompleteCallback_)
      {
        loop_->queueInLoop(std::bind(writeCompleteCallback_, shared_from_this()));
      }
    }
    // 异常处理
    else
    {
      nwrote = 0;
      if (errno != EWOULDBLOCK)
      {
        LOG_SYSERR << "TcpConnection::sendInLoop";
        if (errno == EPIPE || errno == ECONNRESET)
        {
          faultError = true;
        }
      }
    }
  }
  // 如果还有残留的数据没有发送完成
  assert(remaining <= len);
  if (!faultError && remaining > 0)
  {
    size_t oldLen = outputBuffer_.readableBytes();
    // 如果输出缓冲区的数据已经超过高水位标记，那么调用highWaterMarkCallback_
    if (oldLen + remaining >= highWaterMark_ && oldLen < highWaterMark_ && highWaterMarkCallback_)
    {
      loop_->queueInLoop(std::bind(highWaterMarkCallback_, shared_from_this(), oldLen + remaining));
    }
    // 把数据添加到输出缓冲区中
    outputBuffer_.append(static_cast<const char*>(data) + nwrote, remaining);
    // 监听channel的可写事件（因为还有数据未发完），
    // 当可写事件被触发，就可以继续发送了，调用的是TcpConnection::handleWrite()
    if (!channel_->isWriting())
    {
      channel_->enableWriting();
    }
  }
}

void TcpConnection::shutdown()
{
  if (state_ == kConnected)
  {
    setState(kDisconnecting);
    loop_->runInLoop(std::bind(&TcpConnection::shutdownInLoop, this));
  }
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 主动关闭，调用TcpConnection::shutdown()。
*********************************************************************/
void TcpConnection::shutdownInLoop()
{
  loop_->assertInLoopThread();
  // 先判断是否发送buffer里还有东西，若有，暂时不关闭
  if (!channel_->isWriting())
  {
    // 关闭写功能
    socket_->shutdownWrite();
  }
}

void TcpConnection::forceClose()
{
  if (state_ == kConnected || state_ == kDisconnecting)
  {
    setState(kDisconnecting);
    loop_->queueInLoop(std::bind(&TcpConnection::forceCloseInLoop, shared_from_this()));
  }
}

void TcpConnection::forceCloseWithDelay(double seconds)
{
  if (state_ == kConnected || state_ == kDisconnecting)
  {
    setState(kDisconnecting);
    loop_->runAfter(seconds, makeWeakCallback(shared_from_this(), &TcpConnection::forceClose));
  }
}

void TcpConnection::forceCloseInLoop()
{
  loop_->assertInLoopThread();
  if (state_ == kConnected || state_ == kDisconnecting)
  {
    handleClose();
  }
}

const char* TcpConnection::stateToString() const
{
  switch (state_)
  {
    case kDisconnected:
      return "kDisconnected";
    case kConnecting:
      return "kConnecting";
    case kConnected:
      return "kConnected";
    case kDisconnecting:
      return "kDisconnecting";
    default:
      return "unknown state";
  }
}

void TcpConnection::setTcpNoDelay(bool on)
{
  socket_->setTcpNoDelay(on);
}

void TcpConnection::startRead()
{
  loop_->runInLoop(std::bind(&TcpConnection::startReadInLoop, this));
}

void TcpConnection::startReadInLoop()
{
  loop_->assertInLoopThread();
  if (!reading_ || !channel_->isReading())
  {
    channel_->enableReading();
    reading_ = true;
  }
}

void TcpConnection::stopRead()
{
  loop_->runInLoop(std::bind(&TcpConnection::stopReadInLoop, this));
}

void TcpConnection::stopReadInLoop()
{
  loop_->assertInLoopThread();
  if (reading_ || channel_->isReading())
  {
    channel_->disableReading();
    reading_ = false;
  }
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : TcpConnection建立连接完成。
*********************************************************************/
void TcpConnection::connectEstablished()
{
  loop_->assertInLoopThread();
  assert(state_ == kConnecting); // 正处于连接建立过程
  setState(kConnected);
  channel_->tie(shared_from_this());
  // 每个连接对应一个channel，打开描述符的可读属性
  channel_->enableReading();
  // 连接成功，回调客户注册的函数（由用户提供的函数，比如OnConnection）
  connectionCallback_(shared_from_this());
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : TcpConnection::connectDestroyed()是TcpConnection析构前
最后调用的一个函数，它通知用户连接已断开。
*********************************************************************/
void TcpConnection::connectDestroyed()
{
  loop_->assertInLoopThread();
  if (state_ == kConnected)
  {
    setState(kDisconnected);
    channel_->disableAll();
    // 仅仅起到记录作用而已
    connectionCallback_(shared_from_this());
  }
  // 在poller中移除channel
  channel_->remove();
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 
当某个channel有读事件发生时，会调用TcpConnection::handleRead()函数，
然后从socket里读入数据到buffer，再通过回调把这些数据返回给用户层。
*********************************************************************/
void TcpConnection::handleRead(Timestamp receiveTime)
{
  loop_->assertInLoopThread(); // 断言是否在loop线程
  int savedErrno = 0; 
  // 读数据到inputBuffer_中
  ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno);
  if (n > 0)
  {
    // 用户提供的处理信息的回调函数（由用户自己提供的函数，比如OnMessage）
    messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }
  // 读到了0，表明客户端已经关闭了
  else if (n == 0)
  {
    handleClose();
  }
  else
  {
    errno = savedErrno;
    LOG_SYSERR << "TcpConnection::handleRead";
    handleError();
  }
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 当可写事件触发时，调用TcpConnection::handleWrite()。
*********************************************************************/
void TcpConnection::handleWrite()
{
  loop_->assertInLoopThread();
  if (channel_->isWriting())
  {
    // 写数据
    ssize_t n = sockets::write(channel_->fd(), outputBuffer_.peek(), outputBuffer_.readableBytes());
    if (n > 0)
    {
      // 调整发送buffer的内部index，以便下次继续发送
      outputBuffer_.retrieve(n);
      // 如果可读的数据量为0，这里的可读是针对系统发送函数来说的，不是针对用户
      // 如果对于系统发送函数来说，可读的数据量为0，表示所有数据都被发送完毕了，即写完成了
      if (outputBuffer_.readableBytes() == 0)
      {
        // 不再关注写事件
        channel_->disableWriting();
        if (writeCompleteCallback_)
        {
          // 调用用户的写完成回调函数
          loop_->queueInLoop(std::bind(writeCompleteCallback_, shared_from_this()));
        }
        // 如果当前状态是正在关闭连接，那么就调用shutdown来主动关闭连接
        if (state_ == kDisconnecting)
        {
          shutdownInLoop();
        }
      }
    }
    else
    {
      LOG_SYSERR << "TcpConnection::handleWrite";
    }
  }
  else
  {
    LOG_TRACE << "Connection fd = " << channel_->fd() << " is down, no more writing";
  }
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 当对端调用shutdown()关闭连接时，本端会收到一个FIN，
channel的读事件被触发，但inputBuffer_.readFd() 会返回0，然后调用
handleClose()，处理关闭事件，最后调用TcpServer::removeConnection()。
*********************************************************************/
void TcpConnection::handleClose()
{
  // 断言是否在loop线程
  loop_->assertInLoopThread();
  LOG_TRACE << "fd = " << channel_->fd() << " state = " << stateToString();
  assert(state_ == kConnected || state_ == kDisconnecting);
  setState(kDisconnected);
  // channel上不再关注任何事情
  channel_->disableAll();
  // 获得shared_ptr交由tcpsever处理
  TcpConnectionPtr guardThis(shared_from_this());
  // 作用是记录一些日志
  connectionCallback_(guardThis);
  // 回调TcpServer::removeConnection()，TcpConnection的生命期由TcpServer控制
  closeCallback_(guardThis);
}

/******************************************************************** 
Modify : Eric Lee
Date : 2018-01-20
Description : 处理出错事件
*********************************************************************/
void TcpConnection::handleError()
{
  int err = sockets::getSocketError(channel_->fd());
  LOG_ERROR << "TcpConnection::handleError [" << name_
            << "] - SO_ERROR = " << err << " " << strerror_tl(err);
}
~青萍之末~
关注
专栏目录
muduo库的TcpConnection类剖析
Mr_scott_j的博客
12-12 2697
TcpConnection是muduo中最为复杂的类，其实就是对已连接套接字的一个抽象。 TcpConnection使用Channel来获得socket上的IO事件，它可以自己处理writable事件，而把readable事件通过MessageCallback传达给客户。在TcpConnection析构时候会close(fd)（在Socket析构函数中发生）。
muduo源码分析：TcpConnection类
amoscykl的博客
11-01 708
前言 前面学习了TcpServer的实现，TcpServer对每个连接都会新建一个TcpConnection（使用shared_ptr管理）。接下来学习一下TcpConnection的设计细节。   连接状态 muduo对于一个连接的从生到死进行了状态的定义，类似一个状态机。 enum States { kDisconnected, kConnecting, kConnected, k...
5.muduo之TcpConnection类
qq_42987442的博客
09-09 216
介绍： 1.TcpConnection.h文件 ///该类对象，客户端和服务器都会用到 ///这是一个接口类，所以不用暴露太多细节 class TcpConnection : noncopyable, public std::enable_shared_from_this<TcpConnection> { public: /// Constructs a TcpConnection with a connected sockfd ///用一个
muduo Tcpconnection类
xufengyongyou的专栏
04-26 379
muduo  Tcpconnection 封装一次连接
muduo : TcpConnection
Huntinux
08-11 1204
引用前面学习了TcpServer的实现，TcpServer对每个连接都会新建一个TcpConnection（使用shared_ptr管理）。接下来学习一下TcpConnection的设计细节。连接状态muduo对于一个连接的从生到死进行了状态的定义，类似一个状态机。enum States { kDisconnected, kConnecting, kConnected, kDisconnecting
muduo-0.9.1-beta.tar.gz
11-30
3. 处理连接：通过`TcpServer::newConnection`方法处理新的客户端连接，并定义相应的回调函数处理数据读写。 4. 定义事件处理器：muduo库中的`EventLoop`和`Channel`类是处理事件的基础，你可以自定义事件处理器类...
1、muduo网络库 ---- Linux平台下muduo编译安装
JACKSONMHLK的博客
12-22 4353
muduo库的介绍：一个基于reactor反应堆模型的多线程C++网络库。作者是陈硕大神。 muduo库是基于 boost 库开发的，所以需要在 Linux 平台上首先安装 boost 库。 1、boost 库安装 第一种方法是编译源码安装，可以了解一下，不过比较麻烦： 1、准备好boost压缩包，我这里是boost_1_65_0.tar.gz 2、解压 tar -zxvf boost_1_65_0.tar.gz /usr/local 3、进入/usr/local/boost_1_65_0目录.
muduo学习笔记---HttpServer_test.cc
weixin_43133795的博客
12-17 734
先贴一下陈硕大佬的代码： HttpServer_test.cc : 这个是server的顶层实现，主要的工作就是注册了一个回调函数，处理http的业务逻辑 #include "muduo/net/http/HttpServer.h" #include "muduo/net/http/HttpRequest.h" #include "muduo/net/http/HttpResponse.h" #i...
读Muduo源码笔记---7(Protobuf)
qq_28840229的博客
10-30 698
1、概念    Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。     将 程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化” （Dese...
muduo源码解析之TcpConnection
Swartz2015的专栏
02-23 853
在上一篇对Tcpserver的连接事件处理器Acceptor的解析中知道Acceptor为每个连接创建一个TcpConnection结构，通过将这个结构传递给Eventpool实现eventpool和Acceptor的关联。因此TcpConnection是连接后面eventpool的桥梁。本篇将解析TcpConnection类。   首先看一下TcpConnection的类数据成员：
tcp connection
weixin_34274029的博客
03-06 129
三次握手与四次挥手的原因 https://yq.aliyun.com/articles/7435?spm=5176.8091938.0.0.N4v33a linux里的backlog详解 tcp connection setup的实现(一) linux内核中tcp连接的断开处理 tcp connection setup的实现(二) 关于tcp_v4_do_rcv()中对TCP_LIST...
33muduo_net库源码分析（九）
INGNIGHT的专栏
09-10 414
1.TcpServer/TcpConnection （1）Acceptor类的主要功能是socket、bind、listen （2）一般来说，在上层应用程序中，我们不直接使用Acceptor，而是把它作为TcpServer的成员TcpServer还包含了一个TcpConnection列表 （3）TcpConnection与Acceptor类似，有两个重要的数据成员，Socket与Chan
Muduo之TcpConnection源码分析笔记
Aaron的专栏
05-04 510
Muduo之TcpConnection源码分析笔记
muduo网络库学习笔记(12)：TcpServer和TcpConnection类
li27z的博客
11-08 1110
muduo网络库-TcpServer和TcpConnection类
muduo_net代码剖析之TcpConnection
JaweG
11-29 332
1、TcpServer在接收并建立连接的过程中，TcpConnection做了什么工作？ 经过前文对TcpServer类的讲解以及上图的展示，我们知道： TcpConnection是TcpServer的一个成员变量 当TcpServer接收到client的连接请求后，将会回调newConnection()函数：先创建TcpConnection对象用来与client连接，再执行connectEs...
Get-NetTCPConnection列出任何软件（浏览器）当前打开的所有 HTTPS 连接
最新发布
weixin_71228606的博客
08-16 287
是一个有用的实用程序，用于检查打开的端口和侦听器。但是，该工具仅返回文本，具有隐晦的参数，并且不能跨平台使用。中找到的大部分功能。例如，您可以列出任何软件（浏览器）当前打开的所有。系统上，可以使用名为。
windows 深入理解PowerShell中的Get-NetTCPConnection命令
fdsgdsgdfw的博客
04-12 483
维获取）**[外链图片转存中…(img-GUjZdTvT-1712868952285)]
windows:深入理解PowerShell中的Get-NetTCPConnection命令
十年运维开发经验的王义杰在此分享自己的知识和经验
12-19 967
命令是Windows PowerShell中一个非常实用的工具，它提供了一种快速、直观的方式来查看和分析TCP连接状态。无论是用于日常管理任务，还是复杂的故障排查，了解和掌握这个命令都将大大提高你的工作效率。
net9. Tcp连接类——TcpConnection
TABE_的博客
03-29 898
TcpConnection类 TcpConnection用来表示一个 TCP 连接, 不可再生, 如果这个连接断开, 那么该TcpConnection就失去了意义 TcpConnection中包含有封装好的读写 buffer, 用来收发数据 TcpConnection的生命周期由智能指针shared_ptr来管理, 具体在下面的注释中有 TcpConnection对象有四个状态, 表示连接的正在建立, 建立完成, 处于断开 (TcpConnection不主动关闭一个连接,都是等客户端主动关闭), 已经断开
使用Muduo实现短URL服务 - Linux下的嵌入式系统实践
此外，书中还提供了许多其他示例，如TCP协议处理、文件传输、定时器、网络延迟测量等，这些都展示了Muduo在网络编程中的广泛应用。 Muduo网络库提供了一种高效且易于理解的方式来构建网络服务，特别适合那些需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

~青萍之末~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值