HTTPClient.h

Go to the documentation of this file.

 
#ifndef SUPPORTLIB_HTTPCLIENT_H
#define SUPPORTLIB_HTTPCLIENT_H
#include "Object.h"
#include "Blob.h"
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/asio/connect.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <iostream>
#include <string>
#include <map>
 
namespace giri {
    namespace ssl = boost::asio::ssl;
    namespace http = boost::beast::http;
 
    class HTTPClient : public Object<HTTPClient> {
        using tcp = boost::asio::ip::tcp; 
    public:
        enum class Version : size_t {
            v_10 = 10,
            v_11 = 11
        };
        HTTPClient(bool ssl = false, 
                   HTTPClient::Version version = HTTPClient::Version::v_11,
                   const std::string& userAgent = "giris_supportlib_http_client",
                   const std::string& contentType = "application/x-www-form-urlencoded",
                   const std::map<std::string, std::string>& customHead = {}
                   ) : 
                   m_SSL(ssl), 
                   m_Version(version),
                   m_UserAgent(userAgent),
                   m_ContentType(contentType),
                   m_CustomHead(customHead){}
        
        void setUserAgentString(const std::string & userAgent) {
            m_UserAgent = userAgent;
        }
        void setContentType(const std::string & contentType) {
            m_ContentType = contentType;
        }
        void setVersion(const HTTPClient::Version v) {
            m_Version = v;
        }
        void setSSL(bool ssl){
            m_SSL = ssl;
        }
        void setCustomHead(std::map<std::string, std::string> customHead){
            m_CustomHead = customHead;
        }
 
        std::string getUserAgentString() const {
            return m_UserAgent;
        }
        std::string getContentType() const {
            return m_ContentType;
        }
        HTTPClient::Version getVersion() const {
            return m_Version;
        }
        bool getSSL() const {
            return m_SSL;
        }
        boost::system::error_code getError() const {
            return m_Ec;
        }
        std::map<std::string, std::string> getCustomHead() const {
            return m_CustomHead;
        }
 
        std::vector<char> HTTPGet(const std::string & host, const std::string& port, const std::string &target = "/")
        {
            http::request<http::string_body> req{http::verb::get, target, (size_t)m_Version};
            req.set(http::field::host, host);
            req.set(http::field::user_agent, m_UserAgent);
 
            for(const auto& curHead : m_CustomHead)
                req.set(curHead.first, curHead.second);
 
            performRequest(host, port, req);
            std::ostringstream ostr;
            ostr << boost::beast::buffers_to_string(m_Res.body().data()); std::string s = ostr.str();
            return std::vector<char>(s.begin(), s.end());
        }
 
        std::vector<char> HTTPDelete(const std::string & host, const std::string& port, const std::string &target = "/")
        {
            http::request<http::string_body> req{http::verb::delete_, target, (size_t)m_Version};
            req.set(http::field::host, host);
            req.set(http::field::user_agent, m_UserAgent);
 
            for(const auto& curHead : m_CustomHead)
                req.set(curHead.first, curHead.second);
 
            performRequest(host, port, req);
            std::ostringstream ostr;
            ostr << boost::beast::buffers_to_string(m_Res.body().data()); std::string s = ostr.str();
            return std::vector<char>(s.begin(), s.end());
        }
 
        std::vector<char> HTTPPost(const std::string & host, const std::string& port, const std::string &target, const std::vector<char>& data)
        {
            http::request<http::string_body> req{http::verb::post, target, (size_t)m_Version};
            req.set(http::field::host, host);
            req.set(http::field::user_agent, m_UserAgent);
            req.set(http::field::content_type, m_ContentType);
 
            for(const auto& curHead : m_CustomHead)
                req.set(curHead.first, curHead.second);
 
            req.body() = std::string(data.begin(), data.end());
            req.prepare_payload();
            performRequest(host, port, req);
            std::ostringstream ostr;
            ostr << boost::beast::buffers_to_string(m_Res.body().data()); std::string s = ostr.str();
            return std::vector<char>(s.begin(), s.end());
        }
 
        std::vector<char> HTTPPost(const std::string & host, const std::string& port, const std::string &target, const Blob& data)
        {
            std::vector<char> dat;
            dat.reserve(data.size());
            dat.assign(data.begin(), data.end());
            return HTTPPost(host, port, target, dat);
        }
 
        std::vector<char> HTTPPut(const std::string & host, const std::string& port, const std::string &target, const std::vector<char>& data)
        {
            http::request<http::string_body> req{http::verb::put, target, (size_t)m_Version};
            req.set(http::field::host, host);
            req.set(http::field::user_agent, m_UserAgent);
            req.set(http::field::content_type, m_ContentType);
 
            for(const auto& curHead : m_CustomHead)
                req.set(curHead.first, curHead.second);
 
            req.body() = std::string(data.begin(), data.end());
            req.prepare_payload();
            performRequest(host, port, req);
            std::ostringstream ostr;
            ostr << boost::beast::buffers_to_string(m_Res.body().data()); std::string s = ostr.str();
            return std::vector<char>(s.begin(), s.end());
        }
 
        std::vector<char> HTTPPut(const std::string & host, const std::string& port, const std::string &target, const Blob& data)
        {
            std::vector<char> dat;
            dat.reserve(data.size());
            dat.assign(data.begin(), data.end());
            return HTTPPut(host, port, target, dat);
        }
 
    private:
        void performRequest(const std::string& host, const std::string& port, const http::request<http::string_body>& req)
        {
            tcp::resolver resolver{m_Ioc};
            auto const results = resolver.resolve(host, port);
            if(m_SSL){
                ssl::stream<tcp::socket> stream{m_Ioc, m_Ctx};
                boost::asio::connect(stream.next_layer(), results.begin(), results.end());
                stream.handshake(ssl::stream_base::client);
                http::write(stream, req);
                http::read(stream, m_Buffer, m_Res);
                stream.shutdown(m_Ec);
            }
            else{
                tcp::socket stream{m_Ioc};
                boost::asio::connect(stream, results.begin(), results.end());
                http::write(stream, req);
                http::read(stream, m_Buffer, m_Res);
                stream.shutdown(tcp::socket::shutdown_both, m_Ec);
            }
        }
        bool m_SSL;
        HTTPClient::Version m_Version;
        std::string m_UserAgent;
        std::string m_ContentType;
        ssl::context m_Ctx{ssl::context::sslv23_client};
        boost::asio::io_context m_Ioc;
        boost::system::error_code m_Ec;
        boost::beast::flat_buffer m_Buffer;
        http::response<http::dynamic_body> m_Res;
        std::map<std::string, std::string> m_CustomHead;
    };
}
#endif //SUPPORTLIB_HTTPCLIENT_H