muduo網路庫學習之EventLoop（七）：TcpClient、Connector

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void Connector::connect()
{
    int sockfd = sockets::createNonblockingOrDie(); // 建立非阻塞套接字
    int ret = sockets::connect(sockfd, serverAddr_.getSockAddrInet());
    int savedErrno = (ret == 0) ? 0 : errno;
    switch (savedErrno)
    {
    case 0:
    case EINPROGRESS:   // 非阻塞套接字，未連線成功返回碼是EINPROGRESS表示正在連線
    case EINTR:
    case EISCONN:           // 連線成功
        connecting(sockfd);
        break;
        ....
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void Connector::connecting(int sockfd)
{
    setState(kConnecting);
    assert(!channel_);
    // Channel與sockfd關聯
    channel_.reset(new Channel(loop_, sockfd));
    // 設定可寫回撥函式，這時候如果socket沒有錯誤，sockfd就處於可寫狀態
    channel_->setWriteCallback(
        boost::bind(&Connector::handleWrite, this)); // FIXME: unsafe
    // 設定錯誤回撥函式
    channel_->setErrorCallback(
        boost::bind(&Connector::handleError, this)); // FIXME: unsafe

    channel_->enableWriting();      // 讓Poller關注可寫事件
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

    if (state_ == kConnecting)
    {
        int sockfd = removeAndResetChannel();   // 從poller中移除關注，並將channel置空
        // socket可寫並不意味著連線一定建立成功
        // 還需要用getsockopt(sockfd, SOL_SOCKET, SO_ERROR, ...)再次確認一下。
        int err = sockets::getSocketError(sockfd);
        ......
        else    // 連線成功
        {
            setState(kConnected);
            if (connect_)
            {
                newConnectionCallback_(sockfd);     // 回撥
            }

        }
    }
}

1
2
3
4

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

1
2

typedef boost::shared_ptr<Connector> ConnectorPtr;
ConnectorPtr connector_;    // 用於主動發起連線

1

TcpConnectionPtr connection_; // Connector連線成功以後，得到一個TcpConnection

1
2
3

// 設定連線成功回撥函式
connector_->setNewConnectionCallback(
    boost::bind(&TcpClient::newConnection, this, _1));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void TcpClient::newConnection(int sockfd)
{
    ...........
    TcpConnectionPtr conn(new TcpConnection(loop_, connName, sockfd, localAddr, peerAddr));

    conn->setConnectionCallback(connectionCallback_);
    conn->setMessageCallback(messageCallback_);
    conn->setWriteCompleteCallback(writeCompleteCallback_);
    conn->setCloseCallback(
        boost::bind(&TcpClient::removeConnection, this, _1)); // FIXME: unsafe
    {
        MutexLockGuard lock(mutex_);
        connection_ = conn;     // 儲存TcpConnection
    }

    conn->connectEstablished();     // 這裡回撥connectionCallback_
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include <muduo/net/Channel.h>
#include <muduo/net/TcpClient.h>

#include <muduo/base/Logging.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/InetAddress.h>

#include <boost/bind.hpp>

#include <stdio.h>

using namespace muduo;
using namespace muduo::net;

class TestClient
{
public:
    TestClient(EventLoop *loop, const InetAddress &listenAddr)
        : loop_(loop),
          client_(loop, listenAddr, "TestClient"),
          stdinChannel_(loop, 0)
    {
        client_.setConnectionCallback(
            boost::bind(&TestClient::onConnection, this, _1));
        client_.setMessageCallback(
            boost::bind(&TestClient::onMessage, this, _1, _2, _3));
        //client_.enableRetry();
        // 標準輸入緩衝區中有資料的時候，回撥TestClient::handleRead
        stdinChannel_.setReadCallback(boost::bind(&TestClient::handleRead, this));
        stdinChannel_.enableReading();      // 關注可讀事件
    }

    void connect()
    {
        client_.connect();
    }

private:
    void onConnection(const TcpConnectionPtr &conn)
    {
        if (conn->connected())
        {
            printf("onConnection(): new connection [%s] from %s\n",
                   conn->name().c_str(),
                   conn->peerAddress().toIpPort().c_str());
        }
        else
        {
            printf("onConnection(): connection [%s] is down\n",
                   conn->name().c_str());
        }
    }

    void onMessage(const TcpConnectionPtr &conn, Buffer *buf, Timestamp time)
    {
        string msg(buf->retrieveAllAsString());
        printf("onMessage(): recv a message [%s]\n", msg.c_str());
        LOG_TRACE << conn->name() << " recv " << msg.size() << " bytes at " << time.toFormattedString();
    }

    // 標準輸入緩衝區中有資料的時候，回撥該函式
    void handleRead()
    {
        char buf[1024] = {0};
        fgets(buf, 1024, stdin);
        buf[strlen(buf) - 1] = '\0';        // 去除\n
        client_.connection()->send(buf);
    }

    EventLoop *loop_;
    TcpClient client_;
    Channel stdinChannel_;      // 標準輸入Channel
};

int main(int argc, char *argv[])
{
    LOG_INFO << "pid = " << getpid() << ", tid = " << CurrentThread::tid();
    EventLoop loop;
    InetAddress serverAddr("127.0.0.1", 8888);
    TestClient client(&loop, serverAddr);
    client.connect();
    loop.loop();
}