http_client.hpp

Go to the documentation of this file.

 
#ifndef JOIN_SERVICES_HTTP_CLIENT_HPP
#define JOIN_SERVICES_HTTP_CLIENT_HPP
 
// libjoin.
#include <join/socket_stream.hpp>
#include <join/http_protocol.hpp>
#include <join/http_message.hpp>
#include <join/chunk_stream.hpp>
#include <join/tls_stream.hpp>
#include <join/resolver.hpp>
#include <join/zstream.hpp>
#include <join/version.hpp>
 
// C++.
#include <chrono>
 
namespace join
{
    template <class Protocol>
    class BasicHttpClient : public Protocol::Stream
    {
    public:
        using Endpoint = typename Protocol::Endpoint;
 
        BasicHttpClient (const char* host, uint16_t port = Protocol::defaultPort, bool keepAlive = true)
        : _host (host)
        , _port (port)
        , _keep (keepAlive)
        , _keepTimeout (std::chrono::seconds::zero ())
        {
        }
 
        BasicHttpClient (const std::string& host, uint16_t port = Protocol::defaultPort, bool keepAlive = true)
        : BasicHttpClient (host.c_str (), port, keepAlive)
        {
        }
 
        BasicHttpClient (const BasicHttpClient& other) = delete;
 
        BasicHttpClient& operator= (const BasicHttpClient& other) = delete;
 
        BasicHttpClient (BasicHttpClient&& other)
        : Protocol::Stream (std::move (other))
        , _host (std::move (other._host))
        , _port (other._port)
        , _keep (other._keep)
        , _keepTimeout (other._keepTimeout)
        , _keepMax (other._keepMax)
        {
        }
 
        BasicHttpClient& operator= (BasicHttpClient&& other)
        {
            Protocol::Stream::operator= (std::move (other));
            this->_host = std::move (other._host);
            this->_port = other._port;
            this->_keep = other._keep;
            this->_keepTimeout = other._keepTimeout;
            this->_keepMax = other._keepMax;
            return *this;
        }
 
        virtual ~BasicHttpClient ()
        {
            clearEncoding ();
        }
 
        void close () override
        {
            Protocol::Stream::close ();
            this->_keepTimeout = std::chrono::seconds::zero ();
            this->_keepMax = -1;
        }
 
        virtual std::string scheme () const
        {
            return "http";
        }
 
        const std::string& host () const
        {
            return this->_host;
        }
 
        uint16_t port () const
        {
            return this->_port;
        }
 
        std::string authority () const
        {
            std::string auth;
 
            if (IpAddress::isIpv6Address (this->host ()))
            {
                auth += "[" + this->host () + "]";
            }
            else
            {
                auth += this->host ();
            }
 
            if (this->port () != Dns::Resolver::resolveService (this->scheme ()))
            {
                auth += ":" + std::to_string (this->port ());
            }
 
            return auth;
        }
 
        std::string url () const
        {
            return this->scheme () + "://" + this->authority () + "/";
        }
 
        bool keepAlive () const
        {
            return this->_keep;
        }
 
        void keepAlive (bool keep)
        {
            this->_keep = keep;
        }
 
        std::chrono::seconds keepAliveTimeout () const
        {
            return this->_keepTimeout;
        }
 
        int keepAliveMax () const
        {
            return this->_keepMax;
        }
 
        int send (HttpRequest& request)
        {
            // restore concrete stream.
            clearEncoding ();
 
            // check if reconnection is required.
            if (this->needReconnection ())
            {
                Endpoint endpoint{Dns::Resolver::lookupAddress (this->host ()), this->port ()};
                endpoint.hostname (this->host ());
 
                this->reconnect (endpoint);
                if (this->fail ())
                {
                    return -1;
                }
            }
 
            // set missing request headers.
            if (!request.hasHeader ("Accept"))
            {
                request.header ("Accept", "*/*");
            }
            if (!request.hasHeader ("Connection"))
            {
                request.header ("Connection", this->_keep ? "keep-alive" : "close");
            }
            if (!request.hasHeader ("Host"))
            {
                request.header ("Host", this->authority ());
            }
            if (!request.hasHeader ("User-Agent"))
            {
                request.header ("User-Agent", "join/" JOIN_VERSION);
            }
 
            // write request headers.
            if (request.writeHeaders (*this) == -1)
            {
                return -1;
            }
 
            // flush request headers.
            this->flush ();
 
            // set encoding.
            if (request.hasHeader ("Transfer-Encoding"))
            {
                this->setEncoding (join::rsplit (request.header ("Transfer-Encoding"), ","));
            }
            if (request.hasHeader ("Content-Encoding"))
            {
                this->setEncoding (join::rsplit (request.header ("Content-Encoding"), ","));
            }
 
            return 0;
        }
 
