与π介子，C网HTTP客户端请求响应++(HTTP Client Request Response

我想创建一个简单了HTTPClient 介子网 （π介子的净杠杆提高:: ASIO）。
引导版本1.49介子网版4.11

我的客户应该只是一个能够：

• 发送一个HTTP请求（这是工作）
• 收到HTTP响应（不工作）
• 异步代码是不是必须的，同步将确定

这是我得到了什么：

#include <iostream>
#include "boost/asio.hpp"
#include "boost/thread.hpp"
#include "pion/net/HTTPRequestWriter.hpp"
#include "pion/net/HTTPResponseReader.hpp"


void FinishedResponseReading(pion::net::HTTPResponsePtr httpResponsePtr,
                             pion::net::TCPConnectionPtr tcpConnectionPtr,
                             const boost::system::error_code& errorCode_ref)
{
    // ***************************
    // this code is never reached!
    // ***************************
    std::cout << errorCode_ref << std::endl;
    std::cout << httpResponsePtr->getContent() << std::endl;

    tcpConnectionPtr->finish();
    tcpConnectionPtr->close();
}


void FinishedRequestSending(const boost::system::error_code& error_code_ref,
                            pion::net::TCPConnectionPtr tcpConnectionPtr,
                            pion::net::HTTPRequest* httpRequest_ptr)
{
    // ***************************
    // this code is never reached!
    // ***************************
    pion::net::HTTPResponseReader::FinishedHandler fh =
        boost::bind(FinishedResponseReading, _1, _2, _3);
    pion::net::HTTPResponseReaderPtr httpResponseReaderPtr =
        pion::net::HTTPResponseReader::create(tcpConnectionPtr,
                                              *httpRequest_ptr,
                                              fh);
    httpResponseReaderPtr->receive();
}


int main()
{
    boost::asio::io_service io_service;

    // create and configure HTTPRequest
    pion::net::HTTPRequest* httpRequest_ptr = new pion::net::HTTPRequest();
    pion::net::HTTPRequestPtr httpRequestPtr(httpRequest_ptr);
    httpRequest_ptr->setResource("/someService");
    httpRequest_ptr->setMethod("PUT");

    // create TCPConnection
    pion::net::TCPConnection* tcpConnection_ptr =
        new pion::net::TCPConnection(io_service);
    pion::net::TCPConnectionPtr tcpConnectionPtr(tcpConnection_ptr);

    // create HTTPRequestWriter
    pion::net::HTTPRequestWriterPtr httpRequestWriterPtr(
        pion::net::HTTPRequestWriter::create(tcpConnectionPtr,
                                             httpRequestPtr,
                                             boost::bind(FinishedRequestSending, _1,
                                                         tcpConnectionPtr, 
                                                         httpRequest_ptr)));
    // needed?
    tcpConnection_ptr->setLifecycle(pion::net::TCPConnection::LIFECYCLE_KEEPALIVE);
    // connect to server
    tcpConnection_ptr->connect("192.168.1.14", 8080);
    // send payload
    httpRequestWriterPtr << "{\"someService\": \"something\"}";
    httpRequestWriterPtr->send();

    // ***********************************
    // working fine so far! server is getting payload and is sending a HTTP Response
    // but FinishedRequestSending is never reached
    // ***********************************

    // this is just to not exit immediately
    boost::this_thread::sleep(boost::posix_time::milliseconds(15000));

    // cleanup
    delete(httpRequest_ptr);
    delete(tcpConnection_ptr);

    return 0;
}

Answer 1:

如果你想同步沟通，你可以做这样的事情：

int main()
{
    boost::asio::io_service io_service
    pion::net::TCPConnection tcpConnection(io_service);

    pion::net::HTTPRequest httpRequest;
    httpRequest.setResource("/server/resource");
    httpRequest.setMethod("PUT");
    httpRequest.setMinor(1);
    httpRequest.setMajor(1);
    httpRequest.setContent("test");

    boost::system::error_code ec;
    ec = tcpConnection.connect("192.168.1.1", 80); // blocks till connected or timed out
    if (!ec)
    {
        httpRequest.send(tcpConnection, ec); // never blocks
        if (!ec)
        {
            pion::net::HTTPResponse(httpRequest);
            httpResponse.receive(tcpConnection, ec); // this might block forever :-(
            // httpResponse.receive seems to be IO dependent, you can set your socket to timeout
            if (!ec)
            {
                httpResponse.write(std::cout, ec);
            }
        }
    }
}

---

然而，如果你需要一些更复杂的方法，你可以pion::net::HTTPResponseReader等非同步服务器响应。
标题：

class MyHTTPClient {
public:
    void close();
    pion::net::HTTPResponsePtr blockingReceiveOrTimeout(pion::net::HTTPRequest httpRequest, boost::system::error_code& ec_ref);
    MyHTTPClient(boost::asio::ip::address aServerIP, unsigned int aServerPort);
    virtual ~MyHTTPClient();
private:
    boost::asio::ip::address            mp_serverIP;
    unsigned int                    mp_serverPort;
    boost::asio::io_service             mp_ioService;
    pion::net::TCPConnectionPtr         mp_tcpConnectionPtr;
    pion::net::HTTPResponsePtr          mp_curr_httpResponsePtr;
    boost::system::error_code           mp_curr_errorCode;

    void finishedReceiveResponse(pion::net::HTTPResponsePtr httpResponsePtr, const boost::system::error_code& error_code_ref);

};

CPP：

MyHTTPClient::MyHTTPClient(boost::asio::ip::address aServerIP, unsigned int aServerPort) : mp_serverIP(aServerIP), mp_serverPort(aServerPort)
{
    mp_tcpConnectionPtr.reset(new pion::net::TCPConnection(mp_ioService));
    mp_tcpConnectionPtr->setLifecycle(pion::net::TCPConnection::LIFECYCLE_KEEPALIVE);
}

MyHTTPClient::~MyHTTPClient()
{
     mp_tcpConnectionPtr->close();
}

void MyHTTPClient::close()
{
    mp_tcpConnectionPtr->close();
}

pion::net::HTTPResponsePtr MyHTTPClient::blockingReceiveOrTimeout(pion::net::HTTPRequest httpRequest, boost::system::error_code& error_code_ref)
{
    // reinit
    mp_curr_httpResponsePtr.reset();
    mp_ioService.reset();
    error_code_ref.clear();

    // connect to server if not already connectec
    if (!mp_tcpConnectionPtr->is_open())
    {
        error_code_ref = mp_tcpConnectionPtr->connect(mp_serverIP, mp_serverPort);
    }
    if (!error_code_ref)
    {
        // send Request
        httpRequest.send(*mp_tcpConnectionPtr.get(), error_code_ref, false);

        if (!error_code_ref)
        {
            // asynchronously wait for response (times out automatically)
            pion::net::HTTPResponseReader::FinishedHandler responseReaderFinishHandler = boost::bind(&MyHTTPClient::finishedReceiveResponse, this, _1, _3);
            const pion::net::HTTPRequest constHTTPRequest = httpRequest;
            pion::net::HTTPResponseReaderPtr httpResponseReaderPtr = pion::net::HTTPResponseReader::create(
                    mp_tcpConnectionPtr,
                    constHTTPRequest,
                    responseReaderFinishHandler);
             httpResponseReaderPtr->receive();
             mp_ioService.run();
        }
    }
    return mp_curr_httpResponsePtr;
}

void MyHTTPClient::finishedReceiveResponse(pion::net::HTTPResponsePtr httpResponsePtr, const boost::system::error_code& error_code_ref)
{
    mp_curr_httpResponsePtr = httpResponsePtr;
}

Answer 2:

马丁的代码更新的PION 5.0.3：

httpClient.hpp：

#ifndef httpClient_HPP_INCLUDED
#define httpClient_HPP_INCLUDED

#include <pion/error.hpp>
#include <pion/http/response.hpp>
#include <pion/tcp/connection.hpp>
#include <pion/http/response_reader.hpp>
#include <boost/asio.hpp>

class httpClient
{
public:
    void close();
    pion::http::response_ptr blockingReceiveOrTimeout(pion::http::request httpRequest, boost::system::error_code& ec_ref);
    httpClient(boost::asio::ip::address aServerIP, unsigned int aServerPort);
    virtual ~httpClient();

private:
    boost::asio::ip::address mp_serverIP;
    unsigned int mp_serverPort;
    boost::asio::io_service mp_ioService;
    pion::tcp::connection_ptr mp_tcpConnectionPtr;
    pion::http::response_ptr mp_curr_httpResponsePtr;
    boost::system::error_code mp_curr_errorCode;

    void finishedReceiveResponse(pion::http::response_ptr httpResponsePtr, const boost::system::error_code& error_code_ref);

};

#endif // httpClient_HPP_INCLUDED

httpClient.cpp：

#include "httpClient.hpp"

httpClient::httpClient(boost::asio::ip::address aServerIP, unsigned int aServerPort) : mp_serverIP(aServerIP), mp_serverPort(aServerPort)
{
    mp_tcpConnectionPtr.reset(new pion::tcp::connection(mp_ioService));
    mp_tcpConnectionPtr->set_lifecycle(pion::tcp::connection::LIFECYCLE_KEEPALIVE);
}

httpClient::~httpClient()
{
     mp_tcpConnectionPtr->close();
}

void httpClient::close()
{
    mp_tcpConnectionPtr->close();
}

pion::http::response_ptr httpClient::blockingReceiveOrTimeout(pion::http::request httpRequest, boost::system::error_code& error_code_ref)
{
    // reinit
    mp_curr_httpResponsePtr.reset();
    mp_ioService.reset();
    error_code_ref.clear();

    // connect to server if not already connectec
    if (!mp_tcpConnectionPtr->is_open())
    {
        error_code_ref = mp_tcpConnectionPtr->connect(mp_serverIP, mp_serverPort);
    }
    if (!error_code_ref)
    {
        // send Request
        httpRequest.send(*mp_tcpConnectionPtr.get(), error_code_ref, false);

        if (!error_code_ref)
        {
            // asynchronously wait for response (times out automatically)
            pion::http::response_reader::finished_handler_t responseReaderFinishHandler = boost::bind(&httpClient::finishedReceiveResponse, this, _1, _3);
            const pion::http::request constHTTPRequest = httpRequest;
            pion::http::response_reader_ptr httpResponseReaderPtr = pion::http::response_reader::create(
                    mp_tcpConnectionPtr,
                    constHTTPRequest,
                    responseReaderFinishHandler);
             httpResponseReaderPtr->receive();
             mp_ioService.run();
        }
    }
    return mp_curr_httpResponsePtr;
}

void httpClient::finishedReceiveResponse(pion::http::response_ptr httpResponsePtr, const boost::system::error_code& error_code_ref)
{
    mp_curr_httpResponsePtr = httpResponsePtr;
}

对于completness main.cpp中：

#include <iostream>
#include "httpClient.hpp"

int main (int argc, char *argv[])
{
    pion::http::request request;
    std::string requestData = "asdf";
    request.set_content(requestData);
    httpClient client(boost::asio::ip::address::from_string("10.1.1.100"), 80);
    pion::http::response_ptr response;
    boost::system::error_code ec;
    response = client.blockingReceiveOrTimeout(request, ec);
    response->write(std::cout, ec);
    return 0;
}

Answer 3:

我不熟悉介子网。 然而，基于该版本我认为是按每命名约定被使用，通过π介子网码快速扫描看起来好像io_service.run()需要在应用程序代码中被调用。 在那里我发现介子网明确调用的唯一的地方io_service.run()是在PionScheduler由所使用的类型的Server类型。

文章来源: HTTP Client Request Response with pion-net c++