BOOST ASIO :: DENALLINE_TIMER在超时之前重置

好吧，所以，我已经玩过你的榜样。

我可以看到超时到期时发生的无限循环，因为缺乏错误处理，尽管已经到达了超时，但read_content循环仍继续进行。

注意：

1. 第一个read_until_async建议它只会读取状态线。这根本不是那么回事！请参阅boost read_until在定界线上不会停止。
   

   它将读取第一个数据的" swoop"，其中包括至少 rn。实际上，许多服务器将标题发送给同一数据包。（实际上，有效的行为可能取决于代理和可能的硬件）。因此，假设您应该始终要求第二个read_until_async阅读标题是不安全的。而且由于可能永远不会发生"rnrn"，因此很容易进入故障模式（例如，到达流程末端时）。

2. 如果您不仔细观察流程，则可以得出结论："计时器发射得太早"（例如，您降落在refresh_socket_timer中）。但是，在我的错误情况下正在发生的事情是read_until_async只是立即返回，这是的，就像返回数据包一样。

所以我提出了

void read_content(const boost::system::error_code& err)
{
    if (err && socket_.is_open())
    {
        DEBUG_TRACE();
        boost::asio::async_read(*ssocket_, response_,
                boost::asio::transfer_at_least(1),
                boost::bind(&AsyncDownload::read_content, this,
                    boost::asio::placeholders::error)
                );
        refresh_socket_timer();
    }
    else
        std::cerr << "Error '" << err.message() << "'n";
}

因此，我们避免了连接下降时的无限循环。

void refresh_socket_timer()
{
    if (socket_.is_open())
    {
        DEBUG_TRACE();
        timer_.expires_from_now(boost::posix_time::seconds(TCP_SOCKET_TIMEOUT));
        timer_.async_wait(boost::bind(&AsyncDownload::socket_timeout, this, boost::asio::placeholders::error));
    }
}

因此，我们避免关闭插座后刷新计时器。

void socket_timeout(const boost::system::error_code &error_)
{
    // operation_aborted error is thrown whenever we cancel the timer or
    // we reset the timer using expires_from_now function,
    if ( error_ != boost::asio::error::operation_aborted ) {
        DEBUG_TRACE();
        std::cout << " ------------> TCP Connection Timeout. Broken Connection Found. Abort Operationn";
        // Ok, our TCP connection is broken, we will cancel all asynchronous
        // operations of our sockets.
        socket_.close();
    }
}

因此，我们在超时时积极关闭插座。

如果您在上述条件下评论if(...)条件，则会看到我所描述的故障模式。

这是我用来测试的完整示例：

#include <boost/asio.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/bind.hpp>
using tcp = boost::asio::ip::tcp;
#define TCP_SOCKET_TIMEOUT 2
#define DEBUG_TRACE() do { std::cout << __FILE__ << ':' << __LINE__ << "t" << __FUNCTION__ << "n"; } while(false)
struct AsyncDownload
{
    tcp::resolver               resolver_;
    tcp::socket                 socket_;
    tcp::socket*                ssocket_ = &socket_;
    boost::asio::deadline_timer timer_;
    std::string                 localFilePath_;
    boost::asio::streambuf      response_;
    AsyncDownload(boost::asio::io_service& io_service, 
            const std::string &protocol, 
            const std::string &serverip, 
            const std::string &port) :
        resolver_(io_service),
        socket_(io_service),
        timer_(io_service, boost::posix_time::seconds(TCP_SOCKET_TIMEOUT))
    {
        DEBUG_TRACE();
        // Start TCP Socket Timer
        start_socket_timer();
        // Start an asynchronous resolve to translate the server and service names
        // into a list of endpoints.
        tcp::resolver::query query(serverip, port);
        resolver_.async_resolve(query, boost::bind(&AsyncDownload::resolve, this, 
                    boost::asio::placeholders::error,
                    boost::asio::placeholders::iterator)
                );
    }
    void resolve(const boost::system::error_code &err, tcp::resolver::iterator endpoint_iterator)
    {
        DEBUG_TRACE();
        boost::asio::async_connect(ssocket_->lowest_layer(), endpoint_iterator, boost::bind(&AsyncDownload::connect, this, boost::asio::placeholders::error));
        refresh_socket_timer();
    }
    void connect(const boost::system::error_code& err)
    {
        DEBUG_TRACE();
        std::string const request_ = "GET / HTTP/1.1rnHost: www.example.comrnrn";
        boost::asio::async_write(socket_, boost::asio::buffer(request_),
                boost::bind(&AsyncDownload::write_request, this, boost::asio::placeholders::error));
        refresh_socket_timer();
    }
    void write_request(const boost::system::error_code& err)
    {
        DEBUG_TRACE();
        boost::asio::async_read_until(*ssocket_, response_, "rn",
                boost::bind(&AsyncDownload::read_status_line, this,
                    boost::asio::placeholders::error));
        refresh_socket_timer();
    }
    void read_status_line(const boost::system::error_code& err)
    {
        DEBUG_TRACE();
        std::cout << "read_status_line: " << &response_ << "n";
        boost::asio::async_read_until(*ssocket_, response_, "rnrn",
                boost::bind(&AsyncDownload::read_headers, this,
                    boost::asio::placeholders::error));
        refresh_socket_timer();
    }
    void read_headers(const boost::system::error_code& err)
    {
        DEBUG_TRACE();
        // ..............
        boost::asio::async_read(*ssocket_, response_, 
                boost::asio::transfer_at_least(1), 
                boost::bind(&AsyncDownload::read_content, this,
                    boost::asio::placeholders::error)
                );
        refresh_socket_timer();
    }
    void read_content(const boost::system::error_code& err)
    {
        if (err && socket_.is_open())
        {
            DEBUG_TRACE();
            boost::asio::async_read(*ssocket_, response_,
                    boost::asio::transfer_at_least(1),
                    boost::bind(&AsyncDownload::read_content, this,
                        boost::asio::placeholders::error)
                    );
            refresh_socket_timer();
        }
        else
            std::cerr << "Error '" << err.message() << "'n";
    }
    void start_socket_timer()
    {
        DEBUG_TRACE();
        timer_.async_wait(boost::bind(&AsyncDownload::socket_timeout, this, boost::asio::placeholders::error));
    }
    void refresh_socket_timer()
    {
        if (socket_.is_open())
        {
            DEBUG_TRACE();
            timer_.expires_from_now(boost::posix_time::seconds(TCP_SOCKET_TIMEOUT));
            timer_.async_wait(boost::bind(&AsyncDownload::socket_timeout, this, boost::asio::placeholders::error));
        }
    }
    void socket_timeout(const boost::system::error_code &error_)
    {
        // operation_aborted error is thrown whenever we cancel the timer or
        // we reset the timer using expires_from_now function,
        if ( error_ != boost::asio::error::operation_aborted ) {
            DEBUG_TRACE();
            std::cout << " ------------> TCP Connection Timeout. Broken Connection Found. Abort Operationn";
            // Ok, our TCP connection is broken, we will cancel all asynchronous
            // operations of our sockets.
            socket_.close();
        }
    }
};
int main()
{
    DEBUG_TRACE();
    boost::asio::io_service io_service;
    AsyncDownload download(
            io_service,
            "http",
            "www.google.com",
            "80");
    io_service.run();
}