Cleanup. Introduce new mutex to prevent pending, active and requested network slots in connectivity manager.

Signed-off-by: Maaike <maaike@iolar.nl>

Author: maaikez

include/ocpp/common/websocket/websocket.hpp

@@ -21,7 +21,6 @@ class Websocket {
     // unique_ptr holds address of base - requires WebSocketBase to have a virtual destructor
     std::unique_ptr<WebsocketBase> websocket;
     std::function<void(const int security_profile)> connected_callback;
-    // std::function<void()> disconnected_callback;
     std::function<void(const WebsocketCloseReason reason)> closed_callback;
     std::function<void(const WebsocketCloseReason reason)> failed_callback;
     std::function<void(const std::string& message)> message_callback;
@@ -42,7 +41,6 @@ class Websocket {
     void disconnect(const WebsocketCloseReason code);
 
     // \brief reconnects the websocket after the delay
-    // void reconnect(std::error_code reason, long delay);
     void reconnect();
 
     /// \brief indicates if the websocket is connected
@@ -51,9 +49,6 @@ class Websocket {
     /// \brief register a \p callback that is called when the websocket is connected successfully
     void register_connected_callback(const std::function<void(const int security_profile)>& callback);
 
-    /// \brief register a \p callback that is called when the websocket connection is disconnected
-    // void register_disconnected_callback(const std::function<void()>& callback);
-
     /// \brief register a \p callback that is called when the websocket connection has been closed and will not attempt
     /// to reconnect
     void register_closed_callback(const std::function<void(const WebsocketCloseReason reason)>& callback);

include/ocpp/common/websocket/websocket_base.hpp

@@ -36,7 +36,7 @@ struct WebsocketConnectionOptions {
     std::optional<std::string> hostName;
     bool verify_csms_common_name;
     bool use_tpm_tls;
-    std::optional<std::string> iface_or_ip;    ///< The interface of the connection or the ip address of the interface
+    std::optional<std::string> iface_or_ip; ///< The interface of the connection or the ip address of the interface
 };
 
 ///
@@ -47,20 +47,14 @@ class WebsocketBase {
     bool m_is_connected;
     WebsocketConnectionOptions connection_options;
     std::function<void(const int security_profile)> connected_callback;
-    // std::function<void()> disconnected_callback;
     std::function<void(const WebsocketCloseReason reason)> closed_callback;
     std::function<void(const WebsocketCloseReason reason)> failed_callback;
     std::function<void(const std::string& message)> message_callback;
-    // websocketpp::lib::shared_ptr<boost::asio::steady_timer> reconnect_timer;
     std::unique_ptr<Everest::SteadyTimer> ping_timer;
     websocketpp::connection_hdl handle;
     std::mutex reconnect_mutex;
     std::mutex connection_mutex;
-    // long reconnect_backoff_ms;
-    // websocketpp::transport::timer_handler reconnect_callback;
-    // int connection_attempts;
     bool shutting_down;
-    // bool reconnecting;
 
     /// \brief Indicates if the required callbacks are registered
     /// \returns true if the websocket is properly initialized
@@ -72,13 +66,6 @@ class WebsocketBase {
     /// \brief Logs websocket connection error
     void log_on_fail(const std::error_code& ec, const boost::system::error_code& transport_ec, const int http_status);
 
-    /// \brief Calculates and returns the reconnect interval based on int retry_backoff_random_range_s,
-    /// retry_backoff_repeat_times, int retry_backoff_wait_minimum_s of the WebsocketConnectionOptions
-    // long get_reconnect_interval();
-
-    // \brief cancels the reconnect timer
-    // void cancel_reconnect_timer();
-
     /// \brief send a websocket ping
     virtual void ping() = 0;
 
@@ -99,8 +86,10 @@ class WebsocketBase {
     virtual void set_connection_options(const WebsocketConnectionOptions& connection_options) = 0;
     void set_connection_options_base(const WebsocketConnectionOptions& connection_options);
 
-    /// \brief reconnect the websocket after the delay
-    // virtual void reconnect(std::error_code reason, long delay) = 0;
+    /// \brief reconnect the websocket.
+    ///
+    /// This is needed because of websocketpp: we can not just call 'connect' because the websocket might be in a wrong
+    /// state here.
     virtual void reconnect() = 0;
 
     /// \brief disconnect the websocket
@@ -115,9 +104,6 @@ class WebsocketBase {
     /// \brief register a \p callback that is called when the websocket is connected successfully
     void register_connected_callback(const std::function<void(const int security_profile)>& callback);
 
-    /// \brief register a \p callback that is called when the websocket connection is disconnected
-    // void register_disconnected_callback(const std::function<void()>& callback);
-
     /// \brief register a \p callback that is called when the websocket connection has been closed and will not attempt
     /// to reconnect
     void register_closed_callback(const std::function<void(const WebsocketCloseReason reason)>& callback);

include/ocpp/common/websocket/websocket_plain.hpp

@@ -5,9 +5,9 @@
 
 #include <thread>
 
+#include <everest/logging.hpp>
 #include <websocketpp/client.hpp>
 #include <websocketpp/config/asio_client.hpp>
-#include <everest/logging.hpp>
 
 #include <ocpp/common/websocket/websocket_base.hpp>
 
@@ -27,6 +27,9 @@ class WebsocketPlain final : public WebsocketBase {
     client ws_client;
     websocketpp::lib::shared_ptr<websocketpp::lib::thread> websocket_thread;
 
+    /// \brief Set to true if websocket is already closed and should not close it again.
+    std::atomic_bool closed;
+
     /// \brief Connect to a plain websocket
     void connect_plain();
 
@@ -50,9 +53,11 @@ class WebsocketPlain final : public WebsocketBase {
 
     ~WebsocketPlain() {
         this->close(WebsocketCloseReason::Normal, "", true);
-        EVLOG_info << "In websocketplain destructor";
+        if (!this->ws_client.stopped()) {
+            this->ws_client.stop();
+        }
+
         this->websocket_thread->join();
-        EVLOG_info << "In websocketplain destructor after join";
     }
 
     /// \brief connect to a plaintext websocket
@@ -61,7 +66,6 @@ class WebsocketPlain final : public WebsocketBase {
 
     /// \brief Reconnects the websocket using the delay, a reason for this reconnect can be provided with the
     /// \p reason parameter
-    // void reconnect(std::error_code reason, long delay) override;
     void reconnect() override;
 
     /// \brief Closes a plaintext websocket connection

include/ocpp/common/websocket/websocket_tls.hpp

@@ -63,7 +63,6 @@ class WebsocketTLS final : public WebsocketBase {
     /// \brief Reconnects the websocket using the delay, a reason for this reconnect can be provided with the
     /// \param reason parameter
     /// \param delay delay of the reconnect attempt
-    // void reconnect(std::error_code reason, long delay) override;
     void reconnect() override;
 
     /// \brief closes the websocket

include/ocpp/v201/charge_point.hpp

@@ -20,7 +20,7 @@
 #include <ocpp/v201/types.hpp>
 #include <ocpp/v201/utils.hpp>
 
-#include "ocpp/v201/connectivity_manager.h"
+#include "ocpp/v201/connectivity_manager.hpp"
 #include "ocpp/v201/messages/Get15118EVCertificate.hpp"
 #include <ocpp/v201/messages/Authorize.hpp>
 #include <ocpp/v201/messages/BootNotification.hpp>

include/ocpp/v201/connectivity_manager.h include/ocpp/v201/connectivity_manager.hpp

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
+
 #pragma once
 
 #include <functional>
@@ -42,7 +45,9 @@ class ConnectivityManager {
     ///        variable.
     std::atomic_bool try_reconnect;
     /// \brief Mutex for the requested, pending and active network slot.
-    mutable std::mutex config_slot_mutex;
+    mutable std::recursive_mutex config_slot_mutex;
+    /// \brief Mutex for the condition variable.
+    mutable std::mutex reconnect_mutex;
     /// \brief Condition variable that waits until it gets a sign to reconnect.
     std::condition_variable reconnect_condition_variable;
     /// \brief Reference to the device model class.
@@ -55,7 +60,7 @@ class ConnectivityManager {
     std::unique_ptr<Websocket> websocket;
     /// \brief The potential interface to use requested by libocpp, but not 'approved' by 'core' yet.
     int32_t requested_network_slot;
-    /// \brief The interface which will be used to connect
+    /// \brief The interface which will be used to connect, pending connection at the websocket.
     int32_t pending_network_slot;
     /// \brief The interface which is currently in use by the websocket
     int32_t active_network_slot;
@@ -132,16 +137,14 @@ class ConnectivityManager {
     /// \brief Stops the ChargePoint. Disconnects the websocket connection and stops MessageQueue and all timers
     void stop();
 
-    /// @brief Initializes the websocket and connects to CSMS if it is not yet connected.
-    /// @param configuration_slot Optional configuration slot to connect to
-    void connect_websocket(std::optional<int32_t> config_slot = std::nullopt);
-
     /// \brief Disconnects the the websocket connection to the CSMS if it is connected
     /// \param code Optional websocket close status code (default: normal).
     void disconnect_websocket(WebsocketCloseReason code = WebsocketCloseReason::Normal);
 
     /// \brief Switch to a specifc network connection profile given the configuration slot.
-    /// This disregards the prority
+    ///
+    /// Switch will only be done when the configuration slot has a higher priority.
+    ///
     /// \param configuration_slot Slot in which the configuration is stored
     /// \return true if the switch is possible.
     bool on_try_switch_network_connection_profile(const int32_t configuration_slot);

lib/ocpp/common/websocket/websocket.cpp

@@ -23,20 +23,16 @@ Websocket::Websocket(const WebsocketConnectionOptions& connection_options, std::
     this->websocket = std::make_unique<WebsocketTlsTPM>(connection_options, evse_security);
 #else
     if (connection_options.security_profile <= 1) {
-        EVLOG_info << "Create plain websocket";
         this->websocket = std::make_unique<WebsocketPlain>(connection_options);
-        EVLOG_info << "Plain websocket created";
     } else if (connection_options.security_profile >= 2) {
         this->websocket = std::make_unique<WebsocketTLS>(connection_options, evse_security);
     }
 #endif
 }
 
 Websocket::~Websocket() {
-    if (this->websocket != nullptr)
-    {
+    if (this->websocket != nullptr) {
         this->websocket->disconnect(WebsocketCloseReason::GoingAway);
-        this->websocket->close(WebsocketCloseReason::GoingAway, "", true);
         this->websocket = nullptr;
     }
 }
@@ -55,16 +51,10 @@ void Websocket::disconnect(const WebsocketCloseReason code) {
     this->websocket->disconnect(code);
 }
 
-void Websocket::reconnect()
-{
+void Websocket::reconnect() {
     this->websocket->reconnect();
 }
 
-// void Websocket::reconnect(std::error_code reason, long delay) {
-//     this->logging->sys("Reconnecting");
-//     this->websocket->reconnect(reason, delay);
-// }
-
 bool Websocket::is_connected() {
     return this->websocket->is_connected();
 }
@@ -78,24 +68,13 @@ void Websocket::register_connected_callback(const std::function<void(const int s
     });
 }
 
-// void Websocket::register_disconnected_callback(const std::function<void()>& callback) {
-//     this->disconnected_callback = callback;
-
-//     this->websocket->register_disconnected_callback([this]() {
-//         this->logging->sys("Disconnected");
-//         this->disconnected_callback();
-//     });
-// }
-
-void Websocket::register_closed_callback(
-    const std::function<void(const WebsocketCloseReason reason)>& callback) {
+void Websocket::register_closed_callback(const std::function<void(const WebsocketCloseReason reason)>& callback) {
     this->closed_callback = callback;
     this->websocket->register_closed_callback(
         [this](const WebsocketCloseReason reason) { this->closed_callback(reason); });
 }
 
-void Websocket::register_failed_callback(const std::function<void (const WebsocketCloseReason)> &callback)
-{
+void Websocket::register_failed_callback(const std::function<void(const WebsocketCloseReason)>& callback) {
     this->failed_callback = callback;
     this->websocket->register_failed_callback(
         [this](const WebsocketCloseReason reason) { this->failed_callback(reason); });

lib/ocpp/common/websocket/websocket_base.cpp

@@ -11,11 +11,7 @@ WebsocketBase::WebsocketBase() :
     connected_callback(nullptr),
     closed_callback(nullptr),
     message_callback(nullptr),
-    // reconnect_timer(nullptr),
-    // connection_attempts(0),
-    // reconnect_backoff_ms(0),
-    shutting_down(false)/*,
-    reconnecting(false)*/ {
+    shutting_down(false) {
 
     set_connection_options_base(connection_options);
 
@@ -38,17 +34,11 @@ void WebsocketBase::register_connected_callback(const std::function<void(const i
     this->connected_callback = callback;
 }
 
-// void WebsocketBase::register_disconnected_callback(const std::function<void()>& callback) {
-//     this->disconnected_callback = callback;
-// }
-
-void WebsocketBase::register_closed_callback(
-    const std::function<void(const WebsocketCloseReason reason)>& callback) {
+void WebsocketBase::register_closed_callback(const std::function<void(const WebsocketCloseReason reason)>& callback) {
     this->closed_callback = callback;
 }
 
-void WebsocketBase::register_failed_callback(const std::function<void (const WebsocketCloseReason)> &callback)
-{
+void WebsocketBase::register_failed_callback(const std::function<void(const WebsocketCloseReason)>& callback) {
     this->failed_callback = callback;
 }
 
@@ -81,9 +71,6 @@ void WebsocketBase::disconnect(WebsocketCloseReason code) {
     if (code == WebsocketCloseReason::Normal) {
         this->shutting_down = true;
     }
-    // if (this->reconnect_timer) {
-    //     this->reconnect_timer.get()->cancel();
-    // }
     if (this->ping_timer) {
         this->ping_timer->stop();
     }
@@ -119,36 +106,6 @@ void WebsocketBase::log_on_fail(const std::error_code& ec, const boost::system::
                 << ", Transport error category: " << transport_ec.category().name();
 }
 
-// long WebsocketBase::get_reconnect_interval() {
-
-//     // We need to add 1 to the repeat times since the first try is already connection_attempt 1
-//     if (this->connection_attempts > (this->connection_options.retry_backoff_repeat_times + 1)) {
-//         return this->reconnect_backoff_ms;
-//     }
-
-//     std::random_device rd;
-//     std::mt19937 gen(rd());
-//     std::uniform_int_distribution<> distr(0, this->connection_options.retry_backoff_random_range_s);
-
-//     int random_number = distr(gen);
-
-//     if (this->connection_attempts == 1) {
-//         this->reconnect_backoff_ms = (this->connection_options.retry_backoff_wait_minimum_s + random_number) * 1000;
-//         return this->reconnect_backoff_ms;
-//     }
-
-//     this->reconnect_backoff_ms = this->reconnect_backoff_ms * 2 + (random_number * 1000);
-//     return this->reconnect_backoff_ms;
-// }
-
-// void WebsocketBase::cancel_reconnect_timer() {
-//     std::lock_guard<std::mutex> lk(this->reconnect_mutex);
-//     if (this->reconnect_timer) {
-//         this->reconnect_timer.get()->cancel();
-//     }
-//     this->reconnect_timer = nullptr;
-// }
-
 void WebsocketBase::set_websocket_ping_interval(int32_t interval_s) {
     if (this->ping_timer) {
         this->ping_timer->stop();
@@ -165,11 +122,6 @@ void WebsocketBase::set_authorization_key(const std::string& authorization_key)
 
 void WebsocketBase::on_pong_timeout(websocketpp::connection_hdl hdl, std::string msg) {
     this->close(WebsocketCloseReason::GoingAway, "Pong timeout", false);
-    // if (!this->reconnecting) {
-    //     EVLOG_info << "Reconnecting because of a pong timeout after " << this->connection_options.pong_timeout_s << "s";
-    //     this->reconnecting = true;
-    //     this->close(WebsocketCloseReason::GoingAway, "Pong timeout");
-    // }
 }
 
 } // namespace ocpp