MySQL 9.2.0
Source Code Documentation
MysqlRoutingClassicConnectionBase Class Reference

#include <classic_connection_base.h>

Inheritance diagram for MysqlRoutingClassicConnectionBase:
[legend]

Public Types

enum class  FromEither { None , Started , RecvedFromClient , RecvedFromServer }
 
using ClientSideConnection = TlsSwitchableClientConnection< ClientSideClassicProtocolState >
 
using ServerSideConnection = TlsSwitchableConnection< ServerSideClassicProtocolState >
 
- Public Types inherited from MySQLRoutingConnectionBase
using clock_type = std::chrono::system_clock
 
using time_point_type = clock_type::time_point
 

Public Member Functions

std::shared_ptr< MysqlRoutingClassicConnectionBasegetptr ()
 
void on_handshake_received ()
 
void on_handshake_aborted ()
 
SslMode source_ssl_mode () const
 
SslMode dest_ssl_mode () const
 
net::impl::socket::native_handle_type get_client_fd () const override
 
DestinationManagerdestination_manager () const
 
routing_guidelines::Session_info get_session_info ()
 
void disconnect () override
 
virtual void async_run ()
 
void send_server_failed (std::error_code ec, bool call_finish=true)
 
void recv_server_failed (std::error_code ec, bool call_finish=true)
 
void send_client_failed (std::error_code ec, bool call_finish=true)
 
void recv_client_failed (std::error_code ec, bool call_finish=true)
 
void server_socket_failed (std::error_code ec, bool call_finish=true)
 
virtual void client_socket_failed (std::error_code ec, bool call_finish=true)
 
void resume ()
 
void push_processor (std::unique_ptr< BasicProcessor > processor)
 
void pop_processor ()
 
stdx::expected< void, std::error_code > track_session_changes (net::const_buffer session_trackers, classic_protocol::capabilities::value_type caps, bool ignore_some_state_changed=false)
 
void reset_to_initial ()
 reset the connection's settings to the initial-values. More...
 
ClientSideConnection::protocol_state_typeclient_protocol ()
 
const ClientSideConnection::protocol_state_typeclient_protocol () const
 
ServerSideConnection::protocol_state_typeserver_protocol ()
 
const ServerSideConnection::protocol_state_typeserver_protocol () const
 
ClientSideConnectionclient_conn ()
 
const ClientSideConnectionclient_conn () const
 
ServerSideConnectionserver_conn ()
 
const ServerSideConnectionserver_conn () const
 
virtual void stash_server_conn ()
 
std::optional< mysql_harness::Destinationget_destination_id () const override
 
void destination_id (const std::optional< mysql_harness::Destination > &id)
 
std::optional< mysql_harness::Destinationread_only_destination_id () const override
 
void read_only_destination_id (const std::optional< mysql_harness::Destination > &destination_id)
 
std::optional< mysql_harness::Destinationread_write_destination_id () const override
 
void read_write_destination_id (const std::optional< mysql_harness::Destination > &destination_id)
 
std::optional< mysql_harness::DestinationEndpointdestination_endpoint () const override
 
void destination_endpoint (const std::optional< mysql_harness::DestinationEndpoint > &ep)
 
std::optional< mysql_harness::DestinationEndpointread_only_destination_endpoint () const override
 
void read_only_destination_endpoint (const std::optional< mysql_harness::DestinationEndpoint > &ep)
 
std::optional< mysql_harness::DestinationEndpointread_write_destination_endpoint () const override
 
void read_write_destination_endpoint (const std::optional< mysql_harness::DestinationEndpoint > &ep)
 
void set_destination (std::unique_ptr< Destination > destination)
 
bool authenticated () const
 check if the connection is authenticated. More...
 
void authenticated (bool v)
 
bool connection_sharing_possible () const
 check if connection sharing is possible. More...
 
bool connection_sharing_allowed () const
 check if connection sharing is allowed. More...
 
void connection_sharing_allowed_reset ()
 reset the connection-sharing state. More...
 
std::string connection_sharing_blocked_by () const
 
bool greeting_from_router () const
 if the router is sending the initial server-greeting. More...
 
