Merge lp:~gary-wzl77/net-cpp/bug-fixing-and-features into lp:net-cpp

[Gary.Wang]

1.Fix crash issue when sending large chunk data via PUT method (lp:1570686)
3.Support DELETE method (lp:1570687)
2.Support POST method with istream
4.Support pause and resume mechanism
5.Add some test cases

1.Fix crash issue when sending large chunk data via PUT method (lp:1570686)
3.Support DELETE method (lp:1570687)
2.Support POST method with istream
4.Support pause and resume mechanism
5.Add some test cases

[Thomas Voß (thomas-voss)]

Thanks for the changes, looking good. A few minor niggles inline,

review: Needs Fixing

[lp:~gary-wzl77/net-cpp/bug-fixing-and-features]

51. By Gary.Wang on 2016-05-17

1.bump major revision since this change breaks ABI
2.introduce new API (abort_request_option) for request
3.fix typo

52. By Gary.Wang on 2016-05-23

1.abort_request_option -> abort_request_if to make api more self-explanatory
2.do not set abort request option by default

[Thomas Voß (thomas-voss)]

Thanks for your changes, the MP looks good to me. I tried to further understand your remarks about only setting abort_request_option if explicitly requested and read up on: https://curl.haxx.se/libcurl/c/curl_easy_pause.html. I do not see an issue in the case of async requests, though. For synchronous requests, the operation might block indefinitely, and we should at least document the respective error mode.

Hope that addresses your remark :) Or did I miss something?

review: Approve

[Gary.Wang (gary-wzl77)]

Thanks, Please add the following test case in http_streaming_client_test.cpp.
http://bazaar.launchpad.net/~gary-wzl77/+junk/net-cpp_test_pause_and_resume/revision/53/tests/http_streaming_client_test.cpp#tests/=

Then we can see the potential issue we have in this MP after it is run. (I use the async api to reproduce this issue.)

Log:
....
Download progress: 0.0154666
Download progress: 0.0154666
we pause
Download progress: 0.0154666
Download progress: 0.0154666
Download progress: 0.0154666
we resume.

I resume download after the request is paused for 5 secs. But there is no "Download progress" log printing out any more even if I resume it. It causes the curl thread to hang as well. The issue can be reproduces 100%.

However if I explicitly set async_abort_if(1k/s, 10s) before request asynchronous execution(async_execute). Everything works fine.

Log:
Download progress: 0.0077333
Download progress: 0.0077333
Download progress: 0.0077333
we pause
Download progress: 0.0077333
we resume.
Download progress: 0.0077333
Download progress: 0.0077333
Download progress: 0.0077333
Download progress: 0.00883806
Download progress: 0.00883806

So it's better to mention this case in doc somewhere to reminder developer of setting abort_request_option explicitly before request asynchronous execution if they really want to pause/resume a request in one connection.
Otherwise developer doesn't figure out why it doesn't work out after resuming from paused state.
But anyway, it works fine if developers don't use pause/resume API.

P.S:
curl utilizes progress callback(CURLOPT_PROGRESSFUNCTION) to set bitmask(CURLPAUSE_CONT/CURLPAUSE_ALL) for a connection state change(pause/resume). However the default value of speed_time(2nd argument for abort_request_if) is 0(disabled). So after request is paused, progress cb gets no chance to call in such a case. It failed to resume even if we set the bitmask(CURLPAUSE_CONT).

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-04-01 06:23:30 +0000
+++ CMakeLists.txt	2016-05-23 10:51:40 +0000
@@ -26,8 +26,8 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Werror -Wall -fno-strict-aliasing -fvisibility=hidden -fvisibility-inlines-hidden -pedantic -Wextra")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
 
-set(NET_CPP_VERSION_MAJOR 1)
-set(NET_CPP_VERSION_MINOR 2)
+set(NET_CPP_VERSION_MAJOR 2)
+set(NET_CPP_VERSION_MINOR 0)
 set(NET_CPP_VERSION_PATCH 0)
 
 include(CTest)
 
