asio寫成功，但沒有發送信息

Question

我在創建發送請求的客戶端程序時遇到問題。該請求正在使用保持活動的TCP HTTP連接。當一個連接關閉（由於超時或最大命中），我嘗試並開始一個新的連接，如果沒有可用的，並重新發送請求。但是，連接工作正常，當我嘗試發送寫入時，沒有任何內容被髮送（根據Wireshark），但是我的寫入錯誤代碼是成功的。接收服務器也沒有收到任何信息。這裏是我的代碼的主要部分：

void request_handler::send_1(std::vector<std::string> *bid_vector, std::string request_path, boost::mutex *bids_mutex) 
{ 
    try 
    { 
     boost::asio::streambuf request; 
     std::ostream request_stream(&request); 
     std::string reply_information; 
     request_stream << "GET /tests HTTP/1.1\r\n"; 
     request_stream << "Host: 10.1.10.160\r\n"; 
     request_stream << "Accept: */*\r\n"; 
     request_stream << "Connection: keep-alive\r\n\r\n"; 

     server1_mutex_.lock(); 
     if(server1_available_map_.size() == 0) 
     { 
      server1_mutex_.unlock(); 

      persistent_connection *new_connection = new persistent_connection("10.1.10.160","80"); 
      if(new_connection->send(request, reply_information)) 
      { 
       server1_mutex_.lock(); 
        server1_available_map_[new_connection->get_id()] = new_connection; 
       server1_mutex_.unlock(); 
      } 
     } 
     else 
     { 
       persistent_connection *current_connection = (*(server1_available_map_.begin())).second; 
       server1_available_map_.erase(current_connection->get_id()); 
      server1_mutex_.unlock(); 

      int retry_counter = 20; 
      while(!current_connection->query_rtb(request, reply_information) && --retry_counter != 0) 
      { 
       delete current_connection; 

       server1_mutex_.lock(); 
       if(server1_available_map_.size() == 0) 
       { 
        server1_mutex_.unlock(); 
        current_connection = new persistent_connection("10.1.10.160","80"); 
       } 
       else 
       { 
         current_connection = (*(server1_available_map_.begin())).second; 
         server1_available_map_.erase(current_connection->get_id()); 
        server1_mutex_.unlock(); 
       } 
      } 
      //Could not connect to 20 connections 
      if(retry_counter == 0) 
      { 
       Log::fatal("Could not connect in 20 tries"); 
       delete current_connection; 
       return; 
      } 

      server1_mutex_.lock(); 
       server1_available_map_[current_connection->get_id()] = current_connection; 
      server1_mutex_.unlock(); 
     }  
     bids_mutex->lock(); 
      bid_vector->push_back(reply_information); 
     bids_mutex->unlock();  
    } 
    catch(boost::thread_interrupted& e) 
    { 
     std::cout << "before cancel 1" << std::endl; 
     return; 
    } 
    catch(...) 
    { 
     std::cout << "blah blah blah" << std::endl; 
    } 
} 

而且我persistent_connection類

persistent_connection::persistent_connection(std::string ip, std::string port): 
    io_service_(), socket_(io_service_), host_ip_(ip) 
{ 
    boost::uuids::uuid uuid = boost::uuids::random_generator()(); 
    id_ = boost::lexical_cast<std::string>(uuid); 

    boost::asio::ip::tcp::resolver resolver(io_service_); 
    boost::asio::ip::tcp::resolver::query query(host_ip_,port); 
    boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query); 
    boost::asio::ip::tcp::endpoint endpoint = *iterator; 
    socket_.async_connect(endpoint, boost::bind(&persistent_connection::handler_connect, this, boost::asio::placeholders::error, iterator)); 
    io_service_.run(); 
} 

void persistent_connection::handler_connect(const boost::system::error_code &ec, boost::asio::ip::tcp::resolver::iterator endpoint_iterator) 
{ 
    if(ec) 
    { 
     std::cout << "Couldn't connect" << ec << std::endl; 
     return; 
    } 
    else 
    { 
     boost::asio::socket_base::keep_alive keep_option(true); 
     socket_.set_option(keep_option); 
     std::cout << "Connect handler" << std::endl; 
    } 
} 


bool persistent_connection::send(boost::asio::streambuf &request_information, std::string &reply_information) 
{ 

    std::cout << "DOING QUERY in " << id_ << std::endl; 
    boost::system::error_code write_ec, read_ec; 
    try 
    { 
     std::cout << "Before write" << std::endl; 
     boost::asio::write(socket_, request_information, write_ec); 
     std::cout << write_ec.message() << std::endl; 
    }catch(std::exception& e) 
    { 
     std::cout << "Write exception: " << e.what() << std::endl; 
    } 
    if(write_ec) 
    { 
     std::cout <<"Write error: " << write_ec.message() << std::endl; 
     return false; 
    } 
    boost::array<char,8192> buf; 
    buf.assign(0); 
    try 
    { 
     std::cout << "Before read" << std::endl; 
     boost::asio::read(socket_, boost::asio::buffer(buf), boost::asio::transfer_at_least(1), read_ec); 
     std::cout << read_ec.message() << std::endl; 
    }catch(std::exception& e) 
    { 
     std::cout << "Read exception: " << e.what() << std::endl; 
    } 
    if(read_ec) 
    { 
     std::cout << "Read error: " << read_ec.message() << std::endl; 
     return false; 
    } 
    reply_information = buf.data(); 
    return true; 
} 

std::string persistent_connection::get_id() 
{ 
    return id_; 
} 

要做到這一點的路徑是，如果server1_available_map_.size（）> 0，如果同時執行，並失敗。然後如果第二個server1_available_map_.size（）;上的大小== 0;

輸出用於該呼叫是：

DOING QUERY in 69a8f0ab-2a06-45b4-be26-37aea6d93ff2 
Before write 
Success 
Before read 
End of file 
Read error: End of file 
Connect handler 
DOING QUERY in 4eacaa96-1040-4878-8bf5-c29b87fa1232 
Before write 
Success 
Before read 

其示出了第一連接獲取文件的端部（連接由服務器上的另一端封閉）。第二個連接連接正常（連接處理程序消息），查詢在第二個連接（不同的id）中執行，並且寫入顯然成功，並且程序掛在讀取上（因爲沒有任何可讀的內容）。

有沒有人知道爲什麼會發生這種情況？有什麼我似乎做錯了嗎？

謝謝

Answer 1

它看起來像你傳球同樣的boost :: ASIO ::流緩衝到多個寫入調用。

boost::asio::write(socket_, request_information, write_ec); 

緩衝區的內容第一次調用消耗的boost ::支持ASIO ::寫。這有效地清空了緩衝區，因此沒有什麼需要發送的。如果要爲多次寫入使用相同的緩衝區，則傳遞一個常量字符串。