        int receive (HttpResponse& response)
        {
            // restore concrete stream.
            this->clearEncoding ();
 
            // read response headers.
            if (response.readHeaders (*this) == -1)
            {
                return -1;
            }
 
            // get connection.
            std::string connection = response.header ("Connection");
            std::string alive = response.header ("Keep-Alive");
 
            // check connection.
            if (join::compareNoCase (connection, "keep-alive"))
            {
                size_t pos = alive.find ("timeout=");
                if (pos != std::string::npos)
                {
                    this->_keepTimeout =
                        std::chrono::seconds (::atoi (alive.substr (pos + 8, alive.find (",", pos + 8)).c_str ()));
                }
 
                pos = alive.find ("max=");
                if (pos != std::string::npos)
                {
                    this->_keepMax = ::atoi (alive.substr (pos + 4, alive.find (",", pos + 4)).c_str ());
                }
            }
            else if (join::compareNoCase (connection, "close"))
            {
                this->_keepTimeout = std::chrono::seconds::zero ();
                this->_keepMax = 0;
            }
 
            // set encoding.
            if (response.hasHeader ("Transfer-Encoding"))
            {
                this->setEncoding (join::rsplit (response.header ("Transfer-Encoding"), ","));
            }
            if (response.hasHeader ("Content-Encoding"))
            {
                this->setEncoding (join::rsplit (response.header ("Content-Encoding"), ","));
            }
 
            // get timestamp.
            this->_timestamp = std::chrono::steady_clock::now ();
 
            return 0;
        }
 
    protected:
        void setEncoding (const std::vector<std::string>& encodings)
        {
            for (auto const& encoding : encodings)
            {
                if (encoding.find ("gzip") != std::string::npos)
                {
                    this->_streambuf = new Zstreambuf (this->_streambuf, Zstream::Gzip, this->_wrapped);
                    this->_wrapped = true;
                }
                else if (encoding.find ("deflate") != std::string::npos)
                {
                    this->_streambuf = new Zstreambuf (this->_streambuf, Zstream::Deflate, this->_wrapped);
                    this->_wrapped = true;
                }
                else if (encoding.find ("chunked") != std::string::npos)
                {
                    this->_streambuf = new Chunkstreambuf (this->_streambuf, this->_wrapped);
                    this->_wrapped = true;
                }
            }
 
            this->set_rdbuf (this->_streambuf);
        }
 
        void clearEncoding ()
        {
            if (this->_wrapped && this->_streambuf)
            {
                delete this->_streambuf;
                this->_streambuf = nullptr;
            }
 
            this->_streambuf = &this->_sockbuf;
            this->_wrapped = false;
 
            this->set_rdbuf (this->_streambuf);
        }
 
        bool expired () const
        {
            auto duration = std::chrono::steady_clock::now () - this->_timestamp;
            return (this->_keepTimeout < std::chrono::duration_cast<std::chrono::seconds> (duration)) ||
                   (this->_keepMax == 0);
        }
 
        bool needReconnection ()
        {
            return !this->connected () || this->expired ();
        }
 
        virtual void reconnect (const Endpoint& endpoint)
        {
            this->disconnect ();
            this->close ();
            this->connect (endpoint);
        }
 
        std::streambuf* _streambuf = nullptr;
 
        bool _wrapped = false;
 
        std::chrono::time_point<std::chrono::steady_clock> _timestamp;
 
        std::string _host;
 
        uint16_t _port;
 
        bool _keep;
 
        std::chrono::seconds _keepTimeout;
 
        int _keepMax = -1;
    };
 
    template <class Protocol>
    constexpr BasicHttpClient<Protocol>& operator<< (BasicHttpClient<Protocol>& out, HttpRequest& request)
    {
        out.send (request);
        return out;
    }
 
    template <class Protocol>
    constexpr BasicHttpClient<Protocol>& operator>> (BasicHttpClient<Protocol>& in, HttpResponse& response)
    {
        in.receive (response);
        return in;
    }
 
    template <class Protocol>
    class BasicHttpSecureClient : public BasicHttpClient<Protocol>
    {
    public:
        using Endpoint = typename Protocol::Endpoint;
        using Stream = typename Protocol::Stream;
 
        BasicHttpSecureClient (TlsContext ctx, const char* host, uint16_t port = Protocol::defaultPort,
                               bool keepAlive = true)
        : BasicHttpClient<Protocol> (host, port, keepAlive)
        {
            static_cast<Stream&> (*this) = Stream (std::move (ctx));
        }
 
        BasicHttpSecureClient (TlsContext ctx, const std::string& host, uint16_t port = Protocol::defaultPort,
                               bool keepAlive = true)
        : BasicHttpSecureClient (std::move (ctx), host.c_str (), port, keepAlive)
        {
        }
 
        BasicHttpSecureClient (const BasicHttpSecureClient& other) = delete;
 
        BasicHttpSecureClient& operator= (const BasicHttpSecureClient& other) = delete;
 
        BasicHttpSecureClient (BasicHttpSecureClient&& other)
        : BasicHttpClient<Protocol> (std::move (other))
        {
        }
 
        BasicHttpSecureClient& operator= (BasicHttpSecureClient&& other)
        {
            BasicHttpClient<Protocol>::operator= (std::move (other));
            return *this;
        }
 
        virtual ~BasicHttpSecureClient () = default;
 
        std::string scheme () const override
        {
            return "https";
        }
 
    protected:
        void reconnect (const Endpoint& endpoint) override
        {
            this->disconnect ();
            this->close ();
            this->connect (endpoint);
            if (!this->fail ())
            {
                this->handshake ();
            }
        }
    };
 
    template <class Protocol>
    constexpr BasicHttpSecureClient<Protocol>& operator<< (BasicHttpSecureClient<Protocol>& out, HttpRequest& request)
    {
        out.send (request);
        return out;
    }
 
    template <class Protocol>
    constexpr BasicHttpSecureClient<Protocol>& operator>> (BasicHttpSecureClient<Protocol>& in, HttpResponse& response)
    {
        in.receive (response);
        return in;
    }
}
 
#endif