The ssl::context is now owned by the connection.

mzimbres · mzimbres · commit c0aa4356ea52 · 2023-05-10T23:25:09.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -61,6 +61,7 @@ include_directories(include)
 add_library(test_common STATIC
    tests/common.cpp
 )
+target_link_libraries(test_common PUBLIC OpenSSL::Crypto OpenSSL::SSL)
 target_compile_features(test_common PUBLIC cxx_std_17)
 if (MSVC)
     target_compile_options(test_common PRIVATE /bigobj)
diff --git a/examples/cpp17_intro.cpp b/examples/cpp17_intro.cpp
@@ -32,8 +32,7 @@ auto main(int argc, char * argv[]) -> int
       response<std::string> resp;
 
       net::io_context ioc;
-      net::ssl::context ctx{net::ssl::context::tls_client};
-      connection conn{ioc, ctx};
+      connection conn{ioc};
 
       conn.async_run(cfg, {}, net::detached);
 
diff --git a/examples/cpp17_intro_sync.cpp b/examples/cpp17_intro_sync.cpp
@@ -28,8 +28,7 @@ auto main(int argc, char * argv[]) -> int
          cfg.addr.port = argv[2];
       }
 
-      net::ssl::context ctx{net::ssl::context::tls_client};
-      sync_connection conn{ctx};
+      sync_connection conn;
       conn.run(cfg);
 
       request req;
diff --git a/examples/cpp20_chat_room.cpp b/examples/cpp20_chat_room.cpp
@@ -75,13 +75,12 @@ auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection
 auto co_main(config cfg) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(ex, *ctx);
+   auto conn = std::make_shared<connection>(ex);
    auto stream = std::make_shared<stream_descriptor>(ex, ::dup(STDIN_FILENO));
 
    net::co_spawn(ex, receiver(conn), net::detached);
    net::co_spawn(ex, publisher(stream, conn), net::detached);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    signal_set sig_set{ex, SIGINT, SIGTERM};
    co_await sig_set.async_wait();
diff --git a/examples/cpp20_containers.cpp b/examples/cpp20_containers.cpp
@@ -91,9 +91,8 @@ auto transaction(std::shared_ptr<connection> conn) -> net::awaitable<void>
 // Called from the main function (see main.cpp)
 net::awaitable<void> co_main(config cfg)
 {
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor, *ctx);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    co_await store(conn);
    co_await transaction(conn);
diff --git a/examples/cpp20_echo_server.cpp b/examples/cpp20_echo_server.cpp
@@ -58,10 +58,9 @@ auto listener(std::shared_ptr<connection> conn) -> net::awaitable<void>
 auto co_main(config cfg) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(ex, *ctx);
+   auto conn = std::make_shared<connection>(ex);
    net::co_spawn(ex, listener(conn), net::detached);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    signal_set sig_set(ex, SIGINT, SIGTERM);
    co_await sig_set.async_wait();
diff --git a/examples/cpp20_intro.cpp b/examples/cpp20_intro.cpp
@@ -23,9 +23,8 @@ using connection = net::deferred_t::as_default_on_t<boost::redis::connection>;
 // Called from the main function (see main.cpp)
 auto co_main(config cfg) -> net::awaitable<void>
 {
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor, *ctx);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    // A request containing only a ping command.
    request req;
diff --git a/examples/cpp20_intro_tls.cpp b/examples/cpp20_intro_tls.cpp
@@ -34,9 +34,8 @@ auto co_main(config cfg) -> net::awaitable<void>
    cfg.addr.host = "db.occase.de";
    cfg.addr.port = "6380";
 
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor, *ctx);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    request req;
    req.push("PING");
diff --git a/examples/cpp20_json.cpp b/examples/cpp20_json.cpp
@@ -48,9 +48,8 @@ void boost_redis_from_bulk(user& u, std::string_view sv, boost::system::error_co
 auto co_main(config cfg) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(ex, *ctx);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   auto conn = std::make_shared<connection>(ex);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    // user object that will be stored in Redis in json format.
    user const u{"Joao", "58", "Brazil"};
diff --git a/examples/cpp20_protobuf.cpp b/examples/cpp20_protobuf.cpp
@@ -47,9 +47,8 @@ using tutorial::boost_redis_from_bulk;
 net::awaitable<void> co_main(config cfg)
 {
    auto ex = co_await net::this_coro::executor;
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(ex, *ctx);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   auto conn = std::make_shared<connection>(ex);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    person p;
    p.set_name("Louis");
diff --git a/examples/cpp20_resolve_with_sentinel.cpp b/examples/cpp20_resolve_with_sentinel.cpp
@@ -34,8 +34,7 @@ auto resolve_master_address(std::vector<address> const& addresses) -> net::await
    req.push("SENTINEL", "get-master-addr-by-name", "mymaster");
    req.push("QUIT");
 
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor, *ctx);
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
 
    response<std::optional<std::array<std::string, 2>>, ignore_t> resp;
    for (auto addr : addresses) {
@@ -45,7 +44,7 @@ auto resolve_master_address(std::vector<address> const& addresses) -> net::await
       // TODO: async_run and async_exec should be lauched in
       // parallel here so we can wait for async_run completion
       // before eventually calling it again.
-      conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+      conn->async_run(cfg, {}, net::consign(net::detached, conn));
       co_await conn->async_exec(req, resp, redir(ec));
       conn->cancel();
       conn->reset_stream();
diff --git a/examples/cpp20_streams.cpp b/examples/cpp20_streams.cpp
@@ -84,13 +84,12 @@ auto stream_reader(std::shared_ptr<connection> conn) -> net::awaitable<void>
 auto co_main(config cfg) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(ex, *ctx);
+   auto conn = std::make_shared<connection>(ex);
    net::co_spawn(ex, stream_reader(conn), net::detached);
 
    // Disable health checks.
    cfg.health_check_interval = std::chrono::seconds{0};
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    signal_set sig_set(ex, SIGINT, SIGTERM);
    co_await sig_set.async_wait();
diff --git a/examples/cpp20_subscriber.cpp b/examples/cpp20_subscriber.cpp
@@ -75,10 +75,9 @@ receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 auto co_main(config cfg) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   auto ctx = std::make_shared<net::ssl::context>(net::ssl::context::tls_client);
-   auto conn = std::make_shared<connection>(ex, *ctx);
+   auto conn = std::make_shared<connection>(ex);
    net::co_spawn(ex, receiver(conn), net::detached);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn, ctx));
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
 
    signal_set sig_set(ex, SIGINT, SIGTERM);
    co_await sig_set.async_wait();
diff --git a/examples/sync_connection.hpp b/examples/sync_connection.hpp
@@ -20,9 +20,9 @@ namespace boost::redis
 
 class sync_connection {
 public:
-   sync_connection(boost::asio::ssl::context& ctx)
+   sync_connection()
    : ioc_{1}
-   , conn_{std::make_shared<connection>(ioc_, ctx)}
+   , conn_{std::make_shared<connection>(ioc_)}
    { }
 
    ~sync_connection()
diff --git a/include/boost/redis/connection.hpp b/include/boost/redis/connection.hpp
@@ -54,27 +54,36 @@ class basic_connection : private detail::connection_base<Executor, basic_connect
 
    /// Contructs from an executor.
    explicit
-   basic_connection(executor_type ex, asio::ssl::context& ctx)
+   basic_connection(executor_type ex, asio::ssl::context::method method = asio::ssl::context::tls_client)
    : base_type{ex}
-   , ctx_{&ctx}
+   , ctx_{method}
    , reconn_{ex}
    , runner_{ex, {}}
-   , stream_{std::make_unique<next_layer_type>(ex, ctx)}
+   , stream_{std::make_unique<next_layer_type>(ex, ctx_)}
    { }
 
    /// Contructs from a context.
    explicit
-   basic_connection(asio::io_context& ioc, asio::ssl::context& ctx)
-   : basic_connection(ioc.get_executor(), ctx)
+   basic_connection(asio::io_context& ioc, asio::ssl::context::method method = asio::ssl::context::tls_client)
+   : basic_connection(ioc.get_executor(), method)
    { }
 
    /// Returns the associated executor.
-   auto get_executor() {return stream_->get_executor();}
+   auto get_executor()
+      {return stream_->get_executor();}
+
+   /// Returns the ssl context.
+   auto const& get_ssl_context() const noexcept
+      { return ctx_;}
+
+   /// Returns the ssl context.
+   auto& get_ssl_context() noexcept
+      { return ctx_;}
 
    /// Reset the underlying stream.
    void reset_stream()
    {
-      stream_ = std::make_unique<next_layer_type>(stream_->get_executor(), *ctx_);
+      stream_ = std::make_unique<next_layer_type>(stream_->get_executor(), ctx_);
    }
 
    /// Returns a reference to the next layer.
@@ -280,7 +289,7 @@ class basic_connection : private detail::connection_base<Executor, basic_connect
    auto use_ssl() const noexcept { return use_ssl_;}
 
    bool use_ssl_ = false;
-   asio::ssl::context* ctx_;
+   asio::ssl::context ctx_;
    reconnection_type reconn_;
    runner_type runner_;
    std::unique_ptr<next_layer_type> stream_;
diff --git a/tests/conn_check_health.cpp b/tests/conn_check_health.cpp
@@ -75,8 +75,7 @@ BOOST_AUTO_TEST_CASE(check_health)
    net::io_context ioc;
 
 
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   connection conn1{ioc, ctx};
+   connection conn1{ioc};
 
    request req1;
    req1.push("CLIENT", "PAUSE", "10000", "ALL");
@@ -94,7 +93,7 @@ BOOST_AUTO_TEST_CASE(check_health)
 
    // It looks like client pause does not work for clients that are
    // sending MONITOR. I will therefore open a second connection.
-   connection conn2{ioc, ctx};
+   connection conn2{ioc};
 
    config cfg2;
    cfg2.health_check_id = "conn2";
diff --git a/tests/conn_echo_stress.cpp b/tests/conn_echo_stress.cpp
@@ -65,8 +65,7 @@ auto echo_session(std::shared_ptr<connection> conn, std::string id, int n) -> ne
 auto async_echo_stress() -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ex, ctx);
+   auto conn = std::make_shared<connection>(ex);
 
    int const sessions = 500;
    int const msgs = 1000;
diff --git a/tests/conn_exec.cpp b/tests/conn_exec.cpp
@@ -43,8 +43,7 @@ BOOST_AUTO_TEST_CASE(hello_priority)
 
    net::io_context ioc;
 
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    bool seen1 = false;
    bool seen2 = false;
@@ -93,8 +92,7 @@ BOOST_AUTO_TEST_CASE(wrong_response_data_type)
    response<int> resp;
    net::io_context ioc;
 
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    conn->async_exec(req, resp, [conn](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, boost::redis::error::not_a_number);
@@ -112,8 +110,7 @@ BOOST_AUTO_TEST_CASE(cancel_request_if_not_connected)
    req.push("PING");
 
    net::io_context ioc;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
    conn->async_exec(req, ignore, [conn](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, boost::redis::error::not_connected);
       conn->cancel();
diff --git a/tests/conn_exec_cancel.cpp b/tests/conn_exec_cancel.cpp
@@ -38,8 +38,7 @@ using namespace std::chrono_literals;
 auto implicit_cancel_of_req_written() -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ex, ctx);
+   auto conn = std::make_shared<connection>(ex);
 
    config cfg;
    cfg.health_check_interval = std::chrono::seconds{0};
@@ -81,8 +80,7 @@ BOOST_AUTO_TEST_CASE(test_ignore_implicit_cancel_of_req_written)
 BOOST_AUTO_TEST_CASE(test_cancel_of_req_written_on_run_canceled)
 {
    net::io_context ioc;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    request req0;
    req0.push("PING");
diff --git a/tests/conn_exec_cancel2.cpp b/tests/conn_exec_cancel2.cpp
@@ -40,8 +40,7 @@ auto async_ignore_explicit_cancel_of_req_written() -> net::awaitable<void>
    auto ex = co_await net::this_coro::executor;
 
    generic_response gresp;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ex, ctx);
+   auto conn = std::make_shared<connection>(ex);
 
    run(conn);
 
diff --git a/tests/conn_exec_error.cpp b/tests/conn_exec_error.cpp
@@ -38,8 +38,7 @@ BOOST_AUTO_TEST_CASE(no_ignore_error)
 
    net::io_context ioc;
 
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    conn->async_exec(req, ignore, [&](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, error::resp3_simple_error);
@@ -65,8 +64,7 @@ BOOST_AUTO_TEST_CASE(has_diagnostic)
 
    net::io_context ioc;
 
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    response<std::string, std::string> resp;
    conn->async_exec(req, resp, [&](auto ec, auto){
@@ -108,8 +106,7 @@ BOOST_AUTO_TEST_CASE(resp3_error_in_cmd_pipeline)
    response<std::string> resp2;
 
    net::io_context ioc;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    auto c2 = [&](auto ec, auto)
    {
@@ -165,8 +162,7 @@ BOOST_AUTO_TEST_CASE(error_in_transaction)
 
    net::io_context ioc;
 
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    conn->async_exec(req, resp, [&](auto ec, auto){
       BOOST_TEST(!ec);
@@ -218,8 +214,7 @@ BOOST_AUTO_TEST_CASE(subscriber_wrong_syntax)
    req2.push("SUBSCRIBE"); // Wrong command synthax.
 
    net::io_context ioc;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    auto c2 = [&](auto ec, auto)
    {
diff --git a/tests/conn_exec_retry.cpp b/tests/conn_exec_retry.cpp
@@ -42,8 +42,7 @@ BOOST_AUTO_TEST_CASE(request_retry_false)
    req2.push("PING");
 
    net::io_context ioc;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    net::steady_timer st{ioc};
    st.expires_after(std::chrono::seconds{1});
@@ -105,8 +104,7 @@ BOOST_AUTO_TEST_CASE(request_retry_true)
    req3.push("QUIT");
 
    net::io_context ioc;
-   net::ssl::context ctx{net::ssl::context::tls_client};
-   auto conn = std::make_shared<connection>(ioc, ctx);
+   auto conn = std::make_shared<connection>(ioc);
 
    net::steady_timer st{ioc};
    st.expires_after(std::chrono::seconds{1});
diff --git a/tests/conn_push.cpp b/tests/conn_push.cpp
diff --git a/tests/conn_quit.cpp b/tests/conn_quit.cpp
diff --git a/tests/conn_reconnect.cpp b/tests/conn_reconnect.cpp
diff --git a/tests/conn_run_cancel.cpp b/tests/conn_run_cancel.cpp
diff --git a/tests/conn_tls.cpp b/tests/conn_tls.cpp
diff --git a/tests/issue_50.cpp b/tests/issue_50.cpp
diff --git a/tests/run.cpp b/tests/run.cpp

Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@ include_directories(include)`
`61`	`61`	`add_library(test_common STATIC`
`62`	`62`	`tests/common.cpp`
`63`	`63`	`)`
	`64`	`+target_link_libraries(test_common PUBLIC OpenSSL::Crypto OpenSSL::SSL)`
`64`	`65`	`target_compile_features(test_common PUBLIC cxx_std_17)`
`65`	`66`	`if (MSVC)`
`66`	`67`	`target_compile_options(test_common PRIVATE /bigobj)`
Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,7 @@ auto main(int argc, char * argv[]) -> int`
`28`	`28`	`cfg.addr.port = argv[2];`
`29`	`29`	`}`
`30`	`30`
`31`		`- net::ssl::context ctx{net::ssl::context::tls_client};`
`32`		`- sync_connection conn{ctx};`
	`31`	`+ sync_connection conn;`
`33`	`32`	`conn.run(cfg);`
`34`	`33`
`35`	`34`	`request req;`