HTTP Client Request Response with pion-net c++

I want to create a simple HTTPClient with pion-net (Pion-net leverages boost::asio.).
Boot Version 1.49 Pion-net Version 4.11

My client should just be a able to:

send a HTTP Request (this is working)
receive the HTTP Response (not working)
asynchronous code is not a must, synchronous would be ok

This is what I got:

#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;
}

If you want to communicate synchronously you could do something like this:

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);
            }
        }
    }
}

if however you need a little more sophisticated approach you could pion::net::HTTPResponseReader to wait asynch for a server response.
header:

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;
}

Martin's code updated for 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;
}

for 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;
}

I am not familiar with pion-net. However, based on the version I think is being used per the naming conventions, a quick scan through the pion-net code looks as though the io_service.run() needs to be invoked in the application code. The only place where I found pion-net explicitly invoking io_service.run() was in the PionScheduler types used by the Server types.

来源：https://stackoverflow.com/questions/14601100/http-client-request-response-with-pion-net-c

标签

c++

http

boost-asio

pion-net