start_accept()

void MayaFlux::Core::TCPBackend::start_accept ( ListenerState &  listener )

private

Initiate async_accept loop for a listener.

On accept: creates ConnectionState for the new peer, assigns endpoint id via m_allocate_endpoint_id, starts receive chain, fires state callback. Then resubmits async_accept.

Definition at line 394 of file TCPBackend.cpp.

{
    listener.pending_socket = asio::ip::tcp::socket(m_context);
 
    listener.acceptor.async_accept(
        listener.pending_socket,
        [this, listener_id = listener.info.id](const asio::error_code& ec) {
            std::shared_lock lock(m_listeners_mutex);
            auto it = m_listeners.find(listener_id);
            if (it == m_listeners.end()) {
                return;
            }
 
            auto& lst = *it->second;
 
            if (ec) {
                if (ec == asio::error::operation_aborted) {
                    return;
                }
                MF_WARN(Journal::Component::Core, Journal::Context::NetworkBackend,
                    "TCP accept error on listener {}: {}", listener_id, ec.message());
                start_accept(lst);
                return;
            }
 
            uint64_t new_id = 0;
            if (m_allocate_endpoint_id) {
                new_id = m_allocate_endpoint_id();
            }
 
            auto peer_ep = lst.pending_socket.remote_endpoint();
            std::string peer_addr = peer_ep.address().to_string();
            uint16_t peer_port = peer_ep.port();
 
            auto conn = std::make_unique<ConnectionState>(m_context);
            conn->socket = std::move(lst.pending_socket);
            conn->is_outbound = false;
            conn->info.id = new_id;
            conn->info.transport = NetworkTransport::TCP;
            conn->info.role = EndpointRole::BIDIRECTIONAL;
            conn->info.state = EndpointState::OPEN;
            conn->info.remote_address = peer_addr;
            conn->info.remote_port = peer_port;
            conn->info.local_port = lst.info.local_port;
 
            auto* raw = conn.get();
 
            {
                std::unique_lock conn_lock(m_connections_mutex);
                m_connections[new_id] = std::move(conn);
            }
 
            if (m_state_callback) {
                m_state_callback(raw->info, EndpointState::CLOSED, EndpointState::OPEN);
            }
 
            start_receive_chain(*raw);
 
            MF_INFO(Journal::Component::Core, Journal::Context::NetworkBackend,
                "TCP accepted connection {} from {}:{} on listener {}",
                new_id, peer_addr, peer_port, listener_id);
 
            start_accept(lst);
        });
}

References MayaFlux::Core::TCPBackend::ListenerState::acceptor, MayaFlux::Journal::Core, MayaFlux::Core::EndpointInfo::id, MayaFlux::Core::TCPBackend::ListenerState::info, MF_INFO, MF_WARN, MayaFlux::Journal::NetworkBackend, and MayaFlux::Core::TCPBackend::ListenerState::pending_socket.

Referenced by open_endpoint().

Here is the caller graph for this function: