Don't use async_write_msg in examples

fix #746

example/http/server/async-ssl/CMakeLists.txt

@@ -14,7 +14,6 @@ GroupSources(example/http/server/async-ssl "/")
 add_executable (http-server-async-ssl
     ${BOOST_BEAST_INCLUDES}
     ${PROJECT_SOURCE_DIR}/example/common/server_certificate.hpp
-    ${PROJECT_SOURCE_DIR}/example/common/write_msg.hpp
     Jamfile
     http_server_async_ssl.cpp
 )

example/http/server/async-ssl/http_server_async_ssl.cpp

@@ -14,7 +14,6 @@
 //------------------------------------------------------------------------------
 
 #include "example/common/server_certificate.hpp"
-#include "example/common/write_msg.hpp"
 
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
@@ -231,12 +230,20 @@ class session : public std::enable_shared_from_this<session>
         void
         operator()(http::message<isRequest, Body, Fields>&& msg) const
         {
-            // This function takes ownership of the message by moving
-            // it into a temporary buffer, otherwise we would have
-            // to manage the lifetime of the message and serializer.
-            async_write_msg(
+            // The lifetime of the message has to extend
+            // for the duration of the async operation so
+            // we use a shared_ptr to manage it.
+            auto sp = std::make_shared<
+                http::message<isRequest, Body, Fields>>(std::move(msg));
+
+            // Store a type-erased version of the shared
+            // pointer in the class to keep it alive.
+            self_.res_ = sp;
+
+            // Write the response
+            http::async_write(
                 self_.stream_,
-                std::move(msg),
+                *sp,
                 self_.strand_.wrap(std::bind(
                     &session::on_write,
                     self_.shared_from_this(),
@@ -250,6 +257,7 @@ class session : public std::enable_shared_from_this<session>
     boost::beast::flat_buffer buffer_;
     std::string const& doc_root_;
     http::request<http::string_body> req_;
+    std::shared_ptr<void> res_;
     send_lambda lambda_;
 
 public:
@@ -327,6 +335,9 @@ public:
         if(ec)
             return fail(ec, "write");
 
+        // We're done with the response so delete it
+        res_ = nullptr;
+
         // Read another request
         do_read();
     }

example/http/server/async/CMakeLists.txt

@@ -8,12 +8,10 @@
 #
 
 GroupSources(include/boost/beast beast)
-GroupSources(example/common common)
 GroupSources(example/http/server/async "/")
 
 add_executable (http-server-async
     ${BOOST_BEAST_INCLUDES}
-    ${PROJECT_SOURCE_DIR}/example/common/write_msg.hpp
     Jamfile
     http_server_async.cpp
 )

example/http/server/async/http_server_async.cpp

@@ -13,8 +13,6 @@
 //
 //------------------------------------------------------------------------------
 
-#include "example/common/write_msg.hpp"
-
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
 #include <boost/beast/version.hpp>
@@ -228,12 +226,20 @@ class session : public std::enable_shared_from_this<session>
         void
         operator()(http::message<isRequest, Body, Fields>&& msg) const
         {
-            // This function takes ownership of the message by moving
-            // it into a temporary buffer, otherwise we would have
-            // to manage the lifetime of the message and serializer.
-            async_write_msg(
+            // The lifetime of the message has to extend
+            // for the duration of the async operation so
+            // we use a shared_ptr to manage it.
+            auto sp = std::make_shared<
+                http::message<isRequest, Body, Fields>>(std::move(msg));
+
+            // Store a type-erased version of the shared
+            // pointer in the class to keep it alive.
+            self_.res_ = sp;
+
+            // Write the response
+            http::async_write(
                 self_.socket_,
-                std::move(msg),
+                *sp,
                 self_.strand_.wrap(std::bind(
                     &session::on_write,
                     self_.shared_from_this(),
@@ -246,6 +252,7 @@ class session : public std::enable_shared_from_this<session>
     boost::beast::flat_buffer buffer_;
     std::string const& doc_root_;
     http::request<http::string_body> req_;
+    std::shared_ptr<void> res_;
     send_lambda lambda_;
 
 public:
@@ -306,6 +313,9 @@ public:
         if(ec)
             return fail(ec, "write");
 
+        // We're done with the response so delete it
+        res_ = nullptr;
+
         // Read another request
         do_read();
     }

example/http/server/flex/CMakeLists.txt

@@ -15,7 +15,6 @@ add_executable (http-server-flex
     ${BOOST_BEAST_INCLUDES}
     ${PROJECT_SOURCE_DIR}/example/common/detect_ssl.hpp
     ${PROJECT_SOURCE_DIR}/example/common/server_certificate.hpp
-    ${PROJECT_SOURCE_DIR}/example/common/write_msg.hpp
     Jamfile
     http_server_flex.cpp
 )

example/http/server/flex/http_server_flex.cpp

@@ -15,7 +15,6 @@
 
 #include "example/common/detect_ssl.hpp"
 #include "example/common/server_certificate.hpp"
-#include "example/common/write_msg.hpp"
 
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
@@ -242,12 +241,20 @@ class session
         void
         operator()(http::message<isRequest, Body, Fields>&& msg) const
         {
-            // This function takes ownership of the message by moving
-            // it into a temporary buffer, otherwise we would have
-            // to manage the lifetime of the message and serializer.
-            async_write_msg(
+            // The lifetime of the message has to extend
+            // for the duration of the async operation so
+            // we use a shared_ptr to manage it.
+            auto sp = std::make_shared<
+                http::message<isRequest, Body, Fields>>(std::move(msg));
+
+            // Store a type-erased version of the shared
+            // pointer in the class to keep it alive.
+            self_.res_ = sp;
+
+            // Write the response
+            http::async_write(
                 self_.derived().stream(),
-                std::move(msg),
+                *sp,
                 self_.strand_.wrap(std::bind(
                     &session::on_write,
                     self_.derived().shared_from_this(),
@@ -257,6 +264,7 @@ class session
 
     std::string const& doc_root_;
     http::request<http::string_body> req_;
+    std::shared_ptr<void> res_;
     send_lambda lambda_;
 
 protected:
@@ -318,6 +326,9 @@ public:
         if(ec)
             return fail(ec, "write");
 
+        // We're done with the response so delete it
+        res_ = nullptr;
+
         // Read another request
         do_read();
     }

example/http/server/stackless-ssl/CMakeLists.txt

@@ -14,7 +14,6 @@ GroupSources(example/http/server/stackless-ssl "/")
 add_executable (http-server-stackless-ssl
     ${BOOST_BEAST_INCLUDES}
     ${PROJECT_SOURCE_DIR}/example/common/server_certificate.hpp
-    ${PROJECT_SOURCE_DIR}/example/common/write_msg.hpp
     Jamfile
     http_server_stackless_ssl.cpp
 )

example/http/server/stackless-ssl/http_server_stackless_ssl.cpp

@@ -14,7 +14,6 @@
 //------------------------------------------------------------------------------
 
 #include "example/common/server_certificate.hpp"
-#include "example/common/write_msg.hpp"
 
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
@@ -234,12 +233,20 @@ class session
         void
         operator()(http::message<isRequest, Body, Fields>&& msg) const
         {
-            // This function takes ownership of the message by moving
-            // it into a temporary buffer, otherwise we would have
-            // to manage the lifetime of the message and serializer.
-            async_write_msg(
-                self_.stream_,
-                std::move(msg),
+            // The lifetime of the message has to extend
+            // for the duration of the async operation so
+            // we use a shared_ptr to manage it.
+            auto sp = std::make_shared<
+                http::message<isRequest, Body, Fields>>(std::move(msg));
+
+            // Store a type-erased version of the shared
+            // pointer in the class to keep it alive.
+            self_.res_ = sp;
+
+            // Write the response
+            http::async_write(
+                self_.socket_,
+                *sp,
                 self_.strand_.wrap(std::bind(
                     &session::loop,
                     self_.shared_from_this(),
@@ -253,6 +260,7 @@ class session
     boost::beast::flat_buffer buffer_;
     std::string const& doc_root_;
     http::request<http::string_body> req_;
+    std::shared_ptr<void> res_;
     send_lambda lambda_;
 
 public:
@@ -319,6 +327,9 @@ public:
                 }
                 if(ec)
                     return fail(ec, "write");
+
+                // We're done with the response so delete it
+                res_ = nullptr;
             }
 
             // Perform the SSL shutdown

example/http/server/stackless/CMakeLists.txt

@@ -8,12 +8,10 @@
 #
 
 GroupSources(include/boost/beast beast)
-GroupSources(example/common common)
 GroupSources(example/http/server/stackless "/")
 
 add_executable (http-server-stackless
     ${BOOST_BEAST_INCLUDES}
-    ${PROJECT_SOURCE_DIR}/example/common/write_msg.hpp
     Jamfile
     http_server_stackless.cpp
 )

example/http/server/stackless/http_server_stackless.cpp

@@ -13,8 +13,6 @@
 //
 //------------------------------------------------------------------------------
 
-#include "example/common/write_msg.hpp"
-
 #include <boost/beast/core.hpp>
 #include <boost/beast/http.hpp>
 #include <boost/beast/version.hpp>
@@ -220,6 +218,7 @@ class session
     struct send_lambda
     {
         session& self_;
+        std::shared_ptr<void> res_;
 
         explicit
         send_lambda(session& self)
@@ -231,12 +230,20 @@ class session
         void
         operator()(http::message<isRequest, Body, Fields>&& msg) const
         {
-            // This function takes ownership of the message by moving
-            // it into a temporary buffer, otherwise we would have
-            // to manage the lifetime of the message and serializer.
-            async_write_msg(
+            // The lifetime of the message has to extend
+            // for the duration of the async operation so
+            // we use a shared_ptr to manage it.
+            auto sp = std::make_shared<
+                http::message<isRequest, Body, Fields>>(std::move(msg));
+
+            // Store a type-erased version of the shared
+            // pointer in the class to keep it alive.
+            self_.res_ = sp;
+
+            // Write the response
+            http::async_write(
                 self_.socket_,
-                std::move(msg),
+                *sp,
                 self_.strand_.wrap(std::bind(
                     &session::loop,
                     self_.shared_from_this(),
@@ -249,6 +256,7 @@ class session
     boost::beast::flat_buffer buffer_;
     std::string const& doc_root_;
     http::request<http::string_body> req_;
+    std::shared_ptr<void> res_;
     send_lambda lambda_;
 
 public:
@@ -303,6 +311,9 @@ public:
                 }
                 if(ec)
                     return fail(ec, "write");
+
+                // We're done with the response so delete it
+                res_ = nullptr;
             }
 
             // Send a TCP shutdown