Flow error to disconnected callback (#56)

BrennanConroy · web-flow · commit 5c499e361e5c · 2021-04-21T09:19:36.000-07:00
diff --git a/include/signalrclient/connection.h b/include/signalrclient/connection.h
@@ -35,11 +35,11 @@ namespace signalr
         SIGNALRCLIENT_API void __cdecl send(const std::string& data, transfer_format transfer_format, std::function<void(std::exception_ptr)> callback) noexcept;
 
         SIGNALRCLIENT_API void __cdecl set_message_received(const message_received_handler& message_received_callback);
-        SIGNALRCLIENT_API void __cdecl set_disconnected(const std::function<void __cdecl()>& disconnected_callback);
+        SIGNALRCLIENT_API void __cdecl set_disconnected(const std::function<void __cdecl(std::exception_ptr)>& disconnected_callback);
 
         SIGNALRCLIENT_API void __cdecl set_client_config(const signalr_client_config& config);
 
-        SIGNALRCLIENT_API void __cdecl stop(std::function<void(std::exception_ptr)> callback) noexcept;
+        SIGNALRCLIENT_API void __cdecl stop(std::function<void(std::exception_ptr)> callback, std::exception_ptr exception) noexcept;
 
         SIGNALRCLIENT_API connection_state __cdecl get_connection_state() const noexcept;
         SIGNALRCLIENT_API std::string __cdecl get_connection_id() const;
diff --git a/include/signalrclient/hub_connection.h b/include/signalrclient/hub_connection.h
@@ -41,7 +41,7 @@ namespace signalr
         SIGNALRCLIENT_API connection_state __cdecl get_connection_state() const;
         SIGNALRCLIENT_API std::string __cdecl get_connection_id() const;
 
-        SIGNALRCLIENT_API void __cdecl set_disconnected(const std::function<void __cdecl()>& disconnected_callback);
+        SIGNALRCLIENT_API void __cdecl set_disconnected(const std::function<void __cdecl(std::exception_ptr)>& disconnected_callback);
 
         SIGNALRCLIENT_API void __cdecl set_client_config(const signalr_client_config& config);
 
diff --git a/src/signalrclient/connection.cpp b/src/signalrclient/connection.cpp
@@ -32,7 +32,7 @@ namespace signalr
         m_pImpl->set_message_received(message_received_callback);
     }
 
-    void connection::set_disconnected(const std::function<void()>& disconnected_callback)
+    void connection::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected_callback)
     {
         m_pImpl->set_disconnected(disconnected_callback);
     }
@@ -42,9 +42,9 @@ namespace signalr
         m_pImpl->set_client_config(config);
     }
 
-    void connection::stop(std::function<void(std::exception_ptr)> callback) noexcept
+    void connection::stop(std::function<void(std::exception_ptr)> callback, std::exception_ptr exception) noexcept
     {
-        m_pImpl->stop(callback);
+        m_pImpl->stop(callback, exception);
     }
 
     connection_state connection::get_connection_state() const noexcept
diff --git a/src/signalrclient/connection_impl.cpp b/src/signalrclient/connection_impl.cpp
@@ -35,7 +35,7 @@ namespace signalr
     connection_impl::connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
         std::function<std::shared_ptr<http_client>(const signalr_client_config&)> http_client_factory, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory, const bool skip_negotiation)
         : m_base_url(url), m_connection_state(connection_state::disconnected), m_logger(log_writer, trace_level), m_transport(nullptr), m_skip_negotiation(skip_negotiation),
-        m_message_received([](const std::string&) noexcept {}), m_disconnected([]() noexcept {}), m_disconnect_cts(std::make_shared<cancellation_token>())
+        m_message_received([](const std::string&) noexcept {}), m_disconnected([](std::exception_ptr) noexcept {}), m_disconnect_cts(std::make_shared<cancellation_token>())
     {
         if (http_client_factory != nullptr)
         {
@@ -583,8 +583,9 @@ namespace signalr
             });
     }
 
