EIC code displayed by LXR master/​include/​boost/​redis/​impl/​connect_fsm.ipp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-17 09:00:18

 //
 // Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
 // Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
 #include <boost/redis/config.hpp>
 #include <boost/redis/detail/connect_fsm.hpp>
 #include <boost/redis/detail/coroutine.hpp>
 #include <boost/redis/error.hpp>
 #include <boost/redis/impl/log_utils.hpp>
 
 #include <boost/asio/cancellation_type.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/assert.hpp>
 
 #include <string>
 
 namespace boost::redis::detail {
 
 // Logging
 inline void format_tcp_endpoint(const asio::ip::tcp::endpoint& ep, std::string& to)
 {
    // This formatting is inspired by Asio's endpoint operator<<
    const auto& addr = ep.address();
    if (addr.is_v6())
       to += '[';
    to += addr.to_string();
    if (addr.is_v6())
       to += ']';
    to += ':';
    to += std::to_string(ep.port());
 }
 
 template <>
 struct log_traits<asio::ip::tcp::endpoint> {
    static inline void log(std::string& to, const asio::ip::tcp::endpoint& value)
    {
       format_tcp_endpoint(value, to);
    }
 };
 
 template <>
 struct log_traits<asio::ip::tcp::resolver::results_type> {
    static inline void log(std::string& to, const asio::ip::tcp::resolver::results_type& value)
    {
       auto iter = value.cbegin();
       auto end = value.cend();
 
       if (iter != end) {
          format_tcp_endpoint(iter->endpoint(), to);
          ++iter;
          for (; iter != end; ++iter) {
             to += ", ";
             format_tcp_endpoint(iter->endpoint(), to);
          }
       }
    }
 };
 
 inline transport_type transport_from_config(const config& cfg)
 {
    if (cfg.unix_socket.empty()) {
       if (cfg.use_ssl) {
          return transport_type::tcp_tls;
       } else {
          return transport_type::tcp;
       }
    } else {
       BOOST_ASSERT(!cfg.use_ssl);
       return transport_type::unix_socket;
    }
 }
 
 inline system::error_code translate_timeout_error(
    system::error_code io_ec,
    asio::cancellation_type_t cancel_state,
    error code_if_cancelled)
 {
    // Translates cancellations and timeout errors into a single error_code.
    //   - Cancellation state set, and an I/O error: the entire operation was cancelled.
    //     The I/O code (probably operation_aborted) is appropriate.
    //   - Cancellation state set, and no I/O error: same as above, but the cancellation
    //     arrived after the operation completed and before the handler was called. Set the code here.
    //   - No cancellation state set, I/O error set to operation_aborted: since we use cancel_after,
    //     this means a timeout.
    //   - Otherwise, respect the I/O error.
    if ((cancel_state & asio::cancellation_type_t::terminal) != asio::cancellation_type_t::none) {
       return io_ec ? io_ec : asio::error::operation_aborted;
    }
    return io_ec == asio::error::operation_aborted ? code_if_cancelled : io_ec;
 }
 
 connect_action connect_fsm::resume(
    system::error_code ec,
    const asio::ip::tcp::resolver::results_type& resolver_results,
    redis_stream_state& st,
    asio::cancellation_type_t cancel_state)
 {
    // Translate error codes
    ec = translate_timeout_error(ec, cancel_state, error::resolve_timeout);
 
    // Log it
    if (ec) {
       log_info(*lgr_, "Error resolving the server hostname: ", ec);
    } else {
       log_info(*lgr_, "Resolve results: ", resolver_results);
    }
 
    // Delegate to the regular resume function
    return resume(ec, st, cancel_state);
 }
 
 connect_action connect_fsm::resume(
    system::error_code ec,
    const asio::ip::tcp::endpoint& selected_endpoint,
    redis_stream_state& st,
    asio::cancellation_type_t cancel_state)
 {
    // Translate error codes
    ec = translate_timeout_error(ec, cancel_state, error::connect_timeout);
 
    // Log it
    if (ec) {
       log_info(*lgr_, "Failed to connect to the server: ", ec);
    } else {
       log_info(*lgr_, "Connected to ", selected_endpoint);
    }
 
    // Delegate to the regular resume function
    return resume(ec, st, cancel_state);
 }
 
 connect_action connect_fsm::resume(
    system::error_code ec,
    redis_stream_state& st,
    asio::cancellation_type_t cancel_state)
 {
    switch (resume_point_) {
       BOOST_REDIS_CORO_INITIAL
 
       // Record the transport that we will be using
       st.type = transport_from_config(*cfg_);
 
       if (st.type == transport_type::unix_socket) {
          // Reset the socket, to discard any previous state. Ignore any errors
          BOOST_REDIS_YIELD(resume_point_, 1, connect_action_type::unix_socket_close)
 
          // Connect to the socket
          BOOST_REDIS_YIELD(resume_point_, 2, connect_action_type::unix_socket_connect)
 
          // Fix error codes. If we were cancelled and the code is operation_aborted,
          // it is because per-operation cancellation was activated. If we were not cancelled
          // but the operation failed with operation_aborted, it's a timeout.
          // Also check for cancellations that didn't cause a failure
          ec = translate_timeout_error(ec, cancel_state, error::connect_timeout);
 
          // Log it
          if (ec) {
             log_info(*lgr_, "Failed to connect to the server: ", ec);
          } else {
             log_info(*lgr_, "Connected to ", cfg_->unix_socket);
          }
 
          // If this failed, we can't continue
          if (ec) {
             return ec;
          }
 
          // Done
          return system::error_code();
       } else {
          // ssl::stream doesn't support being re-used. If we're to use
          // TLS and the stream has been used, re-create it.
          // Must be done before anything else is done on the stream.
          // We don't need to close the TCP socket if using plaintext TCP
          // because range-connect closes open sockets, while individual connect doesn't
          if (cfg_->use_ssl && st.ssl_stream_used) {
             BOOST_REDIS_YIELD(resume_point_, 3, connect_action_type::ssl_stream_reset)
          }
 
          // Resolve names. The continuation needs access to the returned
          // endpoints, and is a specialized resume() that will call this function
          BOOST_REDIS_YIELD(resume_point_, 4, connect_action_type::tcp_resolve)
 
          // If this failed, we can't continue (error code translation already performed here)
          if (ec) {
             return ec;
          }
 
          // Now connect to the endpoints returned by the resolver.
          // This has a specialized resume(), too
          BOOST_REDIS_YIELD(resume_point_, 5, connect_action_type::tcp_connect)
 
          // If this failed, we can't continue (error code translation already performed here)
          if (ec) {
             return ec;
          }
 
          if (cfg_->use_ssl) {
             // Mark the SSL stream as used
             st.ssl_stream_used = true;
 
             // Perform the TLS handshake
             BOOST_REDIS_YIELD(resume_point_, 6, connect_action_type::ssl_handshake)
 
             // Translate error codes
             ec = translate_timeout_error(ec, cancel_state, error::ssl_handshake_timeout);
 
             // Log it
             if (ec) {
                log_info(*lgr_, "Failed to perform SSL handshake: ", ec);
             } else {
                log_info(*lgr_, "Successfully performed SSL handshake");
             }
 
             // If this failed, we can't continue
             if (ec) {
                return ec;
             }
          }
 
          // Done
          return system::error_code();
       }
    }
 
    BOOST_ASSERT(false);
    return system::error_code();
 }
 
 }  // namespace boost::redis::detail

This page was automatically generated by the 2.3.7 LXR engine. The LXR team