Merge lp:~gary-wzl77/net-cpp/reading_callback into lp:net-cpp

[Gary.Wang]

Support data reading call back function in streaming API. That makes possible to upload data into the server directly without local cache.

Support data reading call back function in streaming API. That makes possible to upload data into server directly without local cache.

[lp:~gary-wzl77/net-cpp/reading_callback]

58. By Gary.Wang on 2016-07-27

Fixes typo.

59. By Gary.Wang on 2016-08-01

fixes linking error against xenial and yakkety.

60. By Gary.Wang on 2016-08-01

fixes tests failure when bulding with gcc5.

61. By Gary.Wang on 2016-08-01

update symbols file.

62. By Gary.Wang on 2016-08-02

using small package for testing(pause_and_resume).

63. By Gary.Wang on 2016-08-02

don't ship symbol file.

64. By Gary.Wang on 2016-08-02

waits enough time for server process to launch.

sometimes tests failed when running them in yakkety(armhf). As while we start to run tests, server is not ready yet sometimes.

[James Henstridge (jamesh)]

So they don't get lost, here's a summary of the issues I outlined in email:

1. Currently the libnet-cpp.so.2 soname essentially means "libnet-cpp.so.1 recompiled with the new C++11 ABI". If you are breaking the ABI of net-cpp, then the result should not be called libnet-cpp.so.1 _or_ libnet-cpp.so.2.

2. Following on from that, the library should still have different sonames on either side of the C++11 ABI break, so perhaps .so.3 on vivid and .so.4 on newer distros. It is possible to handle this kind of split with a single source tree going through citrain's dual landings via the bileto_pre_release_hook system. The mediascanner2 package is probably one of the simpler examples of this.

3. Replacing the net-cpp package on vivid is a no-go. It is part of the base image that Click packages depend on, and is explicitly part of the ubuntu-sdk-libs meta-package. The packages for the new and old net-cpp need to be able to co-exist in the archive, which means different source package names, and a different development package name.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-04-01 06:23:30 +0000
+++ CMakeLists.txt	2016-08-02 06:33:04 +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 'debian/changelog'
--- debian/changelog	2015-04-15 12:34:49 +0000
+++ debian/changelog	2016-08-02 06:33:04 +0000
@@ -1,3 +1,16 @@
+net-cpp (2.0.0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Thomas Voß ]
+  [Gary Wang]
+  * Enable pause/resume of requests.
+  * Fix LP:#1570686 and LP:#1570687
+
+  [ Gary Wang ]
+  * Add data reading callback function in streaming http interface.
+  * Fix LP:#1605179
+
+ -- Thomas Voß <[e-mail]>  Thu, 21 Jul 2016 04:05:05 -0700
+
 net-cpp (1.2.0+15.04.20150415.2-0ubuntu1) vivid; urgency=medium
 
   [ Thomas Voß ]

=== modified file 'debian/control'
--- debian/control	2015-02-25 10:27:29 +0000
+++ debian/control	2016-08-02 06:33:04 +0000
@@ -6,10 +6,6 @@
                doxygen,
                google-mock,
                graphviz,
-# We rely on C++11 features, and to prevent from ABI breaks
-# in libstdc++ causing us issues, we explicitly select a G++
-# version.
-               g++-4.9,
                libboost-dev,
                libboost-serialization-dev,
                libboost-system-dev,
@@ -29,7 +25,7 @@
 Vcs-Bzr: https://code.launchpad.net/~phablet-team/net-cpp/trunk
 Vcs-Browser: https://bazaar.launchpad.net/~phablet-team/net-cpp/trunk/files
 
-Package: libnet-cpp1
+Package: libnet-cpp2
 Architecture: any
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends},
@@ -45,7 +41,7 @@
 Architecture: any
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends},
-Depends: libnet-cpp1 (= ${binary:Version}),
+Depends: libnet-cpp2 (= ${binary:Version}),
          ${misc:Depends},
 Description: C++11 library for networking purposes - runtime library
  Net-Cpp is a simple and straightforward networking library for C++11.

