httpclient.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <promeki/namespace.h>
#include <promeki/objectbase.h>
#include <promeki/error.h>
#include <promeki/string.h>
#include <promeki/buffer.h>
#include <promeki/url.h>
#include <promeki/list.h>
#include <promeki/sharedptr.h>
#include <promeki/future.h>
#include <promeki/httprequest.h>
#include <promeki/httpresponse.h>
#include <promeki/httpheaders.h>
#include <promeki/sslcontext.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class EventLoop;
 
class HttpClient : public ObjectBase {
                PROMEKI_OBJECT(HttpClient, ObjectBase)
        public:
                static constexpr unsigned int DefaultTimeoutMs = 30'000;
 
                static constexpr int64_t DefaultMaxBodyBytes = 64 * 1024 * 1024;
 
                static constexpr int DefaultMaxRedirects = 10;
 
                explicit HttpClient(ObjectBase *parent = nullptr);
 
                ~HttpClient() override;
 
                Future<HttpResponse> send(const HttpRequest &request);
 
                Future<HttpResponse> get(const String &url);
 
                Future<HttpResponse> post(const String &url, const Buffer &body,
                                          const String &contentType = String("application/octet-stream"));
 
                Future<HttpResponse> put(const String &url, const Buffer &body,
                                         const String &contentType = String("application/octet-stream"));
 
                Future<HttpResponse> del(const String &url);
 
                // ----------------------------------------------------
                // Defaults applied to every request
                // ----------------------------------------------------
 
                void setDefaultHeader(const String &name, const String &value);
 
                void removeDefaultHeader(const String &name);
 
                const HttpHeaders &defaultHeaders() const { return _defaultHeaders; }
 
                void setBaseUrl(const Url &url) { _baseUrl = url; }
 
                const Url &baseUrl() const { return _baseUrl; }
 
                void setTimeoutMs(unsigned int ms) { _timeoutMs = ms; }
 
                void setMaxBodyBytes(int64_t bytes) { _maxBodyBytes = bytes; }
 
                void setMaxRedirects(int max) { _maxRedirects = max; }
 
                int  maxRedirects() const { return _maxRedirects; }
 
                void setSslContext(SslContext ctx) { _sslContext = std::move(ctx); }
 
                SslContext sslContext() const { return _sslContext; }
 
                static bool hasTlsSupport() { return SslContext::hasTlsSupport(); }
 
                PROMEKI_SIGNAL(requestFinished, HttpRequest, HttpResponse);
 
                PROMEKI_SIGNAL(errorOccurred, Error);
 
        private:
                struct Pending;
                using PendingPtr = SharedPtr<Pending, false>;
 
                EventLoop       *_loop = nullptr;
                HttpHeaders      _defaultHeaders;
                Url              _baseUrl;
                unsigned int     _timeoutMs = DefaultTimeoutMs;
                int64_t          _maxBodyBytes = DefaultMaxBodyBytes;
                int              _maxRedirects = DefaultMaxRedirects;
                List<PendingPtr> _active;
                SslContext  _sslContext;
 
                Future<HttpResponse> dispatch(HttpRequest request);
                void                 resolveTargetUrl(HttpRequest &request) const;
                void                 applyDefaultHeaders(HttpRequest &request) const;
                void                 retire(const PendingPtr &p);
 
                // The per-request state machine lives in the cpp;
                // it needs to reach back into _active and emit signals.
                friend struct Pending;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_HTTP