=== modified file 'include/core/net/http/client.h'
--- include/core/net/http/client.h	2014-06-10 14:19:14 +0000
+++ include/core/net/http/client.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_CLIENT_H_
 #define CORE_NET_HTTP_CLIENT_H_
@@ -154,6 +155,16 @@
      */
     virtual std::shared_ptr<Request> post(const Request::Configuration& configuration, const std::string& payload, const std::string& type) = 0;
 
+      /**
+      * @brief post is a convenience method for issuing a POST request for the given URI.
+      * @throw Errors::HttpMethodNotSupported if the underlying implementation does not support the pro vided HTTP method.
+      * @param configuration The configuration to issue a get request for.
+      * @param payload The data to be transmitted as part of the POST request.
+      * @param size Size of the payload data in bytes.
+      * @return An executable instance of class Request.
+      */
+      virtual std::shared_ptr<Request> post(const Request::Configuration& configuration, std::istream& payload, std::size_t size) = 0;
+
     /**
      * @brief post_form is a convenience method for issuing a POST request for the given URI, with url-encoded payload.
      * @throw Errors::HttpMethodNotSupported if the underlying implementation does not support the provided HTTP method.
@@ -163,6 +174,14 @@
      */
     virtual std::shared_ptr<Request> post_form(const Request::Configuration& configuration, const std::map<std::string, std::string>& values);
 
+    /**
+     * @brief del is a convenience method for issueing a DELETE request for the given URI.
+     * @throw Errors::HttpMethodNotSupported if the underlying implementation does not support the provided HTTP method.
+     * @param configuration The configuration to issue a get request for.
+     * @return An executable instance of class Request.
+     */
+    virtual std::shared_ptr<Request> del(const Request::Configuration& configuration) = 0;
+
 protected:
     Client() = default;
 };
 
=== modified file 'include/core/net/http/method.h'
--- include/core/net/http/method.h	2013-12-04 07:23:43 +0000
+++ include/core/net/http/method.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_METHOD_H_
 #define CORE_NET_HTTP_METHOD_H_
@@ -33,7 +34,8 @@
     get,
     head,
     post,
-    put
+    put,
+    del
 };
 }
 }
 
=== modified file 'include/core/net/http/request.h'
--- include/core/net/http/request.h	2014-05-06 11:05:04 +0000
+++ include/core/net/http/request.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_REQUEST_H_
 #define CORE_NET_HTTP_REQUEST_H_
@@ -248,6 +249,18 @@
     virtual void async_execute(const Handler& handler) = 0;
 
     /**
+     * @brief Pause the request
+     * @throw core::net::http::Error in case of http-related errors.
+     */
+    virtual void pause() = 0;
+
+    /**
+     * @brief Resume the request
+     * @throw core::net::http::Error in case of http-related errors.
+     */
+    virtual void resume() = 0;
+
+    /**
      * @brief Returns the input string in URL-escaped format.
      * @param s The string to be URL escaped.
      */
@@ -259,6 +272,14 @@
      */
     virtual std::string url_unescape(const std::string& s) = 0;
 
+    /**
+     * @brief Sets options for aborting the request.
+     * The request will be aborted if transfer speed belows \a limit bytes per second for \a time seconds
+     * @param limit The transfer speed in seconds.
+     * @param time waiting period(seconds) to abort the request.
+     */
+    virtual void abort_request_if(std::uint64_t limit, const std::chrono::seconds& time) = 0;
+
 protected:
     /** @cond */
     Request() = default;
 
=== modified file 'include/core/net/http/streaming_client.h'
--- include/core/net/http/streaming_client.h	2015-03-23 16:09:05 +0000
+++ include/core/net/http/streaming_client.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_STREAMING_CLIENT_H_
 #define CORE_NET_HTTP_STREAMING_CLIENT_H_
@@ -69,7 +70,17 @@
     * @return An executable instance of class Request.
     */
     virtual std::shared_ptr<StreamingRequest> streaming_post(const Request::Configuration& configuration, const std::string& payload, const std::string& type) = 0;