-    void connection_impl::stop(std::function<void(std::exception_ptr)> callback) noexcept
+    void connection_impl::stop(std::function<void(std::exception_ptr)> callback, std::exception_ptr exception) noexcept
     {
+        m_stop_error = exception;
         m_logger.log(trace_level::info, "stopping connection");
 
         shutdown(callback);
@@ -601,7 +602,7 @@ namespace signalr
             if (current_state == connection_state::disconnected)
             {
                 m_disconnect_cts->cancel();
-                callback(nullptr);
+                callback(m_stop_error);
                 return;
             }
 
@@ -654,6 +655,13 @@ namespace signalr
                 return;
             }
 
+            // if we have a m_stop_error, it takes precedence over the error from the transport
+            if (m_stop_error)
+            {
+                error = m_stop_error;
+                m_stop_error = nullptr;
+            }
+
             change_state(connection_state::disconnected);
             m_transport = nullptr;
         }
@@ -679,7 +687,7 @@ namespace signalr
 
         try
         {
-            m_disconnected();
+            m_disconnected(error);
         }
         catch (const std::exception & e)
         {
@@ -726,7 +734,7 @@ namespace signalr
         m_signalr_client_config = config;
     }
 
-    void connection_impl::set_disconnected(const std::function<void()>& disconnected)
+    void connection_impl::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected)
     {
         ensure_disconnected("cannot set the disconnected callback when the connection is not in the disconnected state. ");
         m_disconnected = disconnected;
diff --git a/src/signalrclient/connection_impl.h b/src/signalrclient/connection_impl.h
@@ -40,13 +40,13 @@ namespace signalr
 
         void start(std::function<void(std::exception_ptr)> callback) noexcept;
         void send(const std::string &data, transfer_format transfer_format, std::function<void(std::exception_ptr)> callback) noexcept;
-        void stop(std::function<void(std::exception_ptr)> callback) noexcept;
+        void stop(std::function<void(std::exception_ptr)> callback, std::exception_ptr exception) noexcept;
 
         connection_state get_connection_state() const noexcept;
         std::string get_connection_id() const noexcept;
 
         void set_message_received(const std::function<void(std::string&&)>& message_received);
-        void set_disconnected(const std::function<void()>& disconnected);
+        void set_disconnected(const std::function<void(std::exception_ptr)>& disconnected);
         void set_client_config(const signalr_client_config& config);
 
     private:
@@ -57,9 +57,10 @@ namespace signalr
         std::shared_ptr<transport> m_transport;
         std::unique_ptr<transport_factory> m_transport_factory;
         bool m_skip_negotiation;
+        std::exception_ptr m_stop_error;
 
         std::function<void(std::string&&)> m_message_received;
-        std::function<void()> m_disconnected;
+        std::function<void(std::exception_ptr)> m_disconnected;
         signalr_client_config m_signalr_client_config;
 
         std::shared_ptr<cancellation_token> m_disconnect_cts;
diff --git a/src/signalrclient/hub_connection.cpp b/src/signalrclient/hub_connection.cpp
@@ -104,7 +104,7 @@ namespace signalr
         return m_pImpl->get_connection_id();
     }
 
-    void hub_connection::set_disconnected(const std::function<void()>& disconnected_callback)
+    void hub_connection::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected_callback)
     {
         if (!m_pImpl)
         {
diff --git a/src/signalrclient/hub_connection_impl.cpp b/src/signalrclient/hub_connection_impl.cpp
@@ -40,7 +40,7 @@ namespace signalr
         : m_connection(connection_impl::create(url, trace_level, log_writer,
             http_client_factory, websocket_factory, skip_negotiation)), m_logger(log_writer, trace_level),
         m_callback_manager("connection went out of scope before invocation result was received"),
-        m_handshakeReceived(false), m_disconnected([]() noexcept {}), m_protocol(std::unique_ptr<json_hub_protocol>(new json_hub_protocol()))
+        m_handshakeReceived(false), m_disconnected([](std::exception_ptr) noexcept {}), m_protocol(std::unique_ptr<json_hub_protocol>(new json_hub_protocol()))
     {}
 
     void hub_connection_impl::initialize()
@@ -57,7 +57,7 @@ namespace signalr
             }
         });
 
-        m_connection->set_disconnected([weak_hub_connection]()
+        m_connection->set_disconnected([weak_hub_connection](std::exception_ptr exception)
         {
             auto connection = weak_hub_connection.lock();
             if (connection)
@@ -67,7 +67,7 @@ namespace signalr
 
                 connection->m_callback_manager.clear("connection was stopped before invocation result was received");
 
-                connection->m_disconnected();
+                connection->m_disconnected(exception);
             }
         });
     }
@@ -120,7 +120,7 @@ namespace signalr
 
                 if (start_exception)
                 {
-                    connection->m_connection->stop([start_exception, callback, weak_connection](std::exception_ptr)
+                    connection->m_connection->stop([callback, weak_connection](std::exception_ptr ex)
                     {
                         try
                         {
@@ -133,8 +133,8 @@ namespace signalr
                         }
                         catch (...) {}
 
-                        callback(start_exception);
-                    });
+                        callback(ex);
+                    }, start_exception);
                     return;
                 }
 
@@ -167,7 +167,7 @@ namespace signalr
                         connection->m_connection->stop([callback, handshake_exception](std::exception_ptr)
                         {
                             callback(handshake_exception);
-                        });
+                        }, nullptr);
                     }
                 });
             });
@@ -218,7 +218,7 @@ namespace signalr
                     {
                         callback(exception);
                     }
-                });
+                }, nullptr);
         }
     }
 
@@ -318,7 +318,7 @@ namespace signalr
             }
 
             // TODO: Consider passing "reason" exception to stop
-            m_connection->stop([](std::exception_ptr) {});
+            m_connection->stop([](std::exception_ptr) {}, std::current_exception());
         }
     }
 
@@ -419,7 +419,7 @@ namespace signalr
         m_connection->set_client_config(config);
     }
 
-    void hub_connection_impl::set_disconnected(const std::function<void()>& disconnected)
+    void hub_connection_impl::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected)
     {
         m_disconnected = disconnected;
     }
diff --git a/src/signalrclient/hub_connection_impl.h b/src/signalrclient/hub_connection_impl.h
@@ -43,7 +43,7 @@ namespace signalr
         std::string get_connection_id() const;
 
         void set_client_config(const signalr_client_config& config);
-        void set_disconnected(const std::function<void()>& disconnected);
+        void set_disconnected(const std::function<void(std::exception_ptr)>& disconnected);
 
     private:
         hub_connection_impl(const std::string& url, trace_level trace_level,
@@ -57,7 +57,7 @@ namespace signalr
         std::unordered_map<std::string, std::function<void(const signalr::value&)>, case_insensitive_hash, case_insensitive_equals> m_subscriptions;
         bool m_handshakeReceived;
         std::shared_ptr<completion_event> m_handshakeTask;
-        std::function<void()> m_disconnected;
+        std::function<void(std::exception_ptr)> m_disconnected;
         signalr_client_config m_signalr_client_config;
         std::unique_ptr<hub_protocol> m_protocol;
 
diff --git a/test/signalrclienttests/connection_impl_tests.cpp b/test/signalrclienttests/connection_impl_tests.cpp
diff --git a/test/signalrclienttests/hub_connection_tests.cpp b/test/signalrclienttests/hub_connection_tests.cpp
diff --git a/test/signalrclienttests/test_utils.h b/test/signalrclienttests/test_utils.h

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace signalr`
`32`	`32`	`m_pImpl->set_message_received(message_received_callback);`
`33`	`33`	`}`
`34`	`34`
`35`		`- void connection::set_disconnected(const std::function<void()>& disconnected_callback)`
	`35`	`+ void connection::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected_callback)`
`36`	`36`	`{`
`37`	`37`	`m_pImpl->set_disconnected(disconnected_callback);`
`38`	`38`	`}`
`@@ -42,9 +42,9 @@ namespace signalr`
`42`	`42`	`m_pImpl->set_client_config(config);`
`43`	`43`	`}`
`44`	`44`
`45`		`- void connection::stop(std::function<void(std::exception_ptr)> callback) noexcept`
	`45`	`+ void connection::stop(std::function<void(std::exception_ptr)> callback, std::exception_ptr exception) noexcept`
`46`	`46`	`{`
`47`		`- m_pImpl->stop(callback);`
	`47`	`+ m_pImpl->stop(callback, exception);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`connection_state connection::get_connection_state() const noexcept`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ namespace signalr`
`35`	`35`	`connection_impl::connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,`
`36`	`36`	`std::function<std::shared_ptr<http_client>(const signalr_client_config&)> http_client_factory, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory, const bool skip_negotiation)`
`37`	`37`	`: m_base_url(url), m_connection_state(connection_state::disconnected), m_logger(log_writer, trace_level), m_transport(nullptr), m_skip_negotiation(skip_negotiation),`
`38`		`- m_message_received([](const std::string&) noexcept {}), m_disconnected([]() noexcept {}), m_disconnect_cts(std::make_shared<cancellation_token>())`
	`38`	`+ m_message_received([](const std::string&) noexcept {}), m_disconnected([](std::exception_ptr) noexcept {}), m_disconnect_cts(std::make_shared<cancellation_token>())`
`39`	`39`	`{`
`40`	`40`	`if (http_client_factory != nullptr)`
`41`	`41`	`{`
`@@ -583,8 +583,9 @@ namespace signalr`
`583`	`583`	`});`
`584`	`584`	`}`
`585`	`585`
`586`		`- void connection_impl::stop(std::function<void(std::exception_ptr)> callback) noexcept`
	`586`	`+ void connection_impl::stop(std::function<void(std::exception_ptr)> callback, std::exception_ptr exception) noexcept`
`587`	`587`	`{`
	`588`	`+ m_stop_error = exception;`
`588`	`589`	`m_logger.log(trace_level::info, "stopping connection");`
`589`	`590`
`590`	`591`	`shutdown(callback);`
`@@ -601,7 +602,7 @@ namespace signalr`
`601`	`602`	`if (current_state == connection_state::disconnected)`
`602`	`603`	`{`
`603`	`604`	`m_disconnect_cts->cancel();`
`604`		`- callback(nullptr);`
	`605`	`+ callback(m_stop_error);`
`605`	`606`	`return;`
`606`	`607`	`}`
`607`	`608`
`@@ -654,6 +655,13 @@ namespace signalr`
`654`	`655`	`return;`
`655`	`656`	`}`
`656`	`657`
	`658`	`+ // if we have a m_stop_error, it takes precedence over the error from the transport`
	`659`	`+ if (m_stop_error)`
	`660`	`+ {`
	`661`	`+ error = m_stop_error;`
	`662`	`+ m_stop_error = nullptr;`
	`663`	`+ }`
	`664`	`+`
`657`	`665`	`change_state(connection_state::disconnected);`
`658`	`666`	`m_transport = nullptr;`
`659`	`667`	`}`
`@@ -679,7 +687,7 @@ namespace signalr`
`679`	`687`
`680`	`688`	`try`
`681`	`689`	`{`
`682`		`- m_disconnected();`
	`690`	`+ m_disconnected(error);`
`683`	`691`	`}`
`684`	`692`	`catch (const std::exception & e)`
`685`	`693`	`{`
`@@ -726,7 +734,7 @@ namespace signalr`
`726`	`734`	`m_signalr_client_config = config;`
`727`	`735`	`}`
`728`	`736`
`729`		`- void connection_impl::set_disconnected(const std::function<void()>& disconnected)`
	`737`	`+ void connection_impl::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected)`
`730`	`738`	`{`
`731`	`739`	`ensure_disconnected("cannot set the disconnected callback when the connection is not in the disconnected state. ");`
`732`	`740`	`m_disconnected = disconnected;`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ namespace signalr`
`104`	`104`	`return m_pImpl->get_connection_id();`
`105`	`105`	`}`
`106`	`106`
`107`		`- void hub_connection::set_disconnected(const std::function<void()>& disconnected_callback)`
	`107`	`+ void hub_connection::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected_callback)`
`108`	`108`	`{`
`109`	`109`	`if (!m_pImpl)`
`110`	`110`	`{`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ namespace signalr`
`40`	`40`	`: m_connection(connection_impl::create(url, trace_level, log_writer,`
`41`	`41`	`http_client_factory, websocket_factory, skip_negotiation)), m_logger(log_writer, trace_level),`
`42`	`42`	`m_callback_manager("connection went out of scope before invocation result was received"),`
`43`		`- m_handshakeReceived(false), m_disconnected([]() noexcept {}), m_protocol(std::unique_ptr<json_hub_protocol>(new json_hub_protocol()))`
	`43`	`+ m_handshakeReceived(false), m_disconnected([](std::exception_ptr) noexcept {}), m_protocol(std::unique_ptr<json_hub_protocol>(new json_hub_protocol()))`
`44`	`44`	`{}`
`45`	`45`
`46`	`46`	`void hub_connection_impl::initialize()`
`@@ -57,7 +57,7 @@ namespace signalr`
`57`	`57`	`}`
`58`	`58`	`});`
`59`	`59`
`60`		`- m_connection->set_disconnected([weak_hub_connection]()`
	`60`	`+ m_connection->set_disconnected([weak_hub_connection](std::exception_ptr exception)`
`61`	`61`	`{`
`62`	`62`	`auto connection = weak_hub_connection.lock();`
`63`	`63`	`if (connection)`
`@@ -67,7 +67,7 @@ namespace signalr`
`67`	`67`
`68`	`68`	`connection->m_callback_manager.clear("connection was stopped before invocation result was received");`
`69`	`69`
`70`		`- connection->m_disconnected();`
	`70`	`+ connection->m_disconnected(exception);`
`71`	`71`	`}`
`72`	`72`	`});`
`73`	`73`	`}`
`@@ -120,7 +120,7 @@ namespace signalr`
`120`	`120`
`121`	`121`	`if (start_exception)`
`122`	`122`	`{`
`123`		`- connection->m_connection->stop([start_exception, callback, weak_connection](std::exception_ptr)`
	`123`	`+ connection->m_connection->stop([callback, weak_connection](std::exception_ptr ex)`
`124`	`124`	`{`
`125`	`125`	`try`
`126`	`126`	`{`
`@@ -133,8 +133,8 @@ namespace signalr`
`133`	`133`	`}`
`134`	`134`	`catch (...) {}`
`135`	`135`
`136`		`- callback(start_exception);`
`137`		`- });`
	`136`	`+ callback(ex);`
	`137`	`+ }, start_exception);`
`138`	`138`	`return;`
`139`	`139`	`}`
`140`	`140`
`@@ -167,7 +167,7 @@ namespace signalr`
`167`	`167`	`connection->m_connection->stop([callback, handshake_exception](std::exception_ptr)`
`168`	`168`	`{`
`169`	`169`	`callback(handshake_exception);`
`170`		`- });`
	`170`	`+ }, nullptr);`
`171`	`171`	`}`
`172`	`172`	`});`
`173`	`173`	`});`
`@@ -218,7 +218,7 @@ namespace signalr`
`218`	`218`	`{`
`219`	`219`	`callback(exception);`
`220`	`220`	`}`
`221`		`- });`
	`221`	`+ }, nullptr);`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`@@ -318,7 +318,7 @@ namespace signalr`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`// TODO: Consider passing "reason" exception to stop`
`321`		`- m_connection->stop([](std::exception_ptr) {});`
	`321`	`+ m_connection->stop([](std::exception_ptr) {}, std::current_exception());`
`322`	`322`	`}`
`323`	`323`	`}`
`324`	`324`
`@@ -419,7 +419,7 @@ namespace signalr`
`419`	`419`	`m_connection->set_client_config(config);`
`420`	`420`	`}`
`421`	`421`
`422`		`- void hub_connection_impl::set_disconnected(const std::function<void()>& disconnected)`
	`422`	`+ void hub_connection_impl::set_disconnected(const std::function<void(std::exception_ptr)>& disconnected)`
`423`	`423`	`{`
`424`	`424`	`m_disconnected = disconnected;`
`425`	`425`	`}`