diff --git a/include/blob/blob_client.h b/include/blob/blob_client.h index d53645f..73b6def 100644 --- a/include/blob/blob_client.h +++ b/include/blob/blob_client.h @@ -33,24 +33,31 @@ namespace azure { namespace storage_lite { /// /// An existing object. /// An int value indicates the maximum concurrency expected during execute requests against the service. - blob_client(std::shared_ptr account, int max_concurrency) - : m_account(account) + /// A string value with absolute path to CA bundle location. + blob_client(std::shared_ptr account, int max_concurrency, const std::string& ca_path = "") + : blob_client(account, + std::make_shared(std::make_shared(), std::make_shared()), + (ca_path.empty() ? std::make_shared(max_concurrency) + : std::make_shared(max_concurrency, ca_path))) { - m_context = std::make_shared(std::make_shared(), std::make_shared()); - m_client = std::make_shared(max_concurrency); } /// /// Initializes a new instance of the class. /// /// An existing object. + /// A context of execution defining how to parser and the retry policy class. /// An int value indicates the maximum concurrency expected during execute requests against the service. /// A string value with absolute path to CA bundle location. - blob_client(std::shared_ptr account, int max_concurrency, const std::string& ca_path) - : m_account(account) + blob_client(std::shared_ptr account, + std::shared_ptr context, + int max_concurrency, + const std::string ca_path = "") + : blob_client(account, + context, + (ca_path.empty() ? std::make_shared(max_concurrency) + : std::make_shared(max_concurrency, ca_path))) { - m_context = std::make_shared(std::make_shared(), std::make_shared()); - m_client = std::make_shared(max_concurrency, ca_path); } /// @@ -321,6 +328,15 @@ namespace azure { namespace storage_lite { AZURE_STORAGE_API std::future> start_copy(const std::string &sourceContainer, const std::string &sourceBlob, const std::string &destContainer, const std::string &destBlob); private: + blob_client(std::shared_ptr account, + std::shared_ptr context, + std::shared_ptr client) + : m_client(client), + m_account(account), + m_context(context) + { + } + std::shared_ptr m_client; std::shared_ptr m_account; std::shared_ptr m_context; diff --git a/include/constants.dat b/include/constants.dat index 37fe556..38ce402 100644 --- a/include/constants.dat +++ b/include/constants.dat @@ -118,6 +118,9 @@ DAT(header_value_storage_version, "2018-11-09") DAT(header_value_user_agent, "azure-storage-cpplite/0.1.0") +DAT_TYPED(int, maximum_retries, 3) +DAT_TYPED(int, base_timeout, 10) + DAT(date_format_rfc_1123, "%a, %d %b %Y %H:%M:%S GMT") DAT(date_format_iso_8601, "%Y-%m-%dT%H:%M:%SZ") diff --git a/include/constants.h b/include/constants.h index ec139d8..8f1f212 100644 --- a/include/constants.h +++ b/include/constants.h @@ -5,7 +5,9 @@ namespace azure { namespace storage_lite { namespace constants { #define DAT(x, y) extern AZURE_STORAGE_API const char *x; const int x ## _size{ sizeof(y) / sizeof(char) - 1 }; +#define DAT_TYPED(type, name, value) extern AZURE_STORAGE_API const type name; #include "constants.dat" #undef DAT +#undef DAT_TYPED -}}} // azure::storage_lite::constants \ No newline at end of file +}}} // azure::storage_lite::constants diff --git a/include/get_container_property_request_base.h b/include/get_container_property_request_base.h index bd12c4e..a0adbe3 100644 --- a/include/get_container_property_request_base.h +++ b/include/get_container_property_request_base.h @@ -33,7 +33,7 @@ namespace azure { namespace storage_lite { m_valid = valid; } - bool valid() + bool valid() const { return m_valid; } diff --git a/include/retry.h b/include/retry.h index 3831887..8dbfd52 100644 --- a/include/retry.h +++ b/include/retry.h @@ -6,6 +6,7 @@ #include "storage_EXPORTS.h" +#include "constants.h" #include "http_base.h" #include "utility.h" @@ -78,20 +79,23 @@ namespace azure { namespace storage_lite { class retry_policy final : public retry_policy_base { public: + + retry_policy(const int maximum_retries = azure::storage_lite::constants::maximum_retries, + const std::chrono::seconds base_timeout = std::chrono::seconds{azure::storage_lite::constants::base_timeout}) + : m_maximum_retries(maximum_retries), + m_base_timeout(base_timeout) + { + } + retry_info evaluate(const retry_context &context) const override { - if (context.numbers() == 0) - { - return retry_info(true, std::chrono::seconds(0)); - } - else if (context.numbers() < 26 && can_retry(context.result())) + if (context.numbers() >= m_maximum_retries || + !can_retry(context.result())) { - double delay = (pow(1.2, context.numbers()-1)-1); - delay = std::min(delay, 60.0); // Maximum backoff delay of 1 minute - delay *= (((double)rand())/RAND_MAX)/2 + 0.75; - return retry_info(true, std::chrono::seconds((int)delay)); + return retry_info(false, std::chrono::seconds(0)); } - return retry_info(false, std::chrono::seconds(0)); + + return retry_info(true, calculate_new_delay(context)); } private: @@ -99,6 +103,16 @@ namespace azure { namespace storage_lite { { return retryable(code); } + + std::chrono::seconds calculate_new_delay(const retry_context &context) const + { + // (1 << N) == 2^N + return ((context.numbers() == 0) ? std::chrono::seconds(0) + : (m_base_timeout * (1 << context.numbers()))); + } + + const int m_maximum_retries; + const std::chrono::seconds m_base_timeout; }; }} // azure::storage_lite diff --git a/include/utility.h b/include/utility.h index 2b26fb1..7103d41 100644 --- a/include/utility.h +++ b/include/utility.h @@ -2,6 +2,8 @@ #include #include +#include +#include #include "storage_EXPORTS.h" @@ -28,6 +30,8 @@ namespace azure { namespace storage_lite { AZURE_STORAGE_API std::string get_http_verb(http_base::http_method method); + AZURE_STORAGE_API std::vector> filter_headers(const std::map& headers, const std::string& value); + inline void add_optional_query(storage_url &url, const std::string &name, unsigned int value) { if (value > 0) diff --git a/src/blob/blob_client.cpp b/src/blob/blob_client.cpp index 046a88d..d5c8b79 100644 --- a/src/blob/blob_client.cpp +++ b/src/blob/blob_client.cpp @@ -75,7 +75,7 @@ storage_outcome blob_client::get_chunk_to_stream_sync(const std: property.etag = http->get_response_header(constants::header_etag); property.totalSize = get_length_from_content_range(http->get_response_header(constants::header_content_range)); std::istringstream(http->get_response_header(constants::header_content_length)) >> property.size; - property.last_modified = curl_getdate(http->get_response_header(constants::header_last_modified).c_str(), NULL); + property.last_modified = curl_getdate(http->get_response_header(constants::header_last_modified).c_str(), nullptr); return storage_outcome(property); } return storage_outcome(storage_error(response.error())); @@ -196,14 +196,7 @@ std::future> blob_client::get_container_prop container_property properties(true); properties.etag = http->get_response_header(constants::header_etag); - auto& headers = http->get_response_headers(); - for (auto iter = headers.begin(); iter != headers.end(); ++iter) - { - if (iter->first.find(constants::header_ms_meta_prefix) == 0) - { - properties.metadata.push_back(std::make_pair(iter->first.substr(constants::header_ms_meta_prefix_size), iter->second)); - } - } + properties.metadata = filter_headers(http->get_response_headers(), constants::header_ms_meta_prefix); return storage_outcome(properties); } else @@ -275,7 +268,7 @@ std::future> blob_client::get_blob_properties(con properties.content_type = http->get_response_header(constants::header_content_type); properties.etag = http->get_response_header(constants::header_etag); properties.copy_status = http->get_response_header(constants::header_ms_copy_status); - properties.last_modified = curl_getdate(http->get_response_header(constants::header_last_modified).c_str(), NULL); + properties.last_modified = curl_getdate(http->get_response_header(constants::header_last_modified).c_str(), nullptr); std::string::size_type sz = 0; std::string contentLength = http->get_response_header(constants::header_content_length); if (contentLength.length() > 0) @@ -283,15 +276,7 @@ std::future> blob_client::get_blob_properties(con properties.size = std::stoull(contentLength, &sz, 0); } - auto& headers = http->get_response_headers(); - for (auto iter = headers.begin(); iter != headers.end(); ++iter) - { - if (iter->first.find(constants::header_ms_meta_prefix) == 0) - { - // We need to strip ten characters from the front of the key to account for "x-ms-meta-". - properties.metadata.push_back(std::make_pair(iter->first.substr(constants::header_ms_meta_prefix_size), iter->second)); - } - } + properties.metadata = filter_headers(http->get_response_headers(), constants::header_ms_meta_prefix); return storage_outcome(properties); } else diff --git a/src/constants.cpp b/src/constants.cpp index 5f4e7e0..b5f1f0a 100644 --- a/src/constants.cpp +++ b/src/constants.cpp @@ -3,7 +3,9 @@ namespace azure { namespace storage_lite { namespace constants { #define DAT(x, y) const char *x{ y }; +#define DAT_TYPED(type, name, value) const type name{value}; #include "constants.dat" #undef DAT +#undef DAT_TYPED }}} // azure::storage_lite diff --git a/src/utility.cpp b/src/utility.cpp index 95dcdfc..8c19ab4 100644 --- a/src/utility.cpp +++ b/src/utility.cpp @@ -123,6 +123,21 @@ namespace azure { namespace storage_lite { return std::string(); } + std::vector> filter_headers(const std::map& headers, + const std::string& value) + { + std::vector> filteredHeaders; + filteredHeaders.reserve(headers.size()); + for (const auto& header : headers) + { + if (header.first.find(value) == 0) + { + filteredHeaders.emplace_back(header.first.substr(value.size()), header.second); + } + } + return filteredHeaders; + } + void add_access_condition_headers(http_base &h, storage_headers &headers, const blob_request_base &r) { if (!r.if_modified_since().empty())