-
+    
+    /**
+    * @brief streaming_post is a convenience method for issuing a POST request for the given URI.
+    * @throw Errors::HttpMethodNotSupported if the underlying implementation does not support the pro vided HTTP method.
+    * @param configuration The configuration to issue a get request for.
+    * @param payload The data to be transmitted as part of the POST request.
+    * @param size Size of the payload data in bytes.
+    * @return An executable instance of class Request.
+    */
+    virtual std::shared_ptr<StreamingRequest> streaming_post(const Request::Configuration& configuration, std::istream& payload, std::size_t size) = 0;
+    
     /**
     * @brief streaming_post_form is a convenience method for issuing a POST request for the given URI, with url-encoded payload.
     * @throw Errors::HttpMethodNotSupported if the underlying implementation does not support the provided HTTP method.
@@ -78,6 +89,15 @@
     * @return An executable instance of class Request.
     */
     virtual std::shared_ptr<StreamingRequest> streaming_post_form(const Request::Configuration& configuration, const std::map<std::string, std::string>& values) = 0;
+
+
+    /**
+    * @brief streaming_del is a convenience method for issuing a DELETE request for the given URI.
+    * @throw Errors::HttpMethodNotSupported if the underlying implementation does not support the provided HTTP method.
+    * @param configuration The configuration to issue a del request for.
+    * @return An executable instance of class Request.
+    */
+    virtual std::shared_ptr<StreamingRequest> streaming_del(const Request::Configuration& configuration) = 0;
 };
 
 /** @brief Dispatches to the default implementation and returns a streaming client instance. */
 
=== modified file 'include/core/net/http/streaming_request.h'
--- include/core/net/http/streaming_request.h	2015-03-23 16:09:05 +0000
+++ include/core/net/http/streaming_request.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_STREAMING_REQUEST_H_
 #define CORE_NET_HTTP_STREAMING_REQUEST_H_
@@ -52,6 +53,18 @@
      * @return The response to the request.
      */
     virtual void async_execute(const Handler& handler, const DataHandler& dh) = 0;
+
+    /**
+    * @brief Pause the request
+    * @throw core::net::http::Error in case of http-related errors.
+    */
+    virtual void pause() = 0;
+  
+    /**
+    * @brief Resume the request
+    * @throw core::net::http::Error in case of http-related errors.
+    */
+    virtual void resume() = 0;
 };
 }
 }
 
=== modified file 'src/core/net/http/impl/curl/client.cpp'
--- src/core/net/http/impl/curl/client.cpp	2015-03-23 16:09:05 +0000
+++ src/core/net/http/impl/curl/client.cpp	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 
 #include "client.h"
@@ -176,6 +177,39 @@
     return std::shared_ptr<http::impl::curl::Request>{new http::impl::curl::Request{multi, handle}};
 }
 
