client.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <memory>
#include <cstdint>
#include <stdexcept>
#include <vector>
#include <utility>
#include <initializer_list>
#include <type_traits>
 
 
// Forward cpr::Response existence.
namespace cpr {
    class Response;
}
 
 
namespace elasticlient {
 
 
class ConnectionException: public std::runtime_error {
  public:
    explicit ConnectionException(const std::string &message) : std::runtime_error(message) {}
};
 
 
class Client {
    class Implementation;
    std::unique_ptr<Implementation> impl;
 
  public:
    enum class HTTPMethod {
        GET     = 0,
        POST    = 1,
        PUT     = 2,
        DELETE  = 3,
        HEAD    = 4
    };
 
    struct ClientOption {
        virtual ~ClientOption() {}
        virtual void accept(Implementation &) const = 0;
    };
 
    template <typename T>
    struct ClientOptionValue: public ClientOption {
        T value;
 
        explicit ClientOptionValue(const T& value): value(value) {}
        explicit ClientOptionValue(T&& value): value(std::move(value)) {}
        ClientOptionValue(ClientOptionValue &&) = default;
        virtual ~ClientOptionValue() = default;
 
        T getValue() const {
            return value;
        }
    };
 
    struct TimeoutOption: public ClientOptionValue<std::int32_t> {
        explicit TimeoutOption(std::int32_t timeoutMs)
            : ClientOptionValue(timeoutMs) {}
      protected:
        void accept(Implementation &) const override;
    };
 
    struct ConnectTimeoutOption: public ClientOptionValue<std::int32_t> {
        explicit ConnectTimeoutOption(std::int32_t timeoutMs)
            : ClientOptionValue(timeoutMs) {}
      protected:
        void accept(Implementation &) const override;
    };
 
    struct ProxiesOption: public ClientOption {
        class ProxiesOptionImplementation;
        std::unique_ptr<ProxiesOptionImplementation> impl;
 
        explicit ProxiesOption(
                const std::initializer_list<std::pair<const std::string, std::string>> &proxies);
        ~ProxiesOption();
      protected:
        void accept(Implementation &) const override;
    };
 
    struct SSLOption: public ClientOption {
        class SSLOptionImplementation;
        std::unique_ptr<SSLOptionImplementation> impl;
 
        SSLOption();
        SSLOption(SSLOption &&);
        ~SSLOption();
 
        template <typename... T>
        SSLOption(T... args): SSLOption() {
            optSetter(std::move(args)...);
        }
 
        struct SSLOptionType {
            virtual ~SSLOptionType() {}
            virtual void accept(SSLOptionImplementation &) const = 0;
        };
 
        struct CertFile: public SSLOptionType {
            explicit CertFile(std::string path): path(std::move(path)) {}
            void accept(SSLOptionImplementation &) const override;
            std::string path;
        };
 
        struct KeyFile: public SSLOptionType {
            explicit KeyFile(std::string path, std::string password = {})
                : path(std::move(path)), password(std::move(password))
            {}
            void accept(SSLOptionImplementation &) const override;
            std::string path;
            std::string password;
        };
 
        struct CaInfo: public SSLOptionType {
            explicit CaInfo(std::string path): path(std::move(path)) {}
            void accept(SSLOptionImplementation &) const override;
            std::string path;
        };
 
        struct VerifyHost: public SSLOptionType {
            explicit VerifyHost(bool verify): verify(verify) {}
            void accept(SSLOptionImplementation &) const override;
            bool verify;
        };
 
        struct VerifyPeer: public SSLOptionType {
            explicit VerifyPeer(bool verify): verify(verify) {}
            void accept(SSLOptionImplementation &) const override;
            bool verify;
        };
 
        void setSslOption(const SSLOptionType &);
 
      protected:
        void accept(Implementation &) const override;
 
        template <typename T>
        void optSetter(T&& t) {
            static_assert(std::is_base_of<SSLOptionType, T>::value,
                          "Record must be derived from SSLOptionType");
            setSslOption(std::forward<T>(t));
        }
 
        template<typename T, typename... TRest>
        void optSetter(T&& t, TRest&&... ts) {
            static_assert(std::is_base_of<SSLOptionType, T>::value,
                          "Record must be derived from SSLOptionType");
            optSetter(std::forward<T>(t));
            optSetter(std::move(ts)...);
        }
    };
 
 
    explicit Client(const std::vector<std::string> &hostUrlList,
                    std::int32_t timeout = 6000);
 
    explicit Client(
        const std::vector<std::string> &hostUrlList,
        std::int32_t timeout,
        const std::initializer_list<std::pair<const std::string, std::string>>& proxyUrlList);
 
    template <typename... Opts>
    Client(const std::vector<std::string> &hostUrlList,
           Opts&&... opts)
        : Client(hostUrlList)
    {
        optionConstructHelper(std::move(opts)...);
    }
 
    Client(Client &&);
 
    ~Client();
 
    void setClientOption(const ClientOption &opt);
 
    cpr::Response performRequest(HTTPMethod method,
                                 const std::string &urlPath,
                                 const std::string &body);
 
    cpr::Response search(const std::string &indexName,
                         const std::string &docType,
                         const std::string &body,
                         const std::string &routing = std::string());
 
    cpr::Response get(const std::string &indexName,
                      const std::string &docType,
                      const std::string &id = std::string(),
                      const std::string &routing = std::string());
 
    cpr::Response index(const std::string &indexName,
                        const std::string &docType,
                        const std::string &id,
                        const std::string &body,
                        const std::string &routing = std::string());
 
    cpr::Response remove(const std::string &indexName,
                         const std::string &docType,
                         const std::string &id,
                         const std::string &routing = std::string());
  private:
    template <typename T>
    void optionConstructHelper(T&& opt) {
        static_assert(std::is_base_of<ClientOption, T>::value,
                      "Record must be derived from ClientOption");
        setClientOption(std::forward<T>(opt));
    }
 
    template <typename T, typename... TRest>
    void optionConstructHelper(T&& opt, TRest&&... rest) {
        static_assert(std::is_base_of<ClientOption, T>::value,
                      "Record must be derived from ClientOption");
        optionConstructHelper(std::forward<T>(opt));
        optionConstructHelper(std::move(rest)...);
    }
};
 
 
} // namespace elasticlient