Hub Connection Builder (aspnet#20)

Author: BrennanConroy

include/signalrclient/http_client.h

@@ -51,7 +51,7 @@ namespace signalr
     class http_client
     {
     public:
-        virtual void send(std::string url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback) = 0;
+        virtual void send(const std::string& url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback) = 0;
 
         virtual ~http_client() {}
     };

include/signalrclient/hub_connection.h

@@ -14,22 +14,26 @@
 
 namespace signalr
 {
+    class http_client;
+    class websocket_client;
     class hub_connection_impl;
+    class hub_connection_builder;
 
     class hub_connection
     {
     public:
         typedef std::function<void __cdecl (const signalr::value&)> method_invoked_handler;
 
-        SIGNALRCLIENT_API explicit hub_connection(const std::string& url, trace_level trace_level = trace_level::all,
-            std::shared_ptr<log_writer> log_writer = nullptr);
-
         SIGNALRCLIENT_API ~hub_connection();
 
         hub_connection(const hub_connection&) = delete;
 
         hub_connection& operator=(const hub_connection&) = delete;
 
+        SIGNALRCLIENT_API hub_connection(hub_connection&&) noexcept;
+
+        SIGNALRCLIENT_API hub_connection& operator=(hub_connection&&) noexcept;
+
         SIGNALRCLIENT_API void __cdecl start(std::function<void(std::exception_ptr)> callback) noexcept;
         SIGNALRCLIENT_API void __cdecl stop(std::function<void(std::exception_ptr)> callback) noexcept;
 
@@ -47,6 +51,12 @@ namespace signalr
         SIGNALRCLIENT_API void send(const std::string& method_name, const signalr::value& arguments = signalr::value(), std::function<void(std::exception_ptr)> callback = [](std::exception_ptr) {}) noexcept;
 
     private:
+        friend class hub_connection_builder;
+
+        explicit hub_connection(const std::string& url, trace_level trace_level = trace_level::all,
+            std::shared_ptr<log_writer> log_writer = nullptr, std::shared_ptr<http_client> http_client = nullptr,
+            std::function<std::shared_ptr<websocket_client>()> websocket_factory = nullptr);
+
         std::shared_ptr<hub_connection_impl> m_pImpl;
     };
 }

include/signalrclient/hub_connection_builder.h

@@ -0,0 +1,45 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#pragma once
+
+#include "_exports.h"
+#include "hub_connection.h"
+#include <memory>
+#include "websocket_client.h"
+#include "http_client.h"
+
+namespace signalr
+{
+    class hub_connection_builder
+    {
+    public:
+        SIGNALRCLIENT_API static hub_connection_builder create(const std::string& url);
+
+        SIGNALRCLIENT_API ~hub_connection_builder();
+
+        SIGNALRCLIENT_API hub_connection_builder(const hub_connection_builder&);
+
+        SIGNALRCLIENT_API hub_connection_builder(hub_connection_builder&&) noexcept;
+
+        SIGNALRCLIENT_API hub_connection_builder& operator=(hub_connection_builder&&) noexcept;
+
+        SIGNALRCLIENT_API hub_connection_builder& operator=(const hub_connection_builder&);
+
+        SIGNALRCLIENT_API hub_connection_builder& with_logging(std::shared_ptr<log_writer> logger, trace_level logLevel);
+
+        SIGNALRCLIENT_API hub_connection_builder& with_websocket_factory(std::function<std::shared_ptr<websocket_client>()> factory);
+
+        SIGNALRCLIENT_API hub_connection_builder& with_http_client(std::shared_ptr<http_client> http_client);
+
+        SIGNALRCLIENT_API hub_connection build();
+    private:
+        hub_connection_builder(const std::string& url);
+
+        std::string m_url;
+        std::shared_ptr<log_writer> m_logger;
+        trace_level m_log_level;
+        std::function<std::shared_ptr<websocket_client>()> m_websocket_factory;
+        std::shared_ptr<http_client> m_http_client;
+    };
+}

samples/HubConnectionSample/HubConnectionSample.cpp

@@ -3,7 +3,7 @@
 
 #include <iostream>
 #include <sstream>
-#include "hub_connection.h"
+#include "hub_connection_builder.h"
 #include "log_writer.h"
 #include <future>
 #include "signalr_value.h"
@@ -50,7 +50,10 @@ void send_message(signalr::hub_connection& connection, const std::string& messag
 
 void chat()
 {
-    signalr::hub_connection connection("http://localhost:5000/default", signalr::trace_level::all, std::make_shared<logger>());
+    signalr::hub_connection connection = signalr::hub_connection_builder::create("http://localhost:5000/default")
+        .with_logging(std::make_shared <logger>(), signalr::trace_level::all)
+        .build();
+
     connection.on("Send", [](const signalr::value & m)
     {
         std::cout << std::endl << m.as_array()[0].as_string() << std::endl << "Enter your message: ";

src/signalrclient/CMakeLists.txt

@@ -6,6 +6,7 @@ set (SOURCES
   default_websocket_client.cpp
   handshake_protocol.cpp
   hub_connection.cpp
+  hub_connection_builder.cpp
   hub_connection_impl.cpp
   json_helpers.cpp
   json_hub_protocol.cpp

src/signalrclient/connection_impl.cpp

@@ -15,6 +15,8 @@
 #include "make_unique.h"
 #include "completion_event.h"
 #include <assert.h>
+#include "signalrclient/websocket_client.h"
+#include "default_websocket_client.h"
 
 namespace signalr
 {
@@ -27,14 +29,14 @@ namespace signalr
 
     std::shared_ptr<connection_impl> connection_impl::create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer)
     {
-        return connection_impl::create(url, trace_level, log_writer, nullptr, std::make_unique<transport_factory>());
+        return connection_impl::create(url, trace_level, log_writer, nullptr, nullptr);
     }
 
     std::shared_ptr<connection_impl> connection_impl::create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
-        std::unique_ptr<http_client> http_client, std::unique_ptr<transport_factory> transport_factory)
+        std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory)
     {
         return std::shared_ptr<connection_impl>(new connection_impl(url, trace_level,
-            log_writer ? log_writer : std::make_shared<trace_log_writer>(), std::move(http_client), std::move(transport_factory)));
+            log_writer ? log_writer : std::make_shared<trace_log_writer>(), http_client, websocket_factory));
     }
 
     connection_impl::connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
@@ -52,6 +54,32 @@ namespace signalr
         }
     }
 
+    connection_impl::connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
+        std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        : m_base_http://github.com/url(url), m_connection_state(connection_state::disconnected), m_logger(log_writer, trace_level), m_transport(nullptr),
+        m_message_received([](const std::string&) noexcept {}), m_disconnected([]() noexcept {})
+    {
+        if (http_client != nullptr)
+        {
+            m_http_client = std::move(http_client);
+        }
+        else
+        {
+#ifdef USE_CPPRESTSDK
+            m_http_client = std::unique_ptr<class http_client>(new default_http_client());
+#endif
+        }
+
+        if (websocket_factory == nullptr)
+        {
+#ifdef USE_CPPRESTSDK
+            websocket_factory = []() { return std::make_shared<default_websocket_client>(); };
+#endif
+        }
+
+        m_transport_factory = std::unique_ptr<transport_factory>(new transport_factory(m_http_client, websocket_factory));
+    }
+
     connection_impl::~connection_impl()
     {
         try

src/signalrclient/connection_impl.h

@@ -16,6 +16,8 @@
 
 namespace signalr
 {
+    class websocket_client;
+
     // Note:
     // Factory methods and private constructors prevent from using this class incorrectly. Because this class
     // derives from `std::enable_shared_from_this` the instance has to be owned by a `std::shared_ptr` whenever
@@ -27,7 +29,7 @@ namespace signalr
         static std::shared_ptr<connection_impl> create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer);
 
         static std::shared_ptr<connection_impl> create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
-            std::unique_ptr<http_client> http_client, std::unique_ptr<transport_factory> transport_factory);
+            std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory);
 
         connection_impl(const connection_impl&) = delete;
 
@@ -62,11 +64,14 @@ namespace signalr
         cancellation_token m_start_completed_event;
         std::string m_connection_id;
         std::string m_connection_token;
-        std::unique_ptr<http_client> m_http_client;
+        std::shared_ptr<http_client> m_http_client;
 
         connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
             std::unique_ptr<http_client> http_client, std::unique_ptr<transport_factory> transport_factory);
 
+        connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
+            std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory);
+
         void start_transport(const std::string& url, std::function<void(std::shared_ptr<transport>, std::exception_ptr)> callback);
         void send_connect_request(const std::shared_ptr<transport>& transport,
             const std::string& url, std::function<void(std::exception_ptr)> callback);

src/signalrclient/default_http_client.cpp

@@ -10,7 +10,7 @@
 
 namespace signalr
 {
-    void default_http_client::send(std::string url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback)
+    void default_http_client::send(const std::string& url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback)
     {
         web::http::method method;
         if (request.method == http_method::GET)

src/signalrclient/default_http_client.h

@@ -10,6 +10,6 @@ namespace signalr
     class default_http_client : public http_client
     {
     public:
-        void send(std::string url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback) override;
+        void send(const std::string& url, const http_request& request, std::function<void(const http_response&, std::exception_ptr)> callback) override;
     };
 }

src/signalrclient/hub_connection.cpp

@@ -5,16 +5,30 @@
 #include "signalrclient/hub_connection.h"
 #include "hub_connection_impl.h"
 #include "signalrclient/signalr_exception.h"
+#include "signalrclient/http_client.h"
+#include "signalrclient/websocket_client.h"
 
 namespace signalr
 {
     hub_connection::hub_connection(const std::string& url,
-        trace_level trace_level, std::shared_ptr<log_writer> log_writer)
-        : m_pImpl(hub_connection_impl::create(url, trace_level, std::move(log_writer)))
+        trace_level trace_level, std::shared_ptr<log_writer> log_writer, std::shared_ptr<http_client> http_client,
+        std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        : m_pImpl(hub_connection_impl::create(url, trace_level, log_writer, http_client, websocket_factory))
     {}
 
+    hub_connection::hub_connection(hub_connection&& rhs) noexcept
+        : m_pImpl(std::move(rhs.m_pImpl))
+    {}
+
+    hub_connection& hub_connection::operator=(hub_connection&& rhs) noexcept
+    {
+        m_pImpl = std::move(rhs.m_pImpl);
+
+        return *this;
+    }
+
     // Do NOT remove this destructor. Letting the compiler generate and inline the default dtor may lead to
-    // undefinded behavior since we are using an incomplete type. More details here:  http://herbsutter.com/gotw/_100/
+    // undefined behavior since we are using an incomplete type. More details here:  http://herbsutter.com/gotw/_100/
     hub_connection::~hub_connection() = default;
 
     void hub_connection::start(std::function<void(std::exception_ptr)> callback) noexcept