+std::shared_ptr<http::impl::curl::Request> http::impl::curl::Client::post_impl(
+        const Request::Configuration& configuration,
+        std::istream& payload,
+        std::size_t size)
+{
+    ::curl::easy::Handle handle;
+    handle.method(http::Method::post)
+            .url(configuration.uri.c_str())
+            .header(configuration.header)
+            .on_read_data([&payload, size](void* dest, std::size_t in_size, std::size_t nmemb)
+            {
+                //use internal buffer size(in_size *nmemb) instread of size passed by parameter
+                //to avoid client crashing when sending large chuck of data via POST method
+                auto result = payload.readsome(static_cast<char *>(dest), in_size * nmemb);
+                return result;            
+            }, size);
+    
+    
+    handle.set_option(::curl::Option::post_field_size, size);
+    handle.set_option(::curl::Option::ssl_verify_host,
+                      configuration.ssl.verify_host ? ::curl::easy::enable_ssl_host_verification : ::curl::easy::disable);
+    handle.set_option(::curl::Option::ssl_verify_peer,
+                      configuration.ssl.verify_peer ? ::curl::easy::enable : ::curl::easy::disable);
+
+    if (configuration.authentication_handler.for_http)
+    {
+        auto credentials = configuration.authentication_handler.for_http(configuration.uri);
+        handle.http_credentials(credentials.username, credentials.password);
+    }
+
+    return std::shared_ptr<http::impl::curl::Request>{new http::impl::curl::Request{multi, handle}};
+}
+
 std::shared_ptr<http::impl::curl::Request> http::impl::curl::Client::put_impl(
         const Request::Configuration& configuration,
         std::istream& payload,
@@ -185,9 +219,11 @@
     handle.method(http::Method::put)
             .url(configuration.uri.c_str())
             .header(configuration.header)
-            .on_read_data([&payload, size](void* dest, std::size_t /*in_size*/, std::size_t /*nmemb*/)
+            .on_read_data([&payload, size](void* dest, std::size_t in_size, std::size_t nmemb)
             {
-                auto result = payload.readsome(static_cast<char*>(dest), size);
+                //use internal buffer size(in_size *nmemb) instread of size passed by parameter
+                //to avoid client crashing when sending large chuck of data via PUT method
+                auto result = payload.readsome(static_cast<char*>(dest), in_size * nmemb);
                 return result;
             }, size);
 
@@ -205,6 +241,27 @@
     return std::shared_ptr<http::impl::curl::Request>{new http::impl::curl::Request{multi, handle}};
 }
 
+std::shared_ptr<http::impl::curl::Request> http::impl::curl::Client::del_impl(const http::Request::Configuration& configuration)
+{
+    ::curl::easy::Handle handle;
+    handle.method(http::Method::del)
+          .url(configuration.uri.c_str())
+          .header(configuration.header);
+
+    handle.set_option(::curl::Option::ssl_verify_host,
+                      configuration.ssl.verify_host ? ::curl::easy::enable_ssl_host_verification : ::curl::easy::disable);
+    handle.set_option(::curl::Option::ssl_verify_peer,
+                      configuration.ssl.verify_peer ? ::curl::easy::enable : ::curl::easy::disable);
+
+    if (configuration.authentication_handler.for_http)
+    {
+        auto credentials = configuration.authentication_handler.for_http(configuration.uri);
+        handle.http_credentials(credentials.username, credentials.password);
+    }
+
+    return std::shared_ptr<http::impl::curl::Request>{new http::impl::curl::Request{multi, handle}};
+}
+
 std::shared_ptr<http::StreamingRequest> http::impl::curl::Client::streaming_get(const http::Request::Configuration& configuration)
 {
     return get_impl(configuration);
@@ -225,6 +282,11 @@
     return post_impl(configuration, payload, type);
 }
 
+std::shared_ptr<http::StreamingRequest> http::impl::curl::Client::streaming_post(const http::Request  ::Configuration& configuration, std::istream& payload, std::size_t size)
+{
+    return post_impl(configuration, payload, size);
+}
+  
 std::shared_ptr<http::StreamingRequest> http::impl::curl::Client::streaming_post_form(const http::Request::Configuration& configuration, const std::map<std::string, std::string>& values)
 {
     std::stringstream ss;
@@ -239,6 +301,11 @@
     return post_impl(configuration, ss.str(), http::ContentType::x_www_form_urlencoded);
 }
 
+std::shared_ptr<http::StreamingRequest> http::impl::curl::Client::streaming_del(const http::Request::Configuration& configuration)
+{
+    return del_impl(configuration);
+}
+
 std::shared_ptr<http::Request> http::impl::curl::Client::head(const http::Request::Configuration& configuration)
 {
     return head_impl(configuration);
@@ -257,6 +324,19 @@
     return post_impl(configuration, payload, ct);
 }
 
+std::shared_ptr<http::Request> http::impl::curl::Client::post(
+        const Request::Configuration& configuration,
+        std::istream& payload,
+        std::size_t size)
+{
+    return post_impl(configuration, payload, size);
+}
+
+std::shared_ptr<http::Request> http::impl::curl::Client::del(const Request::Configuration& configuration)
+{
+    return del_impl(configuration);
+}
+
 std::shared_ptr<http::Request> http::impl::curl::Client::put(
         const Request::Configuration& configuration,
         std::istream& payload,
 
=== modified file 'src/core/net/http/impl/curl/client.h'
--- src/core/net/http/impl/curl/client.h	2015-03-24 11:56:02 +0000
+++ src/core/net/http/impl/curl/client.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_IMPL_CURL_CLIENT_H_
 #define CORE_NET_HTTP_IMPL_CURL_CLIENT_H_
@@ -55,19 +56,25 @@
     std::shared_ptr<http::Request> get(const Request::Configuration& configuration) override;
     std::shared_ptr<http::Request> head(const Request::Configuration& configuration) override;
     std::shared_ptr<http::Request> post(const Request::Configuration& configuration, const std::string&, const std::string&) override;
+    std::shared_ptr<http::Request> post(const Request::Configuration& configuration, std::istream& payload, std::size_t size) override;
     std::shared_ptr<http::Request> put(const Request::Configuration& configuration, std::istream& payload, std::size_t size) override;
+    std::shared_ptr<http::Request> del(const Request::Configuration& configuration) override;
 
     std::shared_ptr<http::StreamingRequest> streaming_get(const Request::Configuration& configuration) override;
     std::shared_ptr<http::StreamingRequest> streaming_head(const Request::Configuration& configuration) override;
     std::shared_ptr<http::StreamingRequest> streaming_put(const Request::Configuration& configuration, std::istream& payload, std::size_t size) override;
     std::shared_ptr<http::StreamingRequest> streaming_post(const Request::Configuration& configuration, const std::string& payload, const std::string& type) override;
+    std::shared_ptr<http::StreamingRequest> streaming_post(const Request::Configuration& configuration, std::istream& payload, std::size_t size) override;
     std::shared_ptr<http::StreamingRequest> streaming_post_form(const Request::Configuration& configuration, const std::map<std::string, std::string>& values) override;
+    std::shared_ptr<http::StreamingRequest> streaming_del(const Request::Configuration& configuration) override;
 
 private:
     std::shared_ptr<curl::Request> get_impl(const Request::Configuration& configuration);
     std::shared_ptr<curl::Request> head_impl(const Request::Configuration& configuration);
     std::shared_ptr<curl::Request> post_impl(const Request::Configuration& configuration, const std::string&, const std::string&);
+    std::shared_ptr<curl::Request> post_impl(const Request::Configuration& configuration, std::istream& payload, std::size_t size);
     std::shared_ptr<curl::Request> put_impl(const Request::Configuration& configuration, std::istream& payload, std::size_t size);
+    std::shared_ptr<curl::Request> del_impl(const Request::Configuration& configuration);
 
     ::curl::multi::Handle multi;    
 };
 
=== modified file 'src/core/net/http/impl/curl/easy.cpp'
--- src/core/net/http/impl/curl/easy.cpp	2015-03-03 11:12:12 +0000
+++ src/core/net/http/impl/curl/easy.cpp	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 
 #include "easy.h"
@@ -96,6 +97,11 @@
     return static_cast<curl::Code>(curl_easy_perform(handle));
 }
 