=== removed file 'debian/libnet-cpp1.symbols'
--- debian/libnet-cpp1.symbols	2015-03-23 16:24:27 +0000
+++ debian/libnet-cpp1.symbols	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-libnet-cpp.so.1 libnet-cpp1 #MINVER#
- (c++)"core::net::http::make_client()@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::make_streaming_client()@Base" 1.1.0+15.04.20150305-0ubuntu1
- (c++)"core::net::make_uri(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, std::vector<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > const&)@Base" 1.1.0+14.10.20140804
- (c++)"core::net::http::Client::uri_to_string(core::net::Uri const&) const@Base" 1.1.0+14.10.20140804
- (c++)"core::net::http::Client::Errors::HttpMethodNotSupported::HttpMethodNotSupported(core::net::http::Method, core::Location const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Client::Errors::HttpMethodNotSupported::~HttpMethodNotSupported()@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Client::post_form(core::net::http::Request::Configuration const&, std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::canonicalize_key(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::add(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::set(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::remove(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::remove(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::enumerate(std::function<void (std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::set<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&)> const&) const@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Credentials::~Credentials()@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Errors::AlreadyActive::AlreadyActive(core::Location const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Errors::AlreadyActive::~AlreadyActive()@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Handler::Handler(core::net::http::Request::Handler const&)@Base" 1.1.0+15.04.20141204
- (c++)"core::net::http::Request::Handler::~Handler()@Base" 1.1.0+15.04.20141204
- (c++)"core::net::http::Request::Handler::on_progress(std::function<core::net::http::Request::Progress::Next (core::net::http::Request::Progress const&)> const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Handler::on_response(std::function<void (core::net::http::Response const&)> const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Handler::on_error(std::function<void (core::net::Error const&)> const&)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Response::~Response()@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::operator<<(std::basic_ostream<char, std::char_traits<char> >&, core::net::http::Status)@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::has(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Header::has(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Handler::on_progress() const@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Handler::on_response() const@Base" 0.0.1+14.10.20140611
- (c++)"core::net::http::Request::Handler::on_error() const@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo for core::net::http::Client::Errors::HttpMethodNotSupported@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo for core::net::http::Client@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo for core::net::http::Header@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo for core::net::http::Request::Errors::AlreadyActive@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo for core::net::http::Request@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo name for core::net::http::Client::Errors::HttpMethodNotSupported@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo name for core::net::http::Client@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo name for core::net::http::Header@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo name for core::net::http::Request::Errors::AlreadyActive@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo name for core::net::http::Request@Base" 0.0.1+14.10.20140611
- (c++)"vtable for core::net::http::Client::Errors::HttpMethodNotSupported@Base" 0.0.1+14.10.20140611
- (c++)"vtable for core::net::http::Client@Base" 0.0.1+14.10.20140611
- (c++)"vtable for core::net::http::Header@Base" 0.0.1+14.10.20140611
- (c++)"vtable for core::net::http::Request::Errors::AlreadyActive@Base" 0.0.1+14.10.20140611
- (c++)"vtable for core::net::http::Request@Base" 0.0.1+14.10.20140611
- (c++)"typeinfo for core::net::http::StreamingRequest@Base" 1.1.0+15.04.20150305-0ubuntu1
- (c++)"typeinfo name for core::net::http::StreamingRequest@Base" 1.1.0+15.04.20150305-0ubuntu1
- (c++)"vtable for core::net::http::StreamingRequest@Base" 1.1.0+15.04.20150305-0ubuntu1
\ No newline at end of file

=== renamed file 'debian/libnet-cpp1.install' => 'debian/libnet-cpp2.install'
=== modified file 'debian/rules'
--- debian/rules	2014-06-27 08:16:12 +0000
+++ debian/rules	2016-08-02 06:33:04 +0000
@@ -5,13 +5,5 @@
 
 include /usr/share/dpkg/default.mk
 
-# Explicitly selecting a G{CC,++}-version here to avoid accidental
-# ABI breaks introduced by toolchain updates.
-export CC=$(DEB_HOST_GNU_TYPE)-gcc-4.9
-export CXX=$(DEB_HOST_GNU_TYPE)-g++-4.9
-
 %:
 	dh $@ --fail-missing
-
-override_dh_auto_configure:
-	dh_auto_configure -- -DCMAKE_C_COMPILER=$(CC) -DCMAKE_CXX_COMPILER=$(CXX)

=== 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-08-02 06:33:04 +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-08-02 06:33:04 +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-08-02 06:33:04 +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_
@@ -212,6 +213,13 @@
             /** Invoked for querying user credentials to authenticate proxy accesses. */
             AuthenicationHandler for_proxy;
         } authentication_handler;
+
+        /** Encapsulates thresholds for minimum transfer speed in [kB/s] for duration seconds. */
+        struct
+        {
+            std::uint64_t limit{1};
+            std::chrono::seconds duration{std::chrono::seconds{30}};
+        } speed;
     };
 
     Request(const Request&) = delete;
@@ -248,6 +256,19 @@
     virtual void async_execute(const Handler& handler) = 0;
 
     /**
+     * @brief Pause the request with options for aborting the request.
+     * The request will be aborted if transfer speed falls below \a limit in [bytes/second] for \a time seconds.
+     * @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.
      */

=== 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-08-02 06:33:04 +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_
@@ -61,6 +62,17 @@
     virtual std::shared_ptr<StreamingRequest> streaming_put(const Request::Configuration& configuration, std::istream& payload, std::size_t size) = 0;
 
     /**
+    * @brief streaming_put is a convenience method for issuing a PUT 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.
+    * @param readdata_callback The callback function to read data in order to send it to the peer.
+    *        The data area pointed at by the pointer \a dest should be filled up with at most \a buf_size number of bytes.
+    * @param size Size of the payload data in bytes.
+    * @return An executable instance of class Request.
+    */
+    virtual std::shared_ptr<StreamingRequest> streaming_put(const Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, std::size_t size) = 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 provided HTTP method.
     * @param configuration The configuration to issue a get request for.
@@ -69,8 +81,29 @@
     * @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 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 readdata_callback The callback function to read data in order to send it to the peer.
+    *        The data area pointed at by the pointer \a dest should be filled up with at most \a buf_size number of bytes.
+    * @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::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, 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.
     * @param configuration The configuration to issue a get request for.
@@ -78,6 +111,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-08-02 06:33:04 +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_

=== 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-08-02 06:33:04 +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"
@@ -35,6 +36,11 @@
 namespace
 {
 const std::string BASE64_PADDING[] = { "", "==", "=" };
+template<typename To, typename From>
+To cast_without_overflow(From from)
+{
+    return static_cast<To>(std::min<From>(std::numeric_limits<To>::max(), from));
+}
 }
 
 http::impl::curl::Client::Client()