void expected_server_transport_constraints (TransportConstraints val)
 
TransportConstraints expected_server_transport_constraints () const
 
void some_state_changed (bool v)
 
void expected_server_mode (mysqlrouter::ServerMode v)
 
mysqlrouter::ServerMode expected_server_mode () const
 
void current_server_mode (mysqlrouter::ServerMode v)
 
mysqlrouter::ServerMode current_server_mode () const
 
void wait_for_my_writes (bool v)
 
bool wait_for_my_writes () const
 
void gtid_at_least_executed (const std::string &gtid)
 
std::string gtid_at_least_executed () const
 
std::chrono::seconds wait_for_my_writes_timeout () const
 
void wait_for_my_writes_timeout (std::chrono::seconds timeout)
 
void collation_connection_maybe_dirty (bool val)
 
bool collation_connection_maybe_dirty () const
 
std::optional< classic_protocol::session_track::TransactionCharacteristicstrx_characteristics () const
 
void trx_characteristics (std::optional< classic_protocol::session_track::TransactionCharacteristics > trx_chars)
 
std::optional< classic_protocol::session_track::TransactionStatetrx_state () const
 
void wait_until_completed () override
 
void completed () override
 
ExecutionContextexecution_context ()
 
const ExecutionContextexecution_context () const
 
void trace (Tracer::Event e)
 
Tracertracer ()
 
net::steady_timerread_timer ()
 
net::steady_timerconnect_timer ()
 
void connect_error_code (const std::error_code &ec)
 
std::error_code connect_error_code () const
 
void diagnostic_area_changed (bool diagnostic_area_changed)
 
bool diagnostic_area_changed () const
 
const TraceSpanevents () const
 
TraceSpanevents ()
 
void recv_from_either (FromEither v)
 
FromEither recv_from_either () const
 
void has_transient_error_at_connect (bool val)
 
bool has_transient_error_at_connect () const
 
- Public Member Functions inherited from MySQLRoutingConnectionBase
 MySQLRoutingConnectionBase (MySQLRoutingContext &context, std::function< void(MySQLRoutingConnectionBase *)> remove_callback)
 
virtual ~MySQLRoutingConnectionBase ()=default
 
MySQLRoutingContextcontext ()
 
const MySQLRoutingContextcontext () const
 
std::string get_server_address () const
 Returns address of server to which connection is established. More...
 
void server_address (const std::string &dest)
 
std::string get_client_address () const
 Returns address of client which connected to router. More...
 
void client_address (const std::string &dest)
 
std::size_t get_bytes_up () const
 
std::size_t get_bytes_down () const
 
time_point_type get_started () const
 
time_point_type get_connected_to_server () const
 
time_point_type get_last_sent_to_server () const
 
time_point_type get_last_received_from_server () const
 
Stats get_stats () const
 
void transfered_to_server (size_t bytes)
 
void transfered_to_client (size_t bytes)
 
void disassociate ()
 
void accepted ()
 
virtual void connected ()
 
template<class F >
auto disconnect_request (F &&f)
 
bool disconnect_requested () const
 
routing_guidelines::Session_info get_session_info () const
 
void set_routing_guidelines_session_rand ()
 

Static Public Member Functions

template<typename... Args>
static std::shared_ptr< MysqlRoutingClassicConnectionBasecreate (Args &&...args)
 
static stdx::expected< size_t, std::error_code > encode_error_packet (std::vector< uint8_t > &error_frame, const uint8_t seq_id, const classic_protocol::capabilities::value_type caps, const uint16_t error_code, const std::string &msg, const std::string &sql_state)
 

Protected Types

enum class  Function { kLoop , kFinish }
 

Protected Member Functions

 MysqlRoutingClassicConnectionBase (MySQLRoutingContext &context, DestinationManager *destination_manager, std::unique_ptr< ConnectionBase > client_connection, std::unique_ptr< RoutingConnectionBase > client_routing_connection, std::function< void(MySQLRoutingConnectionBase *)> remove_callback)
 
void call_next_function (Function next)
 
- Protected Member Functions inherited from MySQLRoutingConnectionBase
void log_connection_summary ()
 