+::curl::Code easy::native::pause(easy::native::Handle handle, int bitmask)
+{
+    return static_cast<curl::Code>(curl_easy_pause(handle, bitmask));
+}
+
 std::string easy::native::escape(easy::native::Handle handle, const std::string& in)
 {
     auto escaped = curl_easy_escape(handle, in.c_str(), in.size());
@@ -355,6 +361,8 @@
 {
     if (!d) throw easy::Handle::HandleHasBeenAbandoned{};
 
+    static constexpr const char* http_delete = "DELETE";
+
     switch(method)
     {
     case core::net::http::Method::get:
@@ -371,6 +379,9 @@
     case core::net::http::Method::put:
         set_option(Option::http_put, enable);
         break;
+    case core::net::http::Method::del:
+        set_option(Option::customrequest, http_delete);
+        break;
     default: throw core::net::http::Client::Errors::HttpMethodNotSupported{method, CORE_FROM_HERE()};
     }
 
@@ -431,6 +442,18 @@
     throw_if_not<curl::Code::ok>(easy::native::perform(native()), [this]() { return std::string{d->error};});
 }
 
+void easy::Handle::pause()
+{
+    if (!d) throw easy::Handle::HandleHasBeenAbandoned{};
+    throw_if_not<curl::Code::ok>(easy::native::pause(native(), CURLPAUSE_ALL), [this]() { return std::string{d->error};});
+}
+
+void easy::Handle::resume()
+{
+    if (!d) throw easy::Handle::HandleHasBeenAbandoned{};
+    throw_if_not<curl::Code::ok>(easy::native::pause(native(), CURLPAUSE_RECV_CONT), [this]() { return std::string{d->error};});
+}
+
 // URL escapes the given input string.
 std::string easy::Handle::escape(const std::string& in)
 {
 
=== modified file 'src/core/net/http/impl/curl/easy.h'
--- src/core/net/http/impl/curl/easy.h	2015-03-03 11:12:12 +0000
+++ src/core/net/http/impl/curl/easy.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_IMPL_CURL_EASY_H_
 #define CORE_NET_HTTP_IMPL_CURL_EASY_H_
@@ -136,7 +137,10 @@
     timeout_ms = CURLOPT_TIMEOUT_MS,
     ssl_engine_default = CURLOPT_SSLENGINE_DEFAULT,
     ssl_verify_peer = CURLOPT_SSL_VERIFYPEER,
-    ssl_verify_host = CURLOPT_SSL_VERIFYHOST
+    ssl_verify_host = CURLOPT_SSL_VERIFYHOST,
+    customrequest = CURLOPT_CUSTOMREQUEST,
+    low_speed_limit = CURLOPT_LOW_SPEED_LIMIT,
+    low_speed_time = CURLOPT_LOW_SPEED_TIME
 };
 
 namespace native
@@ -209,6 +213,9 @@
 // Executes the operation configured on the handle.
 ::curl::Code perform(Handle handle);
 
+// Executes pause operation on the handle.
+::curl::Code pause(Handle handle, int bitmask);
+
 // URL escapes the given input string.
 std::string escape(Handle handle, const std::string& in);
 
@@ -339,6 +346,12 @@
     // Executes the operation associated with this handle.
     void perform();
 
+    // Executes pause operation associated with this handle.
+    void pause();
+
+    // Executes resume operation associated with this handle.
+    void resume();
+
     // URL escapes the given input string.
     std::string escape(const std::string& in);
 
 
=== modified file 'src/core/net/http/impl/curl/request.h'
--- src/core/net/http/impl/curl/request.h	2015-03-23 16:09:05 +0000
+++ src/core/net/http/impl/curl/request.h	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 #ifndef CORE_NET_HTTP_IMPL_CURL_REQUEST_H_
 #define CORE_NET_HTTP_IMPL_CURL_REQUEST_H_
@@ -273,6 +274,28 @@
         multi.add(easy);
     }
 
+    void pause()
+    {   
+        try
+        {   
+            easy.pause();
+        } catch(const std::system_error& se)
+        {   
+            throw core::net::http::Error(se.what(), CORE_FROM_HERE());
+        }       
+    }       
+
+    void resume()
+    {   
+        try
+        {   
+            easy.resume();
+        } catch(const std::system_error& se)
+        {   
+            throw core::net::http::Error(se.what(), CORE_FROM_HERE());
+        }       
+    }       
+
     std::string url_escape(const std::string& s)
     {
         return easy.escape(s);
@@ -282,6 +305,16 @@
     {
         return easy.unescape(s);
     }
+
+    void abort_request_if(std::uint64_t limit, const std::chrono::seconds& time)
+    {
+        if (atomic_state.load() != core::net::http::Request::State::ready)
+            throw core::net::http::Request::Errors::AlreadyActive{CORE_FROM_HERE()};
+    
+        easy.set_option(::curl::Option::low_speed_limit, limit);
+        easy.set_option(::curl::Option::low_speed_time, time.count());
+    }
+
 private:
     std::atomic<core::net::http::Request::State> atomic_state;
     ::curl::multi::Handle multi;
 
=== modified file 'tests/http_client_test.cpp'
--- tests/http_client_test.cpp	2014-11-13 12:57:24 +0000
+++ tests/http_client_test.cpp	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 
 #include <core/net/error.h>
@@ -30,6 +31,7 @@
 #include <json/json.h>
 
 #include <future>
+#include <fstream>
 
 namespace http = core::net::http;
 namespace json = Json;
@@ -456,6 +458,33 @@
     EXPECT_EQ("test", root["form"]["test"].asString());
 }
 