@@ -120,6 +126,8 @@
                       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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
 
     if (configuration.authentication_handler.for_http)
     {
@@ -141,6 +149,8 @@
                       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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
 
     if (configuration.authentication_handler.for_http)
     {
@@ -166,6 +176,86 @@
                       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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
+
+    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::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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
+
+    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::post_impl(
+        const Request::Configuration& configuration,
+        std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback,
+        std::size_t size)
+{
+    ::curl::easy::Handle handle;
+    handle.method(http::Method::post)
+            .url(configuration.uri.c_str())
+            .header(configuration.header)
+            .on_read_data([readdata_callback, size](void* dest, std::size_t in_size, std::size_t nmemb)
+            {
+                if(readdata_callback) {
+                    try 
+                    {
+                        return readdata_callback(dest, in_size * nmemb);
+                    } catch (...) 
+                    {
+                        //Just ignoring errors here.
+                    }
+                }
+
+                //stop the current operation immediately
+                return (size_t)::curl::Code::no_readfunc_abort;
+            }, 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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
 
     if (configuration.authentication_handler.for_http)
     {
@@ -185,9 +275,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);
 
@@ -195,6 +287,72 @@
                       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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
+
+    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::function<size_t(void *dest, std::size_t buf_size)> readdata_callback,
+        std::size_t size)
+{
+    ::curl::easy::Handle handle;
+    handle.method(http::Method::put)
+            .url(configuration.uri.c_str())
+            .header(configuration.header)
+            .on_read_data([readdata_callback, size](void* dest, std::size_t in_size, std::size_t nmemb)
+            {
+                if(readdata_callback) {
+                    try 
+                    {
+                        return readdata_callback(dest, in_size * nmemb);
+                    } catch (...) 
+                    {
+                        //Just ignoring errors here.
+                    }
+                }
+
+                //stop the current operation immediately
+                return (size_t)::curl::Code::no_readfunc_abort;
+            }, 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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
+
+    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::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);
+    handle.set_option(::curl::Option::low_speed_limit, cast_without_overflow<long>(configuration.speed.limit));
+    handle.set_option(::curl::Option::low_speed_time, cast_without_overflow<long>(configuration.speed.duration.count()));
 
     if (configuration.authentication_handler.for_http)
     {
@@ -220,11 +378,26 @@
     return put_impl(configuration, payload, size);
 }
 
+std::shared_ptr<http::StreamingRequest> http::impl::curl::Client::streaming_put(const http::Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, std::size_t size)
+{
+    return put_impl(configuration, readdata_callback, size);
+}
+
 std::shared_ptr<http::StreamingRequest> http::impl::curl::Client::streaming_post(const http::Request::Configuration& configuration, const std::string& payload, const std::string& type)
 {
     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(const http::Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, std::size_t size)
+{
+    return post_impl(configuration, readdata_callback, 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 +412,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 +435,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-08-02 06:33:04 +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,29 @@
     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_put(const Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, 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(const Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, 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> post_impl(const Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, 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> put_impl(const Request::Configuration& configuration, std::function<size_t(void *dest, std::size_t buf_size)> readdata_callback, 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-08-02 06:33:04 +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_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-08-02 06:33:04 +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_
@@ -88,7 +89,8 @@
     ssl_crl_bad_file = CURLE_SSL_CRL_BADFILE,
     ssl_issuer_error = CURLE_SSL_ISSUER_ERROR,
     chunk_failed = CURLE_CHUNK_FAILED,
-    no_connection_available = CURLE_NO_CONNECTION_AVAILABLE
+    no_connection_available = CURLE_NO_CONNECTION_AVAILABLE,
+    no_readfunc_abort = CURL_READFUNC_ABORT
 };
 
 std::ostream& operator<<(std::ostream& out, Code code);
@@ -136,7 +138,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 +214,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 +347,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/multi.cpp'
--- src/core/net/http/impl/curl/multi.cpp	2015-02-25 10:26:38 +0000
+++ src/core/net/http/impl/curl/multi.cpp	2016-08-02 06:33:04 +0000
@@ -285,6 +285,11 @@
     return result;
 }
 
+void multi::Handle::dispatch(const std::function<void ()> &task)
+{
+    d->dispatcher.post(task);
+}
+
 void multi::Handle::run()
 {
     d->dispatcher.run();

=== modified file 'src/core/net/http/impl/curl/multi.h'
--- src/core/net/http/impl/curl/multi.h	2014-03-13 20:50:36 +0000
+++ src/core/net/http/impl/curl/multi.h	2016-08-02 06:33:04 +0000
@@ -140,6 +140,9 @@
     // Queries statistics about the timing information of the last transfers.
     core::net::http::Client::Timings timings();
 
+    // Dispatch dispatches task on the underlying reactor.
+    void dispatch(const std::function<void()>& task);
+
     // Executes the underlying dispatcher executing the curl multi instance.
     // Can be called multiple times for thread-pool use-cases.
     void run();

=== 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-08-02 06:33:04 +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_
@@ -241,7 +242,6 @@
                 case Request::Progress::Next::abort_operation: result = 1; break;
                 case Request::Progress::Next::continue_operation: result = 0; break;
                 }
-
                 return result;
             });
         }
@@ -273,6 +273,34 @@
         multi.add(easy);
     }
 
+    void pause()
+    {
+        auto copy = easy;
+        multi.dispatch([copy]() mutable
+        {
+            try
+            {
+                copy.pause();
+            }
+            catch(...) {}
+        });
+
+    }       
+
+    void resume()
+    {
+        auto copy = easy;
+        multi.dispatch([copy]() mutable
+        {
+            try
+            {
+                copy.resume();
+            }
+            catch(...) {}
+
+        });
+    }
+
     std::string url_escape(const std::string& s)
     {
         return easy.escape(s);
@@ -282,6 +310,7 @@
     {
         return easy.unescape(s);
     }
+
 private:
     std::atomic<core::net::http::Request::State> atomic_state;
     ::curl::multi::Handle multi;

=== modified file 'tests/http_client_load_test.cpp'
--- tests/http_client_load_test.cpp	2014-05-14 10:07:20 +0000
+++ tests/http_client_load_test.cpp	2016-08-02 06:33:04 +0000
@@ -117,7 +117,7 @@
     return true;
 }
 
-static const bool is_initialized = init();
+static const bool is_initialized __attribute__((used)) = init();
 }
 
 TEST_F(HttpClientLoadTest, async_head_request_for_existing_resource_succeeds)

=== 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-08-02 06:33:04 +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;
@@ -53,7 +55,7 @@
     return true;
 }
 
-static const bool is_initialized = init();
+static const bool is_initialized __attribute__((used)) = init();
 }
 
 TEST(HttpClient, uri_to_string)
@@ -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-08-02 06:33:04 +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,10 @@
 #include <future>
 #include <memory>
 
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+
 namespace http = core::net::http;
 namespace json = Json;
 namespace net = core::net;
@@ -64,23 +69,50 @@
     MockDataHandler() = default;
 };
 
-auto default_progress_reporter = [](const http::Request::Progress& progress)
-{
-    if (progress.download.current > 0. && progress.download.total > 0.)
-        std::cout << "Download progress: " << progress.download.current / progress.download.total << std::endl;
-    if (progress.upload.current > 0. && progress.upload.total > 0.)
-        std::cout << "Upload progress: " << progress.upload.current / progress.upload.total << std::endl;
-
+class ProgressBar
+{
+public:
+    ProgressBar(std::uint32_t width)
+        : width{width}, out{std::cout}
+    {
+    }
+
+    ~ProgressBar()
+    {
+        out << std::endl;
+    }
+
+    void update(double percentage)
+    {
+        struct CursorState
+        {
+            CursorState(std::ostream& out) : out{out} { out << "\33[?25l"; }
+            ~CursorState()                            { out << "\33[?25h"; }
+            std::ostream& out;
+        } cs{out};
+
+        out << "\r" << "[" << std::setw(width) << std::left << std::setfill(' ') << std::string(percentage * width, '=') << "] " << std::setw(5) << std::fixed << std::setprecision(2) << percentage * 100 << " %" << std::flush;
+    }
+
+private:
+    std::uint32_t width;
+    std::ostream& out;
+};
+
+auto silent_progress_reporter = [](const http::Request::Progress&)
+{
     return http::Request::Progress::Next::continue_operation;
 };
 
+auto default_progress_reporter = silent_progress_reporter;
+
 bool init()
 {
     static httpbin::Instance instance;
     return true;
 }
 
-static const bool is_initialized = init();
+static const bool is_initialized __attribute__((used)) = init();
 }
 
 TEST(StreamingStreamingHttpClient, head_request_for_existing_resource_succeeds)
@@ -480,6 +512,70 @@
     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, post_request_for_file_with_large_chunk_with_read_callback)
