Boost-Mysql error when shared_ptr is created for connection object

The lifetimes of objects are not guarded well.

• the _io_context member is initialized AFTER the base class, you want to fix the order of the initializers to reflect this

• the ssl_ctx is destructed before the end of initialize. It probably needs to be a member object

• you probably want to use all the resolver endpoints in the connection attempt:

       boost::asio::connect(_connection->stream().next_layer(), endpoints);
  

• most importantly, the lifetime of the io_context object is not shown, but needs to be guarded.

Everything could be greatly simplified by avoiding references, two-step initialization and dynamic allocation.

Some Fixes

Some of the above fixed:

Live On Coliru

#include <boost/asio.hpp>
#include <boost/mysql.hpp>

#include <iostream>
#include <syncstream>
#define HLog(level) (std::osyncstream(std::cout) << "n[" #level "] ")

namespace Horizon::System {
    enum ModuleType {
        RUNTIME_DATABASE,
        RUNTIME_FILESYSTEM,
        RUNTIME_NETWORK,
        RUNTIME_PROCESS,
        RUNTIME_THREAD,
        RUNTIME_TIMER,
        RUNTIME_USER
    };
}

namespace asio = boost::asio;
namespace ssl  = asio::ssl;
using asio::ip::tcp;

struct MainframeComponent {
    MainframeComponent(Horizon::System::ModuleType module_type) : _module_type(module_type) {}

    virtual ~MainframeComponent()                   = default;
    virtual void initialize(int segment_number = 1) = 0;
    virtual void finalize(int segment_number = 1)   = 0;

    Horizon::System::ModuleType get_module_type() { return _module_type; }

  protected:
    Horizon::System::ModuleType _module_type;
};

class DatabaseProcess : public MainframeComponent {
  public:
    // MainframeComponent dispatch module type is set to Main because DatabaseProcess doesn't run on its own
    // thread.
    DatabaseProcess(asio::io_context& io_context)
        : MainframeComponent(Horizon::System::RUNTIME_DATABASE)
        , _io_context(io_context) {}

    ~DatabaseProcess() {
        // Close connection object.
        if (_connection != nullptr) {
            _connection->close();
            _connection.reset();
        }
    }

    void initialize(int /*segment_number*/ = 1) override { HLog(error) << "Database not configured"; }
    void initialize(int /*segment_number*/, std::string host, int port, std::string user, std::string pass,
                    std::string database) {
        try {
            _connection =
                std::make_shared<boost::mysql::tcp_ssl_connection>(_io_context.get_executor(), ssl_ctx);
            tcp::resolver                  resolver(_io_context.get_executor());
            auto                           endpoints = resolver.resolve(host, std::to_string(port));
            boost::mysql::handshake_params params(user, pass, database);
            // asio::connect(_connection->stream().next_layer(), endpoints);
            _connection->connect(*endpoints.begin(), params);
        } catch (boost::mysql::error_with_diagnostics& error) {
            HLog(error) << error.what();
        }

        bool value = _is_initialized;
        _is_initialized.compare_exchange_strong(value, true);
    }

    void finalize(int /*segment_number*/ = 1) override {
        bool value = _is_initialized;
        _is_initialized.compare_exchange_strong(value, false);
    }

    std::shared_ptr<boost::mysql::tcp_ssl_connection> get_connection() { return _connection; }

    bool is_initialized() { return _is_initialized.load(); }

  protected:
    asio::io_context&                                 _io_context;
    ssl::context                                      ssl_ctx{ssl::context::tls_client};
    std::shared_ptr<boost::mysql::tcp_ssl_connection> _connection{nullptr};
    std::atomic<bool>                                 _is_initialized;
};

int main() {
    //
    asio::io_context ioc;
    DatabaseProcess p(ioc);

    p.initialize(1, "localhost", 3306, "root", "root", "test");
}