+TEST(HttpClient, post_request_for_file_with_large_chunk_succeeds)
+{
+    auto client = http::make_client();
+    auto url = std::string(httpbin::host) + httpbin::resources::post();
+
+    // create temp file with large chunk
+    const std::size_t size = 1024*1024;
+    std::ofstream ofs("tmp.dat", std::ios::binary | std::ios::out);
+    ofs.seekp(size);
+    ofs.write("", 1);
+    ofs.close();
+
+    std::ifstream payload("tmp.dat");
+    auto request = client->post(http::Request::Configuration::from_uri_as_string(url),
+                                payload,
+                                size);
+
+    json::Value root;
+    json::Reader reader;
+
+    auto response = request->execute(default_progress_reporter);
+
+    EXPECT_EQ(core::net::http::Status::ok, response.status);
+    EXPECT_TRUE(reader.parse(response.body, root));
+    EXPECT_EQ(url, root["url"].asString());
+}
+
 TEST(HttpClient, put_request_for_existing_resource_succeeds)
 {
     auto client = http::make_client();
@@ -478,6 +507,50 @@
     EXPECT_EQ(payload.str(), root["data"].asString());
 }
 
+TEST(HttpClient, put_request_for_file_with_large_chunk_succeeds)
+{
+    auto client = http::make_client();
+    auto url = std::string(httpbin::host) + httpbin::resources::put();
+
+    // create temp file with large chunk
+    const std::size_t size = 1024*1024;
+    std::ofstream ofs("tmp.dat", std::ios::binary | std::ios::out);
+    ofs.seekp(size);
+    ofs.write("", 1);
+    ofs.close();
+
+    std::ifstream payload("tmp.dat");
+    auto request = client->put(http::Request::Configuration::from_uri_as_string(url),
+                               payload,
+                               size);
+
+    json::Value root;
+    json::Reader reader;
+
+    auto response = request->execute(default_progress_reporter);
+
+    EXPECT_EQ(core::net::http::Status::ok, response.status);
+    EXPECT_TRUE(reader.parse(response.body, root));
+    EXPECT_EQ(url, root["url"].asString());
+}
+
+TEST(HttpClient, del_request_for_existing_resource_succeeds)
+{
+    auto client = http::make_client();
+    auto url = std::string(httpbin::host) + httpbin::resources::del();
+
+    auto request = client->del(http::Request::Configuration::from_uri_as_string(url));
+
+    json::Value root;
+    json::Reader reader;
+
+    auto response = request->execute(default_progress_reporter);
+
+    EXPECT_EQ(core::net::http::Status::ok, response.status);
+    EXPECT_TRUE(reader.parse(response.body, root));
+    EXPECT_EQ(url, root["url"].asString());
+}
+
 namespace com
 {
 namespace mozilla
 
=== modified file 'tests/http_streaming_client_test.cpp'
--- tests/http_streaming_client_test.cpp	2015-03-23 16:24:27 +0000
+++ tests/http_streaming_client_test.cpp	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 
 #include <core/net/error.h>
@@ -33,6 +34,8 @@
 #include <future>
 #include <memory>
 
+#include <fstream>
+
 namespace http = core::net::http;
 namespace json = Json;
 namespace net = core::net;
@@ -480,6 +483,37 @@
     EXPECT_EQ("test", root["form"]["test"].asString());
 }
 