+{
+    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](void *dest, size_t buf_size) -> size_t {
+                                    return payload.readsome(static_cast<char *>(dest), buf_size);
+                                },
+                                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 +593,157 @@
     // 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, put_request_for_file_with_large_chunk_with_read_callback)
+{
+    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](void *dest, size_t buf_size) -> size_t {
+                                    return payload.readsome(static_cast<char *>(dest), buf_size);
+                                },
+                               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());
+}
+
+TEST(StreamingHttpClient, request_can_be_paused_and_resumed)
+{
+    using namespace ::testing;
+    // We obtain a default client instance, dispatching to the default implementation.
+    auto client = http::make_streaming_client();
+
+    // Execute the client
+    std::thread worker{[client]() { client->run(); }};
+
+    auto url = "http://archive.ubuntu.com/ubuntu/dists/xenial/main/installer-amd64/current/images/netboot/ubuntu-installer/amd64/linux";
+
+    // The client mostly acts as a factory for http requests.
+    auto request = client->streaming_get(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));
+
+    std::promise<core::net::http::Response> promise;
+    auto future = promise.get_future();
+
+    ProgressBar pb{80};
+
+    // We finally execute the query asynchronously.
+    request->async_execute(http::Request::Handler()
+        .on_progress([&pb](const http::Request::Progress& progress)
+        {
+            if (progress.download.current > 0. && progress.download.total > 0.)
+                pb.update(progress.download.current / static_cast<double>(progress.download.total));
+            return http::Request::Progress::Next::continue_operation;
+        })
+        .on_response([&](const core::net::http::Response& response)
+        {
+            promise.set_value(response);
+        })
+        .on_error([&](const core::net::Error& e)
+        {
+            promise.set_exception(std::make_exception_ptr(e));
+        }),
+        dh->to_data_handler());
+
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+
+    request->pause();
+    request->resume();
+
+    try
+    {
+        // This might very well throw.
+        EXPECT_EQ(core::net::http::Status::ok, future.get().status);
+    } catch (const std::exception& e) { FAIL() << e.what(); }
+
+    client->stop();
+
+    // We shut down our worker thread
+    if (worker.joinable())
+        worker.join();    
+}
+

=== modified file 'tests/httpbin.h.in'
--- tests/httpbin.h.in	2014-05-22 11:50:55 +0000
+++ tests/httpbin.h.in	2016-08-02 06:33:04 +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_
@@ -44,7 +45,7 @@
               core::posix::exec("/usr/bin/python", {"@CMAKE_CURRENT_BINARY_DIR@/httpbin/run.py"}, {}, core::posix::StandardStream::stdout | core::posix::StandardStream::stderr)
           }
     {
-        std::this_thread::sleep_for(std::chrono::milliseconds{500});
+        std::this_thread::sleep_for(std::chrono::milliseconds{1000});
     }
 
     ~Instance()
@@ -104,6 +105,11 @@
 {
     return "/put";
 }
+/** Returns DELETE data. */
+const char* del()
+{
+    return "/delete";
+}
 /** Challenges basic authentication. */
 const char* basic_auth()
 {