Move derived session creation to session_impl as a factory method

Following this change, session no longer knows about the derived impls.

Author: jgriffiths

src/ga_rust.cpp

@@ -68,8 +68,8 @@ namespace sdk {
         }
     } // namespace
 
-    ga_rust::ga_rust(const nlohmann::json& net_params)
-        : session_impl(net_params)
+    ga_rust::ga_rust(const nlohmann::json& net_params, nlohmann::json& defaults)
+        : session_impl(net_params, defaults)
     {
         GDKRUST_create_session(&m_session, convert_json(m_net_params.get_json()).get());
     }

src/ga_rust.hpp

@@ -10,11 +10,9 @@ namespace sdk {
 
     class ga_rust final : public session_impl {
     public:
-        explicit ga_rust(const nlohmann::json& net_params);
+        ga_rust(const nlohmann::json& net_params, nlohmann::json& defaults);
         ~ga_rust();
 
-        nlohmann::json call_session(const std::string& method, const nlohmann::json& input) const;
-
         void on_failed_login();
 
         bool is_connected() const;
@@ -156,6 +154,8 @@ namespace sdk {
         static int32_t spv_verify_tx(const nlohmann::json& details);
 
     private:
+        nlohmann::json call_session(const std::string& method, const nlohmann::json& input) const;
+
         static void GDKRUST_notif_handler(void* self_context, struct GDKRUST_json* json);
 
         std::shared_ptr<tor_controller> m_tor_ctrl;

src/ga_session.cpp

@@ -421,8 +421,8 @@ namespace sdk {
         boost::asio::executor_work_guard<boost::asio::io_context::executor_type> m_work_guard;
     };
 
-    ga_session::ga_session(const nlohmann::json& net_params)
-        : session_impl(net_params)
+    ga_session::ga_session(const nlohmann::json& net_params, nlohmann::json& defaults)
+        : session_impl(net_params, defaults)
         , m_proxy(socksify(net_params.value("proxy", std::string{})))
         , m_has_network_proxy(!m_proxy.empty())
         , m_io()

src/ga_session.hpp

@@ -40,7 +40,7 @@ namespace sdk {
         using heartbeat_t = websocketpp::pong_timeout_handler;
         using nlocktime_t = std::map<std::string, nlohmann::json>; // txhash:pt_idx -> lock info
 
-        explicit ga_session(const nlohmann::json& net_params);
+        ga_session(const nlohmann::json& net_params, nlohmann::json& defaults);
         ~ga_session();
 
         void connect();

src/session.cpp

@@ -10,9 +10,6 @@
 
 #include "autobahn_wrapper.hpp"
 #include "exception.hpp"
-#ifdef BUILD_GDK_RUST
-#include "ga_rust.hpp"
-#endif
 #include "ga_session.hpp"
 #include "logging.hpp"
 #include "network_parameters.hpp"
@@ -125,20 +122,7 @@ namespace sdk {
             GDK_RUNTIME_ASSERT_MSG(init_done, "You must call GA_init first");
             GDK_RUNTIME_ASSERT_MSG(!get_impl(), "session already connected");
 
-            const auto network = network_parameters::get(net_params.value("name", std::string()));
-            const auto type = net_params.value("server_type", network.value("server_type", std::string()));
-
-            session_ptr session_p;
-
-            if (type == "green") {
-                session_p = boost::make_shared<ga_session>(net_params);
-#ifdef BUILD_GDK_RUST
-            } else if (type == "electrum") {
-                session_p = boost::make_shared<ga_rust>(net_params);
-#endif
-            } else {
-                GDK_RUNTIME_ASSERT_MSG(false, "server_type field unknown value");
-            }
+            session_ptr session_p = session_impl::create(net_params);
 
             boost::weak_ptr<session_impl> weak_session = session_p;
             session_p->set_ping_fail_handler([weak_session] {

src/session_impl.cpp

@@ -1,5 +1,7 @@
 #include "session_impl.hpp"
 #include "exception.hpp"
+#include "ga_rust.hpp"
+#include "ga_session.hpp"
 #include "logging.hpp"
 #include "session.hpp"
 
@@ -14,24 +16,22 @@ namespace sdk {
             ret[key] = src.value(key, ret.value(key, default_));
         }
 
-        static network_parameters get_network_overrides(const nlohmann::json& user_params)
+        static network_parameters get_network_overrides(const nlohmann::json& user_params, nlohmann::json& defaults)
         {
-            // Get the registered network parameters the passed in parameters are based on
-            auto ret = network_parameters::get(user_params.at("name"));
             // Set override-able settings from the users parameters
-            set_override(ret, "electrum_tls", user_params, false);
-            set_override(ret, "electrum_url", user_params, std::string());
-            set_override(ret, "log_level", user_params, "none");
-            set_override(ret, "spv_multi", user_params, false);
-            set_override(ret, "spv_servers", user_params, nlohmann::json::array());
-            set_override(ret, "spv_enabled", user_params, false);
-            set_override(ret, "use_tor", user_params, false);
-            set_override(ret, "user_agent", user_params, std::string());
+            set_override(defaults, "electrum_tls", user_params, false);
+            set_override(defaults, "electrum_url", user_params, std::string());
+            set_override(defaults, "log_level", user_params, "none");
+            set_override(defaults, "spv_multi", user_params, false);
+            set_override(defaults, "spv_servers", user_params, nlohmann::json::array());
+            set_override(defaults, "spv_enabled", user_params, false);
+            set_override(defaults, "use_tor", user_params, false);
+            set_override(defaults, "user_agent", user_params, std::string());
             // FIXME: Remove this by fetching it directly where needed
             const std::string datadir = gdk_config().value("datadir", std::string());
             GDK_RUNTIME_ASSERT(!datadir.empty());
-            ret["state_dir"] = datadir + "/state";
-            return network_parameters{ ret };
+            defaults["state_dir"] = datadir + "/state";
+            return network_parameters{ defaults };
         }
 
         static void configure_logging(const network_parameters& net_params)
@@ -52,8 +52,24 @@ namespace sdk {
         }
     } // namespace
 
-    session_impl::session_impl(const nlohmann::json& net_params)
-        : m_net_params(get_network_overrides(net_params))
+    boost::shared_ptr<session_impl> session_impl::create(const nlohmann::json& net_params)
+    {
+        auto defaults = network_parameters::get(net_params.value("name", std::string()));
+        const auto type = net_params.value("server_type", defaults.value("server_type", std::string()));
+
+        if (type == "green") {
+            return boost::make_shared<ga_session>(net_params, defaults);
+        }
+#ifdef BUILD_GDK_RUST
+        if (type == "electrum") {
+            return boost::make_shared<ga_rust>(net_params, defaults);
+        }
+#endif
+        throw user_error("Unknown server_type");
+    }
+
+    session_impl::session_impl(const nlohmann::json& net_params, nlohmann::json& defaults)
+        : m_net_params(get_network_overrides(net_params, defaults))
         , m_debug_logging(m_net_params.log_level() == "debug")
     {
         configure_logging(m_net_params);

src/session_impl.hpp

@@ -18,14 +18,17 @@ namespace sdk {
 
     class session_impl {
     public:
-        explicit session_impl(const nlohmann::json& net_params);
+        explicit session_impl(const nlohmann::json& net_params, nlohmann::json& defaults);
         session_impl(const session_impl& other) = delete;
         session_impl(session_impl&& other) noexcept = delete;
         session_impl& operator=(const session_impl& other) = delete;
         session_impl& operator=(session_impl&& other) noexcept = delete;
 
         virtual ~session_impl();
 
+        // Factory method
+        static boost::shared_ptr<session_impl> create(const nlohmann::json& net_params);
+
         virtual void on_failed_login() = 0;
         virtual bool is_connected() const = 0;
         virtual void set_ping_fail_handler(ping_fail_t handler) = 0;