+TEST(StreamingHttpClient, post_request_for_file_with_large_chunk_succeeds)
+{
+    using namespace ::testing;
+
+    auto client = http::make_streaming_client();
+    auto url = std::string(httpbin::host) + httpbin::resources::post();
+  
+    // create temp file with large chunk
+    const std::size_t size = 1024*1024;
+    std::ofstream ofs("tmp.dat", std::ios::binary | std::ios::out);
+    ofs.seekp(size);
+    ofs.write("", 1);
+    ofs.close();
+  
+    std::ifstream payload("tmp.dat");
+    auto request = client->streaming_post(http::Request::Configuration::from_uri_as_string(url),
+                                payload,
+                                size);
+  
+    auto dh = MockDataHandler::create(); EXPECT_CALL(*dh, on_new_data(_)).Times(AtLeast(1));
+  
+    auto response = request->execute(default_progress_reporter, dh->to_data_handler());
+  
+    json::Value root;
+    json::Reader reader;
+
+    EXPECT_EQ(core::net::http::Status::ok, response.status);
+    EXPECT_TRUE(reader.parse(response.body, root));
+    EXPECT_EQ(url, root["url"].asString());
+}
+
 TEST(StreamingHttpClient, put_request_for_existing_resource_succeeds)
 {
     using namespace ::testing;
@@ -497,12 +531,66 @@
     // Our mocked data handler.
     auto dh = MockDataHandler::create(); EXPECT_CALL(*dh, on_new_data(_)).Times(AtLeast(1));
 
+    auto response = request->execute(default_progress_reporter, dh->to_data_handler());
+
     json::Value root;
     json::Reader reader;
 
-    auto response = request->execute(default_progress_reporter, dh->to_data_handler());
-
     EXPECT_EQ(core::net::http::Status::ok, response.status);
     EXPECT_TRUE(reader.parse(response.body, root));
     EXPECT_EQ(payload.str(), root["data"].asString());
 }
+
+TEST(StreamingHttpClient, put_request_for_file_with_large_chunk_succeeds)
+{
+    using namespace ::testing;
+
+    auto client = http::make_streaming_client();
+    auto url = std::string(httpbin::host) + httpbin::resources::put();
+  
+    // create temp file with large chunk
+    const std::size_t size = 1024*1024;
+    std::ofstream ofs("tmp.dat", std::ios::binary | std::ios::out);
+    ofs.seekp(size);
+    ofs.write("", 1); 
+    ofs.close();
+  
+    std::ifstream payload("tmp.dat");
+    auto request = client->streaming_put(http::Request::Configuration::from_uri_as_string(url),
+                               payload,
+                               size);
+  
+    auto dh = MockDataHandler::create(); EXPECT_CALL(*dh, on_new_data(_)).Times(AtLeast(1));
+
+    auto response = request->execute(default_progress_reporter, dh->to_data_handler());
+  
+    json::Value root;
+    json::Reader reader;
+  
+    EXPECT_EQ(core::net::http::Status::ok, response.status);
+    EXPECT_TRUE(reader.parse(response.body, root));
+    EXPECT_EQ(url, root["url"].asString());
+}
+
+TEST(StreamingHttpClient, del_request_for_existing_resource_succeeds)
+{
+    using namespace ::testing;
+
+    auto client = http::make_streaming_client();
+    auto url = std::string(httpbin::host) + httpbin::resources::del();
+  
+    auto request = client->streaming_del(http::Request::Configuration::from_uri_as_string(url));
+  
+    // Our mocked data handler.
+    auto dh = MockDataHandler::create(); EXPECT_CALL(*dh, on_new_data(_)).Times(AtLeast(1));
+
+    auto response = request->execute(default_progress_reporter, dh->to_data_handler());
+
+    json::Value root;
+    json::Reader reader;
+  
+    EXPECT_EQ(core::net::http::Status::ok, response.status);
+    EXPECT_TRUE(reader.parse(response.body, root));
+    EXPECT_EQ(url, root["url"].asString());
+}
+
 
=== modified file 'tests/httpbin.h.in'
--- tests/httpbin.h.in	2014-05-22 11:50:55 +0000
+++ tests/httpbin.h.in	2016-05-23 10:51:40 +0000
@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Thomas Voß <[e-mail]>
+ *              Gary Wang  <[e-mail]>
  */
 
 #ifndef HTTPBIN_H_
@@ -104,6 +105,11 @@
 {
     return "/put";
 }
+/** Returns DELETE data. */
+const char* del()
+{
+    return "/delete";
+}
 /** Challenges basic authentication. */
 const char* basic_auth()
 {