ssl session cannot be resused for new connections

Author: cwaldren-ld

libs/server-sent-events/src/client.cpp

@@ -83,16 +83,14 @@ class FoxyClient : public Client,
           logger_(std::move(logger)),
           errors_(std::move(errors)),
           body_parser_(std::nullopt),
-          session_(std::move(executor),
-                   launchdarkly::foxy::session_opts{
-                       ToOptRef(ssl_context_),
-                       connect_timeout_.value_or(kNoTimeout)}),
+          session_(std::nullopt),
           last_event_id_(std::nullopt),
           backoff_(
               initial_reconnect_delay.value_or(kDefaultInitialReconnectDelay),
               kDefaultMaxBackoffDelay),
-          backoff_timer_(session_.get_executor()),
+          backoff_timer_(std::move(executor)),
           last_read_(std::nullopt) {
+        create_session();
         create_parser();
     }
 
@@ -133,6 +131,13 @@ class FoxyClient : public Client,
         body_parser_->get().body().on_event(event_receiver_);
     }
 
+    void create_session() {
+        session_.emplace(
+            backoff_timer_.get_executor(),
+            launchdarkly::foxy::session_opts{
+                ToOptRef(ssl_context_), connect_timeout_.value_or(kNoTimeout)});
+    }
+
     /**
      * Called whenever the connection needs to be reattempted, triggering
      * a timed wait for the current backoff duration.
@@ -158,6 +163,7 @@ class FoxyClient : public Client,
 
         logger_(msg.str());
 
+        create_session();
         create_parser();
         backoff_timer_.expires_from_now(backoff_.delay());
         backoff_timer_.async_wait(beast::bind_front_handler(
@@ -172,7 +178,7 @@ class FoxyClient : public Client,
     }
 
     void run() override {
-        session_.async_connect(
+        session_->async_connect(
             host_, port_,
             beast::bind_front_handler(&FoxyClient::on_connect,
                                       shared_from_this()));
@@ -191,10 +197,10 @@ class FoxyClient : public Client,
         } else {
             req_.erase("last-event-id");
         }
-        session_.opts.timeout = write_timeout_.value_or(kNoTimeout);
-        session_.async_write(req_,
-                             beast::bind_front_handler(&FoxyClient::on_write,
-                                                       shared_from_this()));
+        session_->opts.timeout = write_timeout_.value_or(kNoTimeout);
+        session_->async_write(req_,
+                              beast::bind_front_handler(&FoxyClient::on_write,
+                                                        shared_from_this()));
     }
 
     void on_write(boost::system::error_code ec, std::size_t amount) {
@@ -206,8 +212,8 @@ class FoxyClient : public Client,
             return do_backoff(ec.what());
         }
 
-        session_.opts.timeout = read_timeout_.value_or(kNoTimeout);
-        session_.async_read_header(
+        session_->opts.timeout = read_timeout_.value_or(kNoTimeout);
+        session_->async_read_header(
             *body_parser_, beast::bind_front_handler(&FoxyClient::on_headers,
                                                      shared_from_this()));
     }
@@ -223,7 +229,7 @@ class FoxyClient : public Client,
 
         if (!body_parser_->is_header_done()) {
             /* keep reading headers */
-            return session_.async_read_header(
+            return session_->async_read_header(
                 *body_parser_,
                 beast::bind_front_handler(&FoxyClient::on_headers,
                                           shared_from_this()));
@@ -242,10 +248,11 @@ class FoxyClient : public Client,
                 return do_backoff("invalid Content-Type");
             }
 
+            logger_("connected");
             backoff_.succeed();
 
             last_read_ = std::chrono::steady_clock::now();
-            return session_.async_read_some(
+            return session_->async_read_some(
                 *body_parser_,
                 beast::bind_front_handler(&FoxyClient::on_read_body,
                                           shared_from_this()));
@@ -292,8 +299,8 @@ class FoxyClient : public Client,
     void on_read_body(boost::system::error_code ec, std::size_t amount) {
         boost::ignore_unused(amount);
         if (ec == boost::asio::error::operation_aborted) {
-            logger_("read HTTP response body aborted");
-            return;
+            return do_backoff(
+                "aborting read of response body (timeout/shutdown)");
         }
         if (body_parser_->is_done()) {
             // The server can indicate that the chunk encoded response is done
@@ -303,7 +310,7 @@ class FoxyClient : public Client,
         }
         if (!ec) {
             log_and_update_last_read(amount);
-            return session_.async_read_some(
+            return session_->async_read_some(
                 *body_parser_,
                 beast::bind_front_handler(&FoxyClient::on_read_body,
                                           shared_from_this()));
@@ -312,15 +319,15 @@ class FoxyClient : public Client,
     }
 
     void async_shutdown(std::function<void()> completion) override {
-        boost::asio::post(session_.get_executor(),
+        boost::asio::post(session_->get_executor(),
                           beast::bind_front_handler(&FoxyClient::do_shutdown,
                                                     shared_from_this(),
                                                     std::move(completion)));
     }
 
     void do_shutdown(std::function<void()> completion) {
         backoff_timer_.cancel();
-        session_.async_shutdown(beast::bind_front_handler(
+        session_->async_shutdown(beast::bind_front_handler(
             &FoxyClient::on_shutdown, std::move(completion)));
     }
 
@@ -389,7 +396,7 @@ class FoxyClient : public Client,
     Builder::ErrorCallback errors_;
 
     std::optional<http::response_parser<body>> body_parser_;
-    launchdarkly::foxy::client_session session_;
+    std::optional<launchdarkly::foxy::client_session> session_;
     std::optional<std::string> last_event_id_;
     Backoff backoff_;
     boost::asio::steady_timer backoff_timer_;