shutdown plain socket

cwaldren-ld · cwaldren-ld · commit 2dbdd2926c8a · 2024-04-03T12:39:22.000-07:00
diff --git a/libs/client-sdk/src/data_sources/streaming_data_source.cpp b/libs/client-sdk/src/data_sources/streaming_data_source.cpp
@@ -12,6 +12,7 @@
 #include <boost/json.hpp>
 #include <boost/url.hpp>
 
+#include <iostream>
 #include <utility>
 
 namespace launchdarkly::client_side::data_sources {
diff --git a/libs/server-sent-events/src/client.cpp b/libs/server-sent-events/src/client.cpp
@@ -44,13 +44,6 @@ auto const kDefaultInitialReconnectDelay = std::chrono::seconds(1);
 // Maximum duration between backoff attempts.
 auto const kDefaultMaxBackoffDelay = std::chrono::seconds(30);
 
-// When we shut down the SSL stream using async_shutdown operation, it
-// appears that the completion handler isn't invoked for about 5 minutes. Either
-// we or the server are misbehaving here. In any case, there is no need to wait
-// 5 minutes, we should give a couple seconds to receive a valid response or
-// else stop waiting.
-auto const kShutdownTimeout = std::chrono::seconds(10);
-
 static boost::optional<net::ssl::context&> ToOptRef(
     std::optional<net::ssl::context>& maybe_val) {
     if (maybe_val) {
@@ -65,6 +58,7 @@ class FoxyClient : public Client,
     using cb = std::function<void(launchdarkly::sse::Event)>;
     using body = launchdarkly::sse::detail::EventBody<cb>;
     using response = http::response<body>;
+    int count;
 
    public:
     FoxyClient(boost::asio::any_io_executor executor,
@@ -97,7 +91,8 @@ class FoxyClient : public Client,
               kDefaultMaxBackoffDelay),
           backoff_timer_(std::move(executor)),
           last_read_(std::nullopt),
-          shutting_down_(false) {
+          shutting_down_(false),
+          count(get_counter()) {
         create_session();
         create_parser();
     }
@@ -292,6 +287,10 @@ class FoxyClient : public Client,
                 // if we're shutting down, so shutting_down_ is needed to
                 // disambiguate.
                 if (shutting_down_) {
+                    boost::system::error_code ec = {};
+                    session_->stream.plain().shutdown(
+                        boost::asio::ip::tcp::socket::shutdown_both, ec);
+                    session_->stream.plain().close(ec);
                     return;
                 }
                 errors_(Error::ReadTimeout);
@@ -336,7 +335,6 @@ class FoxyClient : public Client,
     }
 
     void async_shutdown(std::function<void()> completion) override {
-        std::cout << "shutdown requested, posting..\n";
         // Get on the session's executor, otherwise the code in the completion
         // handler could race.
         boost::asio::post(session_->get_executor(),
@@ -345,25 +343,14 @@ class FoxyClient : public Client,
                                                     std::move(completion)));
     }
 
-    void on_shutdown_write() { std::cout << "shutdown write completed\n"; }
     void do_shutdown(std::function<void()> completion) {
-        std::cout << "shutdown request executing..\n";
         shutting_down_ = true;
         backoff_timer_.cancel();
         if (session_->stream.is_ssl()) {
             session_->stream.ssl().next_layer().cancel();
         } else {
             session_->stream.plain().cancel();
         }
-        session_->opts.timeout = kShutdownTimeout;
-        session_->async_shutdown(beast::bind_front_handler(
-            &FoxyClient::on_shutdown, shared_from_this(),
-            std::move(completion)));
-        // Run async_write with a single null byte:
-        session_->stream.async_write_some(
-            net::buffer("\0", 1),
-            beast::bind_front_handler(&FoxyClient::on_shutdown_write,
-                                      shared_from_this()));
     }
 
     void on_shutdown(std::function<void()> completion,
diff --git a/vendor/foxy/include/foxy/impl/client_session/async_shutdown.impl.hpp b/vendor/foxy/include/foxy/impl/client_session/async_shutdown.impl.hpp
@@ -1,9 +1,8 @@
 //
-// Copyright (c) 2018-2019 Christian Mazakas (christian dot mazakas at gmail dot
-// com)
+// Copyright (c) 2018-2019 Christian Mazakas (christian dot mazakas at gmail dot com)
 //
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+// Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // Official repository: https://github.com/LeonineKing1199/foxy
 //
@@ -12,50 +11,39 @@
 #define FOXY_IMPL_CLIENT_SESSION_ASYNC_SHUTDOWN_IMPL_HPP_
 
 #include <foxy/client_session.hpp>
-#include <iostream>
-namespace launchdarkly::foxy {
+
+namespace launchdarkly::foxy
+{
 template <class DynamicBuffer>
 template <class ShutdownHandler>
-auto basic_client_session<DynamicBuffer>::async_shutdown(
-    ShutdownHandler&& handler) & ->
-    typename boost::asio::async_result<
-        std::decay_t<ShutdownHandler>,
-        void(boost::system::error_code)>::return_type {
-    return ::launchdarkly::foxy::detail::async_timer<void(
-        boost::system::error_code)>(
-        [self = this, coro = boost::asio::coroutine()](
-            auto& cb, boost::system::error_code ec = {},
-            std::size_t bytes_transferrred = 0) mutable {
-            auto& s = *self;
-
-            BOOST_ASIO_CORO_REENTER(coro) {
-                if (s.stream.is_ssl()) {
-                    std::cout << "-> ssl().async_shutdown()\n";
-                    BOOST_ASIO_CORO_YIELD s.stream.ssl().async_shutdown(
-                        std::move(cb));
-                    std::cout << "<- ssl().async_shutdown: " << ec.message()
-                              << '\n';
-                    if (ec == boost::asio::ssl::error::stream_truncated) {
-                        ec = {};
-                    }
-                    if (ec) {
-                        goto upcall;
-                    }
-                }
-
-                std::cout << "plain socket shutdown\n";
-                s.stream.plain().shutdown(
-                    boost::asio::ip::tcp::socket::shutdown_both, ec);
-                s.stream.plain().close(ec);
-
-            upcall:
-                std::cout << "invoke completion handler\n";
-                return cb.complete(ec);
-            }
-        },
-        *this, std::forward<ShutdownHandler>(handler));
+auto
+basic_client_session<DynamicBuffer>::async_shutdown(ShutdownHandler&& handler) & ->
+  typename boost::asio::async_result<std::decay_t<ShutdownHandler>,
+                                     void(boost::system::error_code)>::return_type
+{
+  return ::launchdarkly::foxy::detail::async_timer<void(boost::system::error_code)>(
+    [self = this, coro = boost::asio::coroutine()](auto& cb, boost::system::error_code ec = {},
+                                                   std::size_t bytes_transferrred = 0) mutable {
+      auto& s = *self;
+
+      BOOST_ASIO_CORO_REENTER(coro)
+      {
+        if (s.stream.is_ssl()) {
+          BOOST_ASIO_CORO_YIELD s.stream.ssl().async_shutdown(std::move(cb));
+          if (ec == boost::asio::ssl::error::stream_truncated) { ec = {}; }
+          if (ec) { goto upcall; }
+        }
+
+        s.stream.plain().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
+        s.stream.plain().close(ec);
+
+      upcall:
+        return cb.complete(ec);
+      }
+    },
+    *this, std::forward<ShutdownHandler>(handler));
 }
 
-}  // namespace launchdarkly::foxy
+} // namespace launchdarkly::foxy
 
-#endif  // FOXY_IMPL_CLIENT_SESSION_ASYNC_SHUTDOWN_IMPL_HPP_
+#endif // FOXY_IMPL_CLIENT_SESSION_ASYNC_SHUTDOWN_IMPL_HPP_