Private Member Functions

void trace_and_call_function (Tracer::Event::Direction dir, std::string_view stage, Function func)
 
void async_send_client (Function next)
 
void async_recv_client (Function next)
 
void async_send_server (Function next)
 
void async_recv_server (Function next)
 
void async_recv_both (Function next)
 
void async_send_client_and_finish ()
 
void async_wait_client_closed ()
 
void async_wait_send_server (Function next)
 
void server_side_client_greeting ()
 
void loop ()
 
void finish ()
 
virtual void done ()
 
std::string get_routing_source () const override
 
void set_routing_source (std::string name) override
 
routing_guidelines::Server_info get_server_info () const override
 

Private Attributes

std::vector< std::unique_ptr< BasicProcessor > > processors_
 
int active_work_ {0}
 
bool authenticated_ {false}
 
ClientSideConnection client_conn_
 
ServerSideConnection server_conn_
 
std::optional< mysql_harness::Destinationrw_destination_id_
 
std::optional< mysql_harness::Destinationro_destination_id_
 
std::optional< mysql_harness::DestinationEndpointrw_destination_endpoint_
 
std::optional< mysql_harness::DestinationEndpointro_destination_endpoint_
 
bool in_handshake_ {true}
 client side handshake isn't finished yet. More...
 
std::optional< classic_protocol::session_track::TransactionStatetrx_state_
 
std::optional< classic_protocol::session_track::TransactionCharacteristicstrx_characteristics_
 
bool some_state_changed_ {false}
 
bool collation_connection_maybe_dirty_ {false}
 
TransportConstraints expected_server_transport_constraints_
 
ExecutionContext exec_ctx_
 
Tracer tracer_ {false}
 
net::steady_timer read_timer_
 
net::steady_timer connect_timer_
 
std::error_code connect_ec_ {}
 
bool diagnostic_area_changed_ {}
 
std::unique_ptr< Destinationdestination_
 
FromEither recv_from_either_ {FromEither::None}
 
TraceSpan events_
 
mysqlrouter::ServerMode expected_server_mode_
 
mysqlrouter::ServerMode current_server_mode_
 
bool wait_for_my_writes_
 
std::string gtid_at_least_executed_
 
std::chrono::seconds wait_for_my_writes_timeout_
 
bool has_transient_error_at_connect_ {false}
 
WaitableMonitor< bool > is_completed_ {false}
 
DestinationManagerdestination_manager_
 

Additional Inherited Members

- Protected Attributes inherited from MySQLRoutingConnectionBase
MySQLRoutingContextcontext_
 wrapper for common data used by all routing threads More...
 
std::function< void(MySQLRoutingConnectionBase *)> remove_callback_
 callback that is called when thread of execution completes More...
 
Monitor< Statsstats_ {{}}
 
Monitor< bool > disconnect_ {{}}
 

Member Typedef Documentation

◆ ClientSideConnection

◆ ServerSideConnection

Member Enumeration Documentation

◆ FromEither

Enumerator
None 
Started 
RecvedFromClient 
RecvedFromServer 

◆ Function

enum class MysqlRoutingClassicConnectionBase::Function
strongprotected
Enumerator
kLoop 
kFinish 

Constructor & Destructor Documentation

◆ MysqlRoutingClassicConnectionBase()

MysqlRoutingClassicConnectionBase::MysqlRoutingClassicConnectionBase ( MySQLRoutingContext context,
DestinationManager destination_manager,
std::unique_ptr< ConnectionBase client_connection,
std::unique_ptr< RoutingConnectionBase client_routing_connection,
std::function< void(MySQLRoutingConnectionBase *)>  remove_callback 
)
inlineprotected

Member Function Documentation

◆ async_recv_both()

void MysqlRoutingClassicConnectionBase::async_recv_both ( Function  next)
private

◆ async_recv_client()

void MysqlRoutingClassicConnectionBase::async_recv_client ( Function  next)
private

◆ async_recv_server()

void MysqlRoutingClassicConnectionBase::async_recv_server ( Function  next)
private

◆ async_run()

virtual void MysqlRoutingClassicConnectionBase::async_run ( )
inlinevirtual

Reimplemented in MysqlRoutingClassicConnection.

◆ async_send_client()

void MysqlRoutingClassicConnectionBase::async_send_client ( Function  next)
private

◆ async_send_client_and_finish()

void MysqlRoutingClassicConnectionBase::async_send_client_and_finish ( )
private

◆ async_send_server()

void MysqlRoutingClassicConnectionBase::async_send_server ( Function  next)
private

◆ async_wait_client_closed()

void MysqlRoutingClassicConnectionBase::async_wait_client_closed ( )
private

◆ async_wait_send_server()

void MysqlRoutingClassicConnectionBase::async_wait_send_server ( Function  next)
private

◆ authenticated() [1/2]

bool MysqlRoutingClassicConnectionBase::authenticated ( ) const
inline

check if the connection is authenticated.

'true' after the initial handshake and change-user finished with "ok". 'false' at connection start and after change-user is started.

Return values
trueif the connection is authenticated.
Returns
false otherwise

◆ authenticated() [2/2]

void MysqlRoutingClassicConnectionBase::authenticated ( bool  v)
inline

◆ call_next_function()

void MysqlRoutingClassicConnectionBase::call_next_function ( Function  next)
inlineprotected

◆ client_conn() [1/2]

ClientSideConnection & MysqlRoutingClassicConnectionBase::client_conn ( )
inline

◆ client_conn() [2/2]

const ClientSideConnection & MysqlRoutingClassicConnectionBase::client_conn ( ) const
inline

◆ client_protocol() [1/2]

ClientSideConnection::protocol_state_type & MysqlRoutingClassicConnectionBase::client_protocol ( )
inline

◆ client_protocol() [2/2]

const ClientSideConnection::protocol_state_type & MysqlRoutingClassicConnectionBase::client_protocol ( ) const
inline

◆ client_socket_failed()

void MysqlRoutingClassicConnectionBase::client_socket_failed ( std::error_code  ec,
bool  call_finish = true 
)
virtual

◆ collation_connection_maybe_dirty() [1/2]

bool MysqlRoutingClassicConnectionBase::collation_connection_maybe_dirty ( ) const
inline

◆ collation_connection_maybe_dirty() [2/2]

void MysqlRoutingClassicConnectionBase::collation_connection_maybe_dirty ( bool  val)
inline

◆ completed()

void MysqlRoutingClassicConnectionBase::completed ( )
inlineoverridevirtual

◆ connect_error_code() [1/2]

std::error_code MysqlRoutingClassicConnectionBase::connect_error_code ( ) const
inline

◆ connect_error_code() [2/2]

void MysqlRoutingClassicConnectionBase::connect_error_code ( const std::error_code &  ec)
inline

◆ connect_timer()

net::steady_timer & MysqlRoutingClassicConnectionBase::connect_timer ( )
inline

◆ connection_sharing_allowed()

bool MysqlRoutingClassicConnectionBase::connection_sharing_allowed ( ) const

check if connection sharing is allowed.

  • connection sharing is possible.
  • no active transaction
  • no SET TRANSACTION

◆ connection_sharing_allowed_reset()

void MysqlRoutingClassicConnectionBase::connection_sharing_allowed_reset ( )

reset the connection-sharing state.

  • after COM_RESET_CONNECTION::ok
  • after COM_CHANGE_USER::ok

◆ connection_sharing_blocked_by()

std::string MysqlRoutingClassicConnectionBase::connection_sharing_blocked_by ( ) const
Returns
a string representing the reason why sharing is blocked.

◆ connection_sharing_possible()

bool MysqlRoutingClassicConnectionBase::connection_sharing_possible ( ) const

check if connection sharing is possible.

  • the configuration enabled it

◆ create()

template<typename... Args>
static std::shared_ptr< MysqlRoutingClassicConnectionBase > MysqlRoutingClassicConnectionBase::create ( Args &&...  args)
inlinestatic

◆ current_server_mode() [1/2]

mysqlrouter::ServerMode MysqlRoutingClassicConnectionBase::current_server_mode ( ) const
inline

◆ current_server_mode() [2/2]

void MysqlRoutingClassicConnectionBase::current_server_mode ( mysqlrouter::ServerMode  v)
inline

◆ dest_ssl_mode()

SslMode MysqlRoutingClassicConnectionBase::dest_ssl_mode ( ) const
inline

◆ destination_endpoint() [1/2]

std::optional< mysql_harness::DestinationEndpoint > MysqlRoutingClassicConnectionBase::destination_endpoint ( ) const
inlineoverridevirtual

◆ destination_endpoint() [2/2]

void MysqlRoutingClassicConnectionBase::destination_endpoint ( const std::optional< mysql_harness::DestinationEndpoint > &  ep)
inline

◆ destination_id()

void MysqlRoutingClassicConnectionBase::destination_id ( const std::optional< mysql_harness::Destination > &  id)
inline

◆ destination_manager()

DestinationManager * MysqlRoutingClassicConnectionBase::destination_manager ( ) const
inline

◆ diagnostic_area_changed() [1/2]

bool MysqlRoutingClassicConnectionBase::diagnostic_area_changed ( ) const
inline

◆ diagnostic_area_changed() [2/2]

void MysqlRoutingClassicConnectionBase::diagnostic_area_changed ( bool  diagnostic_area_changed)
inline

◆ disconnect()

void MysqlRoutingClassicConnectionBase::disconnect ( )
overridevirtual

◆ done()

void MysqlRoutingClassicConnectionBase::done ( )
privatevirtual

◆ encode_error_packet()

stdx::expected< size_t, std::error_code > MysqlRoutingClassicConnectionBase::encode_error_packet ( std::vector< uint8_t > &  error_frame,
const uint8_t  seq_id,
const classic_protocol::capabilities::value_type  caps,
const uint16_t  error_code,
const std::string &  msg,
const std::string &  sql_state 
)
static

◆ events() [1/2]

TraceSpan & MysqlRoutingClassicConnectionBase::events ( )
inline

◆ events() [2/2]

const TraceSpan & MysqlRoutingClassicConnectionBase::events ( ) const
inline

◆ execution_context() [1/2]

ExecutionContext & MysqlRoutingClassicConnectionBase::execution_context ( )
inline

◆ execution_context() [2/2]

const ExecutionContext & MysqlRoutingClassicConnectionBase::execution_context ( ) const
inline

◆ expected_server_mode() [1/2]

mysqlrouter::ServerMode MysqlRoutingClassicConnectionBase::expected_server_mode ( ) const
inline

◆ expected_server_mode() [2/2]

void MysqlRoutingClassicConnectionBase::expected_server_mode ( mysqlrouter::ServerMode  v)
inline

◆ expected_server_transport_constraints() [1/2]

TransportConstraints MysqlRoutingClassicConnectionBase::expected_server_transport_constraints ( ) const
inline

◆ expected_server_transport_constraints() [2/2]

void MysqlRoutingClassicConnectionBase::expected_server_transport_constraints ( TransportConstraints  val)
inline

◆ finish()

void MysqlRoutingClassicConnectionBase::finish ( )
private

◆ get_client_fd()

net::impl::socket::native_handle_type MysqlRoutingClassicConnectionBase::get_client_fd ( ) const
inlineoverridevirtual

◆ get_destination_id()

std::optional< mysql_harness::Destination > MysqlRoutingClassicConnectionBase::get_destination_id ( ) const
inlineoverridevirtual

◆ get_routing_source()

std::string MysqlRoutingClassicConnectionBase::get_routing_source ( ) const
inlineoverrideprivatevirtual

◆ get_server_info()

routing_guidelines::Server_info MysqlRoutingClassicConnectionBase::get_server_info ( ) const
inlineoverrideprivatevirtual

◆ get_session_info()

routing_guidelines::Session_info MysqlRoutingClassicConnectionBase::get_session_info ( )

◆ getptr()

std::shared_ptr< MysqlRoutingClassicConnectionBase > MysqlRoutingClassicConnectionBase::getptr ( )
inline

◆ greeting_from_router()

bool MysqlRoutingClassicConnectionBase::greeting_from_router ( ) const
inline

if the router is sending the initial server-greeting.

if true, the router sends the initial greeting to the client, if false, the server is sending the initial greeting and router is forward it.

◆ gtid_at_least_executed() [1/2]

std::string MysqlRoutingClassicConnectionBase::gtid_at_least_executed ( ) const
inline

◆ gtid_at_least_executed() [2/2]

void MysqlRoutingClassicConnectionBase::gtid_at_least_executed ( const std::string &  gtid)
inline

◆ has_transient_error_at_connect() [1/2]

bool MysqlRoutingClassicConnectionBase::has_transient_error_at_connect ( ) const
inline

◆ has_transient_error_at_connect() [2/2]

void MysqlRoutingClassicConnectionBase::has_transient_error_at_connect ( bool  val)
inline

◆ loop()

void MysqlRoutingClassicConnectionBase::loop ( )
private

◆ on_handshake_aborted()

void MysqlRoutingClassicConnectionBase::on_handshake_aborted ( )

◆ on_handshake_received()

void MysqlRoutingClassicConnectionBase::on_handshake_received ( )

◆ pop_processor()

void MysqlRoutingClassicConnectionBase::pop_processor ( )
inline

◆ push_processor()

void MysqlRoutingClassicConnectionBase::push_processor ( std::unique_ptr< BasicProcessor processor)
inline

◆ read_only_destination_endpoint() [1/2]

std::optional< mysql_harness::DestinationEndpoint > MysqlRoutingClassicConnectionBase::read_only_destination_endpoint ( ) const
inlineoverridevirtual

Reimplemented from MySQLRoutingConnectionBase.

◆ read_only_destination_endpoint() [2/2]

void MysqlRoutingClassicConnectionBase::read_only_destination_endpoint ( const std::optional< mysql_harness::DestinationEndpoint > &  ep)
inline

◆ read_only_destination_id() [1/2]

std::optional< mysql_harness::Destination > MysqlRoutingClassicConnectionBase::read_only_destination_id ( ) const
inlineoverridevirtual

Reimplemented from MySQLRoutingConnectionBase.

◆ read_only_destination_id() [2/2]

void MysqlRoutingClassicConnectionBase::read_only_destination_id ( const std::optional< mysql_harness::Destination > &  destination_id)
inline

◆ read_timer()

net::steady_timer & MysqlRoutingClassicConnectionBase::read_timer ( )
inline

◆ read_write_destination_endpoint() [1/2]

std::optional< mysql_harness::DestinationEndpoint > MysqlRoutingClassicConnectionBase::read_write_destination_endpoint ( ) const
inlineoverridevirtual

Reimplemented from MySQLRoutingConnectionBase.

◆ read_write_destination_endpoint() [2/2]

void MysqlRoutingClassicConnectionBase::read_write_destination_endpoint ( const std::optional< mysql_harness::DestinationEndpoint > &  ep)
inline

◆ read_write_destination_id() [1/2]

std::optional< mysql_harness::Destination > MysqlRoutingClassicConnectionBase::read_write_destination_id ( ) const
inlineoverridevirtual

Reimplemented from MySQLRoutingConnectionBase.

◆ read_write_destination_id() [2/2]

void MysqlRoutingClassicConnectionBase::read_write_destination_id ( const std::optional< mysql_harness::Destination > &  destination_id)
inline

◆ recv_client_failed()

void MysqlRoutingClassicConnectionBase::recv_client_failed ( std::error_code  ec,
bool  call_finish = true 
)

◆ recv_from_either() [1/2]

FromEither MysqlRoutingClassicConnectionBase::recv_from_either ( ) const
inline

◆ recv_from_either() [2/2]

void MysqlRoutingClassicConnectionBase::recv_from_either ( FromEither  v)
inline

◆ recv_server_failed()

void MysqlRoutingClassicConnectionBase::recv_server_failed ( std::error_code  ec,
bool  call_finish = true 
)

◆ reset_to_initial()

void MysqlRoutingClassicConnectionBase::reset_to_initial ( )

reset the connection's settings to the initial-values.

