diff options
author | bubnikv <bubnikv@gmail.com> | 2018-09-19 12:02:24 +0300 |
---|---|---|
committer | bubnikv <bubnikv@gmail.com> | 2018-09-19 12:02:24 +0300 |
commit | 0558b53493a77bae44831cf87bb0f59359828ef5 (patch) | |
tree | c3e8dbdf7d91a051c12d9ebbf7606d41047fea96 /src/slic3r/Utils/Http.hpp | |
parent | 3ddaccb6410478ad02d8c0e02d6d8e6eb1785b9f (diff) |
WIP: Moved sources int src/, separated most of the source code from Perl.
The XS was left only for the unit / integration tests, and it links
libslic3r only. No wxWidgets are allowed to be used from Perl starting
from now.
Diffstat (limited to 'src/slic3r/Utils/Http.hpp')
-rw-r--r-- | src/slic3r/Utils/Http.hpp | 115 |
1 files changed, 115 insertions, 0 deletions
diff --git a/src/slic3r/Utils/Http.hpp b/src/slic3r/Utils/Http.hpp new file mode 100644 index 000000000..44580b7ea --- /dev/null +++ b/src/slic3r/Utils/Http.hpp @@ -0,0 +1,115 @@ +#ifndef slic3r_Http_hpp_ +#define slic3r_Http_hpp_ + +#include <memory> +#include <string> +#include <functional> +#include <boost/filesystem/path.hpp> + + +namespace Slic3r { + + +/// Represetns a Http request +class Http : public std::enable_shared_from_this<Http> { +private: + struct priv; +public: + struct Progress + { + size_t dltotal; // Total bytes to download + size_t dlnow; // Bytes downloaded so far + size_t ultotal; // Total bytes to upload + size_t ulnow; // Bytes uploaded so far + + Progress(size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow) : + dltotal(dltotal), dlnow(dlnow), ultotal(ultotal), ulnow(ulnow) + {} + }; + + typedef std::shared_ptr<Http> Ptr; + typedef std::function<void(std::string /* body */, unsigned /* http_status */)> CompleteFn; + + // A HTTP request may fail at various stages of completeness (URL parsing, DNS lookup, TCP connection, ...). + // If the HTTP request could not be made or failed before completion, the `error` arg contains a description + // of the error and `http_status` is zero. + // If the HTTP request was completed but the response HTTP code is >= 400, `error` is empty and `http_status` contains the response code. + // In either case there may or may not be a body. + typedef std::function<void(std::string /* body */, std::string /* error */, unsigned /* http_status */)> ErrorFn; + + // See the Progress struct above. + // Writing true to the `cancel` reference cancels the request in progress. + typedef std::function<void(Progress, bool& /* cancel */)> ProgressFn; + + Http(Http &&other); + + // Note: strings are expected to be UTF-8-encoded + + // These are the primary constructors that create a HTTP object + // for a GET and a POST request respectively. + static Http get(std::string url); + static Http post(std::string url); + ~Http(); + + Http(const Http &) = delete; + Http& operator=(const Http &) = delete; + Http& operator=(Http &&) = delete; + + // Sets a maximum size of the data that can be received. + // A value of zero sets the default limit, which is is 5MB. + Http& size_limit(size_t sizeLimit); + // Sets a HTTP header field. + Http& header(std::string name, const std::string &value); + // Removes a header field. + Http& remove_header(std::string name); + // Sets a CA certificate file for usage with HTTPS. This is only supported on some backends, + // specifically, this is supported with OpenSSL and NOT supported with Windows and OS X native certificate store. + // See also ca_file_supported(). + Http& ca_file(const std::string &filename); + // Add a HTTP multipart form field + Http& form_add(const std::string &name, const std::string &contents); + // Add a HTTP multipart form file data contents, `name` is the name of the part + Http& form_add_file(const std::string &name, const boost::filesystem::path &path); + // Same as above except also override the file's filename with a custom one + Http& form_add_file(const std::string &name, const boost::filesystem::path &path, const std::string &filename); + + // Set the file contents as a POST request body. + // The data is used verbatim, it is not additionally encoded in any way. + // This can be used for hosts which do not support multipart requests. + Http& set_post_body(const boost::filesystem::path &path); + + // Callback called on HTTP request complete + Http& on_complete(CompleteFn fn); + // Callback called on an error occuring at any stage of the requests: Url parsing, DNS lookup, + // TCP connection, HTTP transfer, and finally also when the response indicates an error (status >= 400). + // Therefore, a response body may or may not be present. + Http& on_error(ErrorFn fn); + // Callback called on data download/upload prorgess (called fairly frequently). + // See the `Progress` structure for description of the data passed. + // Writing a true-ish value into the cancel reference parameter cancels the request. + Http& on_progress(ProgressFn fn); + + // Starts performing the request in a background thread + Ptr perform(); + // Starts performing the request on the current thread + void perform_sync(); + // Cancels a request in progress + void cancel(); + + // Tells whether current backend supports seting up a CA file using ca_file() + static bool ca_file_supported(); + + // converts the given string to an url_encoded_string + static std::string url_encode(const std::string &str); +private: + Http(const std::string &url); + + std::unique_ptr<priv> p; +}; + +std::ostream& operator<<(std::ostream &, const Http::Progress &); + + +} + +#endif |