host/libs/web/curl_wrapper.cc - device/google/cuttlefish - Git at Google

 //
 // Copyright (C) 2019 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "host/libs/web/curl_wrapper.h"

 #include <stdio.h>

 #include <fstream>
 #include <mutex>
 #include <sstream>
 #include <string>
 #include <thread>

 #include <android-base/logging.h>
 #include <curl/curl.h>
 #include <json/json.h>

 namespace cuttlefish {
 namespace {

 size_t curl_to_function_cb(char* ptr, size_t, size_t nmemb, void* userdata) {
   CurlWrapper::DataCallback* callback = (CurlWrapper::DataCallback*)userdata;
   if (!(*callback)(ptr, nmemb)) {
     return 0;  // Signals error to curl
   }
   return nmemb;
 }

 size_t file_write_callback(char *ptr, size_t, size_t nmemb, void *userdata) {
   std::stringstream* stream = (std::stringstream*) userdata;
   stream->write(ptr, nmemb);
   return nmemb;
 }

 curl_slist* build_slist(const std::vector<std::string>& strings) {
   curl_slist* curl_headers = nullptr;
   for (const auto& str : strings) {
     curl_slist* temp = curl_slist_append(curl_headers, str.c_str());
     if (temp == nullptr) {
       LOG(ERROR) << "curl_slist_append failed to add " << str;
       if (curl_headers) {
         curl_slist_free_all(curl_headers);
         return nullptr;
       }
     }
     curl_headers = temp;
   }
   return curl_headers;
 }

 class CurlWrapperImpl : public CurlWrapper {
  public:
   CurlWrapperImpl() {
     curl_ = curl_easy_init();
     if (!curl_) {
       LOG(ERROR) << "failed to initialize curl";
       return;
     }
   }
   ~CurlWrapperImpl() { curl_easy_cleanup(curl_); }

   CurlResponse<std::string> PostToString(
       const std::string& url, const std::string& data_to_write,
       const std::vector<std::string>& headers) override {
     std::lock_guard<std::mutex> lock(mutex_);
     LOG(INFO) << "Attempting to download \"" << url << "\"";
     if (!curl_) {
       LOG(ERROR) << "curl was not initialized\n";
       return {"", -1};
     }
     curl_slist* curl_headers = build_slist(headers);
     curl_easy_reset(curl_);
     curl_easy_setopt(curl_, CURLOPT_CAINFO,
                      "/etc/ssl/certs/ca-certificates.crt");
     curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
     curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
     curl_easy_setopt(curl_, CURLOPT_POSTFIELDSIZE, data_to_write.size());
     curl_easy_setopt(curl_, CURLOPT_POSTFIELDS, data_to_write.c_str());
     std::stringstream data_to_read;
     curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, file_write_callback);
     curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &data_to_read);
     char error_buf[CURL_ERROR_SIZE];
     curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
     curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
     CURLcode res = curl_easy_perform(curl_);
     if (curl_headers) {
       curl_slist_free_all(curl_headers);
     }
     if (res != CURLE_OK) {
       LOG(ERROR) << "curl_easy_perform() failed. "
                  << "Code was \"" << res << "\". "
                  << "Strerror was \"" << curl_easy_strerror(res) << "\". "
                  << "Error buffer was \"" << error_buf << "\".";
       return {"", -1};
     }
     long http_code = 0;
     curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
     return {data_to_read.str(), http_code};
   }

   CurlResponse<Json::Value> PostToJson(
       const std::string& url, const std::string& data_to_write,
       const std::vector<std::string>& headers) override {
     CurlResponse<std::string> response =
         PostToString(url, data_to_write, headers);
     const std::string& contents = response.data;
     Json::CharReaderBuilder builder;
     std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
     Json::Value json;
     std::string errorMessage;
     if (!reader->parse(&*contents.begin(), &*contents.end(), &json,
                        &errorMessage)) {
       LOG(ERROR) << "Could not parse json: " << errorMessage;
       json["error"] = "Failed to parse json.";
       json["response"] = contents;
     }
     return {json, response.http_code};
   }

   CurlResponse<Json::Value> PostToJson(
       const std::string& url, const Json::Value& data_to_write,
       const std::vector<std::string>& headers) override {
     std::stringstream json_str;
     json_str << data_to_write;
     return PostToJson(url, json_str.str(), headers);
   }

   CurlResponse<bool> DownloadToCallback(
       DataCallback callback, const std::string& url,
       const std::vector<std::string>& headers) {
     std::lock_guard<std::mutex> lock(mutex_);
     LOG(INFO) << "Attempting to download \"" << url << "\"";
     if (!curl_) {
       LOG(ERROR) << "curl was not initialized\n";
       return {false, -1};
     }
     if (!callback(nullptr, 0)) {  // Signal start of data
       LOG(ERROR) << "Callback failure\n";
       return {false, -1};
     }
     curl_slist* curl_headers = build_slist(headers);
     curl_easy_reset(curl_);
     curl_easy_setopt(curl_, CURLOPT_CAINFO,
                      "/etc/ssl/certs/ca-certificates.crt");
     curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
     curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
     curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, curl_to_function_cb);
     curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &callback);
     char error_buf[CURL_ERROR_SIZE];
     curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
     curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
     CURLcode res = curl_easy_perform(curl_);
     if (curl_headers) {
       curl_slist_free_all(curl_headers);
     }
     if (res != CURLE_OK) {
       LOG(ERROR) << "curl_easy_perform() failed. "
                  << "Code was \"" << res << "\". "
                  << "Strerror was \"" << curl_easy_strerror(res) << "\". "
                  << "Error buffer was \"" << error_buf << "\".";
       return {false, -1};
     }
     long http_code = 0;
     curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
     return {true, http_code};
   }

   CurlResponse<std::string> DownloadToFile(
       const std::string& url, const std::string& path,
       const std::vector<std::string>& headers) {
     LOG(INFO) << "Attempting to save \"" << url << "\" to \"" << path << "\"";
     std::fstream stream;
     auto callback = [&stream, path](char* data, size_t size) -> bool {
       if (data == nullptr) {
         stream.open(path, std::ios::out | std::ios::binary | std::ios::trunc);
         return !stream.fail();
       }
       stream.write(data, size);
       return !stream.fail();
     };
     auto callback_res = DownloadToCallback(callback, url, headers);
     if (!callback_res.data) {
       return {"", callback_res.http_code};
     }
     return {path, callback_res.http_code};
     std::lock_guard<std::mutex> lock(mutex_);
     if (!curl_) {
       LOG(ERROR) << "curl was not initialized\n";
       return {"", -1};
     }
   }

   CurlResponse<std::string> DownloadToString(
       const std::string& url, const std::vector<std::string>& headers) {
     std::stringstream stream;
     auto callback = [&stream](char* data, size_t size) -> bool {
       if (data == nullptr) {
         stream = std::stringstream();
         return true;
       }
       stream.write(data, size);
       return true;
     };
     auto callback_res = DownloadToCallback(callback, url, headers);
     if (!callback_res.data) {
       return {"", callback_res.http_code};
     }
     return {stream.str(), callback_res.http_code};
   }

   CurlResponse<Json::Value> DownloadToJson(
       const std::string& url, const std::vector<std::string>& headers) {
     CurlResponse<std::string> response = DownloadToString(url, headers);
     const std::string& contents = response.data;
     Json::CharReaderBuilder builder;
     std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
     Json::Value json;
     std::string errorMessage;
     if (!reader->parse(&*contents.begin(), &*contents.end(), &json,
                        &errorMessage)) {
       LOG(ERROR) << "Could not parse json: " << errorMessage;
       json["error"] = "Failed to parse json.";
       json["response"] = contents;
     }
     return {json, response.http_code};
   }

   CurlResponse<Json::Value> DeleteToJson(
       const std::string& url,
       const std::vector<std::string>& headers) override {
     std::lock_guard<std::mutex> lock(mutex_);
     LOG(INFO) << "Attempting to download \"" << url << "\"";
     if (!curl_) {
       LOG(ERROR) << "curl was not initialized\n";
       return {"", -1};
     }
     curl_slist* curl_headers = build_slist(headers);
     curl_easy_reset(curl_);
     curl_easy_setopt(curl_, CURLOPT_CUSTOMREQUEST, "DELETE");
     curl_easy_setopt(curl_, CURLOPT_CAINFO,
                      "/etc/ssl/certs/ca-certificates.crt");
     curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
     curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
     std::stringstream data_to_read;
     curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, file_write_callback);
     curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &data_to_read);
     char error_buf[CURL_ERROR_SIZE];
     curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
     curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
     CURLcode res = curl_easy_perform(curl_);
     if (curl_headers) {
       curl_slist_free_all(curl_headers);
     }
     if (res != CURLE_OK) {
       LOG(ERROR) << "curl_easy_perform() failed. "
                  << "Code was \"" << res << "\". "
                  << "Strerror was \"" << curl_easy_strerror(res) << "\". "
                  << "Error buffer was \"" << error_buf << "\".";
       return {"", -1};
     }
     long http_code = 0;
     curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);

     auto contents = data_to_read.str();
     Json::CharReaderBuilder builder;
     std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
     Json::Value json;
     std::string errorMessage;
     if (!reader->parse(&*contents.begin(), &*contents.end(), &json,
                        &errorMessage)) {
       LOG(ERROR) << "Could not parse json: " << errorMessage;
       json["error"] = "Failed to parse json.";
       json["response"] = contents;
     }
     return {json, http_code};
   }

   std::string UrlEscape(const std::string& text) override {
     char* escaped_str = curl_easy_escape(curl_, text.c_str(), text.size());
     std::string ret{escaped_str};
     curl_free(escaped_str);
     return ret;
   }

  private:
   CURL* curl_;
   std::mutex mutex_;
 };

 class CurlServerErrorRetryingWrapper : public CurlWrapper {
  public:
   CurlServerErrorRetryingWrapper(CurlWrapper& inner, int retry_attempts,
                                  std::chrono::milliseconds retry_delay)
       : inner_curl_(inner),
         retry_attempts_(retry_attempts),
         retry_delay_(retry_delay) {}

   CurlResponse<std::string> PostToString(
       const std::string& url, const std::string& data,
       const std::vector<std::string>& headers) override {
     return RetryImpl<std::string>(
         [&, this]() { return inner_curl_.PostToString(url, data, headers); });
   }

   CurlResponse<Json::Value> PostToJson(
       const std::string& url, const Json::Value& data,
       const std::vector<std::string>& headers) override {
     return RetryImpl<Json::Value>(
         [&, this]() { return inner_curl_.PostToJson(url, data, headers); });
   }

   CurlResponse<Json::Value> PostToJson(
       const std::string& url, const std::string& data,
       const std::vector<std::string>& headers) override {
     return RetryImpl<Json::Value>(
         [&, this]() { return inner_curl_.PostToJson(url, data, headers); });
   }

   CurlResponse<std::string> DownloadToFile(
       const std::string& url, const std::string& path,
       const std::vector<std::string>& headers) {
     return RetryImpl<std::string>(
         [&, this]() { return inner_curl_.DownloadToFile(url, path, headers); });
   }

   CurlResponse<std::string> DownloadToString(
       const std::string& url, const std::vector<std::string>& headers) {
     return RetryImpl<std::string>(
         [&, this]() { return inner_curl_.DownloadToString(url, headers); });
   }

   CurlResponse<Json::Value> DownloadToJson(
       const std::string& url, const std::vector<std::string>& headers) {
     return RetryImpl<Json::Value>(
         [&, this]() { return inner_curl_.DownloadToJson(url, headers); });
   }

   CurlResponse<bool> DownloadToCallback(
       DataCallback cb, const std::string& url,
       const std::vector<std::string>& hdrs) override {
     return RetryImpl<bool>(
         [&, this]() { return inner_curl_.DownloadToCallback(cb, url, hdrs); });
   }
   CurlResponse<Json::Value> DeleteToJson(
       const std::string& url,
       const std::vector<std::string>& headers) override {
     return RetryImpl<Json::Value>(
         [&, this]() { return inner_curl_.DeleteToJson(url, headers); });
   }

   std::string UrlEscape(const std::string& text) override {
     return inner_curl_.UrlEscape(text);
   }

  private:
   template <typename T>
   CurlResponse<T> RetryImpl(std::function<CurlResponse<T>()> attempt_fn) {
     CurlResponse<T> response;
     for (int attempt = 0; attempt != retry_attempts_; ++attempt) {
       if (attempt != 0) {
         std::this_thread::sleep_for(retry_delay_);
       }
       response = attempt_fn();
       if (!response.HttpServerError()) {
         return response;
       }
     }
     return response;
   }

  private:
   CurlWrapper& inner_curl_;
   int retry_attempts_;
   std::chrono::milliseconds retry_delay_;
 };

 }  // namespace

 /* static */ std::unique_ptr<CurlWrapper> CurlWrapper::Create() {
   return std::unique_ptr<CurlWrapper>(new CurlWrapperImpl());
 }

 /* static */ std::unique_ptr<CurlWrapper> CurlWrapper::WithServerErrorRetry(
     CurlWrapper& inner, int retry_attempts,
     std::chrono::milliseconds retry_delay) {
   return std::unique_ptr<CurlWrapper>(
       new CurlServerErrorRetryingWrapper(inner, retry_attempts, retry_delay));
 }

 CurlWrapper::~CurlWrapper() = default;
 }
	//
	// Copyright (C) 2019 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "host/libs/web/curl_wrapper.h"

	#include <stdio.h>

	#include <fstream>
	#include <mutex>
	#include <sstream>
	#include <string>
	#include <thread>

	#include <android-base/logging.h>
	#include <curl/curl.h>
	#include <json/json.h>

	namespace cuttlefish {
	namespace {

	size_t curl_to_function_cb(char* ptr, size_t, size_t nmemb, void* userdata) {
	CurlWrapper::DataCallback* callback = (CurlWrapper::DataCallback*)userdata;
	if (!(*callback)(ptr, nmemb)) {
	return 0; // Signals error to curl
	}
	return nmemb;
	}

	size_t file_write_callback(char ptr, size_t, size_t nmemb, void userdata) {
	std::stringstream* stream = (std::stringstream*) userdata;
	stream->write(ptr, nmemb);
	return nmemb;
	}

	curl_slist* build_slist(const std::vector<std::string>& strings) {
	curl_slist* curl_headers = nullptr;
	for (const auto& str : strings) {
	curl_slist* temp = curl_slist_append(curl_headers, str.c_str());
	if (temp == nullptr) {
	LOG(ERROR) << "curl_slist_append failed to add " << str;
	if (curl_headers) {
	curl_slist_free_all(curl_headers);
	return nullptr;
	}
	}
	curl_headers = temp;
	}
	return curl_headers;
	}

	class CurlWrapperImpl : public CurlWrapper {
	public:
	CurlWrapperImpl() {
	curl_ = curl_easy_init();
	if (!curl_) {
	LOG(ERROR) << "failed to initialize curl";
	return;
	}
	}
	~CurlWrapperImpl() { curl_easy_cleanup(curl_); }

	CurlResponse<std::string> PostToString(
	const std::string& url, const std::string& data_to_write,
	const std::vector<std::string>& headers) override {
	std::lock_guard<std::mutex> lock(mutex_);
	LOG(INFO) << "Attempting to download \"" << url << "\"";
	if (!curl_) {
	LOG(ERROR) << "curl was not initialized\n";
	return {"", -1};
	}
	curl_slist* curl_headers = build_slist(headers);
	curl_easy_reset(curl_);
	curl_easy_setopt(curl_, CURLOPT_CAINFO,
	"/etc/ssl/certs/ca-certificates.crt");
	curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
	curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
	curl_easy_setopt(curl_, CURLOPT_POSTFIELDSIZE, data_to_write.size());
	curl_easy_setopt(curl_, CURLOPT_POSTFIELDS, data_to_write.c_str());
	std::stringstream data_to_read;
	curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, file_write_callback);
	curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &data_to_read);
	char error_buf[CURL_ERROR_SIZE];
	curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
	curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
	CURLcode res = curl_easy_perform(curl_);
	if (curl_headers) {
	curl_slist_free_all(curl_headers);
	}
	if (res != CURLE_OK) {
	LOG(ERROR) << "curl_easy_perform() failed. "
	<< "Code was \"" << res << "\". "
	<< "Strerror was \"" << curl_easy_strerror(res) << "\". "
	<< "Error buffer was \"" << error_buf << "\".";
	return {"", -1};
	}
	long http_code = 0;
	curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
	return {data_to_read.str(), http_code};
	}

	CurlResponse<Json::Value> PostToJson(
	const std::string& url, const std::string& data_to_write,
	const std::vector<std::string>& headers) override {
	CurlResponse<std::string> response =
	PostToString(url, data_to_write, headers);
	const std::string& contents = response.data;
	Json::CharReaderBuilder builder;
	std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
	Json::Value json;
	std::string errorMessage;
	if (!reader->parse(&contents.begin(), &contents.end(), &json,
	&errorMessage)) {
	LOG(ERROR) << "Could not parse json: " << errorMessage;
	json["error"] = "Failed to parse json.";
	json["response"] = contents;
	}
	return {json, response.http_code};
	}

	CurlResponse<Json::Value> PostToJson(
	const std::string& url, const Json::Value& data_to_write,
	const std::vector<std::string>& headers) override {
	std::stringstream json_str;
	json_str << data_to_write;
	return PostToJson(url, json_str.str(), headers);
	}

	CurlResponse<bool> DownloadToCallback(
	DataCallback callback, const std::string& url,
	const std::vector<std::string>& headers) {
	std::lock_guard<std::mutex> lock(mutex_);
	LOG(INFO) << "Attempting to download \"" << url << "\"";
	if (!curl_) {
	LOG(ERROR) << "curl was not initialized\n";
	return {false, -1};
	}
	if (!callback(nullptr, 0)) { // Signal start of data
	LOG(ERROR) << "Callback failure\n";
	return {false, -1};
	}
	curl_slist* curl_headers = build_slist(headers);
	curl_easy_reset(curl_);
	curl_easy_setopt(curl_, CURLOPT_CAINFO,
	"/etc/ssl/certs/ca-certificates.crt");
	curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
	curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
	curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, curl_to_function_cb);
	curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &callback);
	char error_buf[CURL_ERROR_SIZE];
	curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
	curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
	CURLcode res = curl_easy_perform(curl_);
	if (curl_headers) {
	curl_slist_free_all(curl_headers);
	}
	if (res != CURLE_OK) {
	LOG(ERROR) << "curl_easy_perform() failed. "
	<< "Code was \"" << res << "\". "
	<< "Strerror was \"" << curl_easy_strerror(res) << "\". "
	<< "Error buffer was \"" << error_buf << "\".";
	return {false, -1};
	}
	long http_code = 0;
	curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);
	return {true, http_code};
	}

	CurlResponse<std::string> DownloadToFile(
	const std::string& url, const std::string& path,
	const std::vector<std::string>& headers) {
	LOG(INFO) << "Attempting to save \"" << url << "\" to \"" << path << "\"";
	std::fstream stream;
	auto callback = [&stream, path](char* data, size_t size) -> bool {
	if (data == nullptr) {
	stream.open(path, std::ios::out \| std::ios::binary \| std::ios::trunc);
	return !stream.fail();
	}
	stream.write(data, size);
	return !stream.fail();
	};
	auto callback_res = DownloadToCallback(callback, url, headers);
	if (!callback_res.data) {
	return {"", callback_res.http_code};
	}
	return {path, callback_res.http_code};
	std::lock_guard<std::mutex> lock(mutex_);
	if (!curl_) {
	LOG(ERROR) << "curl was not initialized\n";
	return {"", -1};
	}
	}

	CurlResponse<std::string> DownloadToString(
	const std::string& url, const std::vector<std::string>& headers) {
	std::stringstream stream;
	auto callback = [&stream](char* data, size_t size) -> bool {
	if (data == nullptr) {
	stream = std::stringstream();
	return true;
	}
	stream.write(data, size);
	return true;
	};
	auto callback_res = DownloadToCallback(callback, url, headers);
	if (!callback_res.data) {
	return {"", callback_res.http_code};
	}
	return {stream.str(), callback_res.http_code};
	}

	CurlResponse<Json::Value> DownloadToJson(
	const std::string& url, const std::vector<std::string>& headers) {
	CurlResponse<std::string> response = DownloadToString(url, headers);
	const std::string& contents = response.data;
	Json::CharReaderBuilder builder;
	std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
	Json::Value json;
	std::string errorMessage;
	if (!reader->parse(&contents.begin(), &contents.end(), &json,
	&errorMessage)) {
	LOG(ERROR) << "Could not parse json: " << errorMessage;
	json["error"] = "Failed to parse json.";
	json["response"] = contents;
	}
	return {json, response.http_code};
	}

	CurlResponse<Json::Value> DeleteToJson(
	const std::string& url,
	const std::vector<std::string>& headers) override {
	std::lock_guard<std::mutex> lock(mutex_);
	LOG(INFO) << "Attempting to download \"" << url << "\"";
	if (!curl_) {
	LOG(ERROR) << "curl was not initialized\n";
	return {"", -1};
	}
	curl_slist* curl_headers = build_slist(headers);
	curl_easy_reset(curl_);
	curl_easy_setopt(curl_, CURLOPT_CUSTOMREQUEST, "DELETE");
	curl_easy_setopt(curl_, CURLOPT_CAINFO,
	"/etc/ssl/certs/ca-certificates.crt");
	curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, curl_headers);
	curl_easy_setopt(curl_, CURLOPT_URL, url.c_str());
	std::stringstream data_to_read;
	curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, file_write_callback);
	curl_easy_setopt(curl_, CURLOPT_WRITEDATA, &data_to_read);
	char error_buf[CURL_ERROR_SIZE];
	curl_easy_setopt(curl_, CURLOPT_ERRORBUFFER, error_buf);
	curl_easy_setopt(curl_, CURLOPT_VERBOSE, 1L);
	CURLcode res = curl_easy_perform(curl_);
	if (curl_headers) {
	curl_slist_free_all(curl_headers);
	}
	if (res != CURLE_OK) {
	LOG(ERROR) << "curl_easy_perform() failed. "
	<< "Code was \"" << res << "\". "
	<< "Strerror was \"" << curl_easy_strerror(res) << "\". "
	<< "Error buffer was \"" << error_buf << "\".";
	return {"", -1};
	}
	long http_code = 0;
	curl_easy_getinfo(curl_, CURLINFO_RESPONSE_CODE, &http_code);

	auto contents = data_to_read.str();
	Json::CharReaderBuilder builder;
	std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
	Json::Value json;
	std::string errorMessage;
	if (!reader->parse(&contents.begin(), &contents.end(), &json,
	&errorMessage)) {
	LOG(ERROR) << "Could not parse json: " << errorMessage;
	json["error"] = "Failed to parse json.";
	json["response"] = contents;
	}
	return {json, http_code};
	}

	std::string UrlEscape(const std::string& text) override {
	char* escaped_str = curl_easy_escape(curl_, text.c_str(), text.size());
	std::string ret{escaped_str};
	curl_free(escaped_str);
	return ret;
	}

	private:
	CURL* curl_;
	std::mutex mutex_;
	};

	class CurlServerErrorRetryingWrapper : public CurlWrapper {
	public:
	CurlServerErrorRetryingWrapper(CurlWrapper& inner, int retry_attempts,
	std::chrono::milliseconds retry_delay)
	: inner_curl_(inner),
	retry_attempts_(retry_attempts),
	retry_delay_(retry_delay) {}

	CurlResponse<std::string> PostToString(
	const std::string& url, const std::string& data,
	const std::vector<std::string>& headers) override {
	return RetryImpl<std::string>(
	[&, this]() { return inner_curl_.PostToString(url, data, headers); });
	}

	CurlResponse<Json::Value> PostToJson(
	const std::string& url, const Json::Value& data,
	const std::vector<std::string>& headers) override {
	return RetryImpl<Json::Value>(
	[&, this]() { return inner_curl_.PostToJson(url, data, headers); });
	}

	CurlResponse<Json::Value> PostToJson(
	const std::string& url, const std::string& data,
	const std::vector<std::string>& headers) override {
	return RetryImpl<Json::Value>(
	[&, this]() { return inner_curl_.PostToJson(url, data, headers); });
	}

	CurlResponse<std::string> DownloadToFile(
	const std::string& url, const std::string& path,
	const std::vector<std::string>& headers) {
	return RetryImpl<std::string>(
	[&, this]() { return inner_curl_.DownloadToFile(url, path, headers); });
	}

	CurlResponse<std::string> DownloadToString(
	const std::string& url, const std::vector<std::string>& headers) {
	return RetryImpl<std::string>(
	[&, this]() { return inner_curl_.DownloadToString(url, headers); });
	}

	CurlResponse<Json::Value> DownloadToJson(
	const std::string& url, const std::vector<std::string>& headers) {
	return RetryImpl<Json::Value>(
	[&, this]() { return inner_curl_.DownloadToJson(url, headers); });
	}

	CurlResponse<bool> DownloadToCallback(
	DataCallback cb, const std::string& url,
	const std::vector<std::string>& hdrs) override {
	return RetryImpl<bool>(
	[&, this]() { return inner_curl_.DownloadToCallback(cb, url, hdrs); });
	}
	CurlResponse<Json::Value> DeleteToJson(
	const std::string& url,
	const std::vector<std::string>& headers) override {
	return RetryImpl<Json::Value>(
	[&, this]() { return inner_curl_.DeleteToJson(url, headers); });
	}

	std::string UrlEscape(const std::string& text) override {
	return inner_curl_.UrlEscape(text);
	}

	private:
	template <typename T>
	CurlResponse<T> RetryImpl(std::function<CurlResponse<T>()> attempt_fn) {
	CurlResponse<T> response;
	for (int attempt = 0; attempt != retry_attempts_; ++attempt) {
	if (attempt != 0) {
	std::this_thread::sleep_for(retry_delay_);
	}
	response = attempt_fn();
	if (!response.HttpServerError()) {
	return response;
	}
	}
	return response;
	}

	private:
	CurlWrapper& inner_curl_;
	int retry_attempts_;
	std::chrono::milliseconds retry_delay_;
	};

	} // namespace

	/* static */ std::unique_ptr<CurlWrapper> CurlWrapper::Create() {
	return std::unique_ptr<CurlWrapper>(new CurlWrapperImpl());
	}

	/* static */ std::unique_ptr<CurlWrapper> CurlWrapper::WithServerErrorRetry(
	CurlWrapper& inner, int retry_attempts,
	std::chrono::milliseconds retry_delay) {
	return std::unique_ptr<CurlWrapper>(
	new CurlServerErrorRetryingWrapper(inner, retry_attempts, retry_delay));
	}

	CurlWrapper::~CurlWrapper() = default;
	}