◆ resume()

void MysqlRoutingClassicConnectionBase::resume ( )
inline

◆ send_client_failed()

void MysqlRoutingClassicConnectionBase::send_client_failed ( std::error_code  ec,
bool  call_finish = true 
)

◆ send_server_failed()

void MysqlRoutingClassicConnectionBase::send_server_failed ( std::error_code  ec,
bool  call_finish = true 
)

◆ server_conn() [1/2]

ServerSideConnection & MysqlRoutingClassicConnectionBase::server_conn ( )
inline

◆ server_conn() [2/2]

const ServerSideConnection & MysqlRoutingClassicConnectionBase::server_conn ( ) const
inline

◆ server_protocol() [1/2]

ServerSideConnection::protocol_state_type & MysqlRoutingClassicConnectionBase::server_protocol ( )
inline

◆ server_protocol() [2/2]

const ServerSideConnection::protocol_state_type & MysqlRoutingClassicConnectionBase::server_protocol ( ) const
inline

◆ server_side_client_greeting()

void MysqlRoutingClassicConnectionBase::server_side_client_greeting ( )
private

◆ server_socket_failed()

void MysqlRoutingClassicConnectionBase::server_socket_failed ( std::error_code  ec,
bool  call_finish = true 
)

◆ set_destination()

void MysqlRoutingClassicConnectionBase::set_destination ( std::unique_ptr< Destination destination)
inline

◆ set_routing_source()

void MysqlRoutingClassicConnectionBase::set_routing_source ( std::string  name)
inlineoverrideprivatevirtual

◆ some_state_changed()

void MysqlRoutingClassicConnectionBase::some_state_changed ( bool  v)
inline

◆ source_ssl_mode()

SslMode MysqlRoutingClassicConnectionBase::source_ssl_mode ( ) const
inline

◆ stash_server_conn()

void MysqlRoutingClassicConnectionBase::stash_server_conn ( )
virtual

Reimplemented in MysqlRoutingClassicConnection.

◆ trace()

void MysqlRoutingClassicConnectionBase::trace ( Tracer::Event  e)
inline

◆ trace_and_call_function()

void MysqlRoutingClassicConnectionBase::trace_and_call_function ( Tracer::Event::Direction  dir,
std::string_view  stage,
MysqlRoutingClassicConnectionBase::Function  func 
)
private

◆ tracer()

Tracer & MysqlRoutingClassicConnectionBase::tracer ( )
inline

◆ track_session_changes()

stdx::expected< void, std::error_code > MysqlRoutingClassicConnectionBase::track_session_changes ( net::const_buffer  session_trackers,
classic_protocol::capabilities::value_type  caps,
bool  ignore_some_state_changed = false 
)

◆ trx_characteristics() [1/2]

std::optional< classic_protocol::session_track::TransactionCharacteristics > MysqlRoutingClassicConnectionBase::trx_characteristics ( ) const
inline

◆ trx_characteristics() [2/2]

void MysqlRoutingClassicConnectionBase::trx_characteristics ( std::optional< classic_protocol::session_track::TransactionCharacteristics trx_chars)
inline

◆ trx_state()

std::optional< classic_protocol::session_track::TransactionState > MysqlRoutingClassicConnectionBase::trx_state ( ) const
inline

◆ wait_for_my_writes() [1/2]

bool MysqlRoutingClassicConnectionBase::wait_for_my_writes ( ) const
inline

◆ wait_for_my_writes() [2/2]

void MysqlRoutingClassicConnectionBase::wait_for_my_writes ( bool  v)
inline

◆ wait_for_my_writes_timeout() [1/2]

std::chrono::seconds MysqlRoutingClassicConnectionBase::wait_for_my_writes_timeout ( ) const
inline

◆ wait_for_my_writes_timeout() [2/2]

void MysqlRoutingClassicConnectionBase::wait_for_my_writes_timeout ( std::chrono::seconds  timeout)
inline

◆ wait_until_completed()

void MysqlRoutingClassicConnectionBase::wait_until_completed ( )
inlineoverridevirtual

Member Data Documentation

◆ active_work_

int MysqlRoutingClassicConnectionBase::active_work_ {0}
private

◆ authenticated_

bool MysqlRoutingClassicConnectionBase::authenticated_ {false}
private

◆ client_conn_

ClientSideConnection MysqlRoutingClassicConnectionBase::client_conn_
private

◆ collation_connection_maybe_dirty_

bool MysqlRoutingClassicConnectionBase::collation_connection_maybe_dirty_ {false}
private

◆ connect_ec_

std::error_code MysqlRoutingClassicConnectionBase::connect_ec_ {}
private

◆ connect_timer_

net::steady_timer MysqlRoutingClassicConnectionBase::connect_timer_
private

◆ current_server_mode_

mysqlrouter::ServerMode MysqlRoutingClassicConnectionBase::current_server_mode_
private

◆ destination_

std::unique_ptr<Destination> MysqlRoutingClassicConnectionBase::destination_
private

◆ destination_manager_

DestinationManager* MysqlRoutingClassicConnectionBase::destination_manager_
private

◆ diagnostic_area_changed_

bool MysqlRoutingClassicConnectionBase::diagnostic_area_changed_ {}
private

◆ events_

TraceSpan MysqlRoutingClassicConnectionBase::events_
private

◆ exec_ctx_

ExecutionContext MysqlRoutingClassicConnectionBase::exec_ctx_
private

◆ expected_server_mode_

mysqlrouter::ServerMode MysqlRoutingClassicConnectionBase::expected_server_mode_
private

◆ expected_server_transport_constraints_

TransportConstraints MysqlRoutingClassicConnectionBase::expected_server_transport_constraints_
private

◆ gtid_at_least_executed_

std::string MysqlRoutingClassicConnectionBase::gtid_at_least_executed_
private

◆ has_transient_error_at_connect_

bool MysqlRoutingClassicConnectionBase::has_transient_error_at_connect_ {false}
private

◆ in_handshake_

bool MysqlRoutingClassicConnectionBase::in_handshake_ {true}
private

client side handshake isn't finished yet.

◆ is_completed_

WaitableMonitor<bool> MysqlRoutingClassicConnectionBase::is_completed_ {false}
private

◆ processors_

std::vector<std::unique_ptr<BasicProcessor> > MysqlRoutingClassicConnectionBase::processors_
private

◆ read_timer_

net::steady_timer MysqlRoutingClassicConnectionBase::read_timer_
private

◆ recv_from_either_

FromEither MysqlRoutingClassicConnectionBase::recv_from_either_ {FromEither::None}
private

◆ ro_destination_endpoint_

std::optional<mysql_harness::DestinationEndpoint> MysqlRoutingClassicConnectionBase::ro_destination_endpoint_
private

◆ ro_destination_id_

std::optional<mysql_harness::Destination> MysqlRoutingClassicConnectionBase::ro_destination_id_
private

◆ rw_destination_endpoint_

std::optional<mysql_harness::DestinationEndpoint> MysqlRoutingClassicConnectionBase::rw_destination_endpoint_
private

◆ rw_destination_id_

std::optional<mysql_harness::Destination> MysqlRoutingClassicConnectionBase::rw_destination_id_
private

◆ server_conn_

ServerSideConnection MysqlRoutingClassicConnectionBase::server_conn_
private

◆ some_state_changed_

bool MysqlRoutingClassicConnectionBase::some_state_changed_ {false}
private

◆ tracer_

Tracer MysqlRoutingClassicConnectionBase::tracer_ {false}
private

◆ trx_characteristics_

std::optional<classic_protocol::session_track::TransactionCharacteristics> MysqlRoutingClassicConnectionBase::trx_characteristics_
private

◆ trx_state_

std::optional<classic_protocol::session_track::TransactionState> MysqlRoutingClassicConnectionBase::trx_state_
private

◆ wait_for_my_writes_

bool MysqlRoutingClassicConnectionBase::wait_for_my_writes_
private

◆ wait_for_my_writes_timeout_

std::chrono::seconds MysqlRoutingClassicConnectionBase::wait_for_my_writes_timeout_
private

The documentation for this class was generated from the following files: