open_endpoint()

uint64_t MayaFlux::Core::TCPBackend::open_endpoint ( const EndpointInfo &  info )

overridevirtual

Open a new endpoint.

Parameters

info	Endpoint configuration with id pre-assigned by subsystem.

Returns

The endpoint id on success, or 0 on failure.

The subsystem assigns the id before calling this. The backend stores and uses it for subsequent operations.

For UDP: binds a local port and/or stores a default remote target. For TCP: connects to a remote host, or begins listening on a port. Outbound connect may block. Use co_open_endpoint on the service for non-blocking connect. For SHM: opens or creates a named shared memory segment.

Implements MayaFlux::Core::INetworkBackend.

Definition at line 114 of file TCPBackend.cpp.

{
    bool is_listener = !info.remote_address.empty() ? false
                                                    : (info.local_port > 0);
 
    if (is_listener) {
        auto listener = std::make_unique<ListenerState>(m_context);
        listener->info = info;
        listener->info.state = EndpointState::OPENING;
 
        asio::error_code ec;
        auto endpoint = asio::ip::tcp::endpoint(asio::ip::tcp::v4(), info.local_port);
 
        if (listener->acceptor.open(endpoint.protocol(), ec)) {
            MF_ERROR(Journal::Component::Core, Journal::Context::NetworkBackend,
                "Failed to open TCP acceptor: {}", ec.message());
            return 0;
        }
 
        if (listener->acceptor.set_option(asio::socket_base::reuse_address(true), ec)) {
            MF_ERROR(Journal::Component::Core, Journal::Context::NetworkBackend,
                "Failed to set SO_REUSEADDR on TCP acceptor: {}", ec.message());
            return 0;
        }
 
        if (listener->acceptor.bind(endpoint, ec)) {
            MF_ERROR(Journal::Component::Core, Journal::Context::NetworkBackend,
                "Failed to bind TCP acceptor to port {}: {}", info.local_port, ec.message());
            return 0;
        }
 
        if (listener->acceptor.listen(asio::socket_base::max_listen_connections, ec)) {
            MF_ERROR(Journal::Component::Core, Journal::Context::NetworkBackend,
                "Failed to listen on port {}: {}", info.local_port, ec.message());
            return 0;
        }
 
        listener->info.state = EndpointState::OPEN;
 
        auto* raw = listener.get();
 
        {
            std::unique_lock lock(m_listeners_mutex);
            m_listeners[info.id] = std::move(listener);
        }
 
        if (m_state_callback) {
            m_state_callback(raw->info, EndpointState::OPENING, EndpointState::OPEN);
        }
 
        start_accept(*raw);
 
        MF_INFO(Journal::Component::Core, Journal::Context::NetworkBackend,
            "TCP listener {} opened on port {}", info.id, info.local_port);
 
        return info.id;
    }
 
    auto conn = std::make_unique<ConnectionState>(m_context);
    conn->info = info;
    conn->info.state = EndpointState::OPENING;
    conn->is_outbound = true;
 
    auto* raw = conn.get();
 
    {
        std::unique_lock lock(m_connections_mutex);
        m_connections[info.id] = std::move(conn);
    }
 
    start_connect(*raw);
 
    MF_INFO(Journal::Component::Core, Journal::Context::NetworkBackend,
        "TCP connection {} opening to {}:{}", info.id, info.remote_address, info.remote_port);
 
    return info.id;
}

References MayaFlux::Journal::Core, MayaFlux::Core::EndpointInfo::id, MayaFlux::Core::EndpointInfo::local_port, m_connections, m_connections_mutex, m_context, m_listeners, m_listeners_mutex, m_state_callback, MF_ERROR, MF_INFO, MayaFlux::Journal::NetworkBackend, MayaFlux::Core::OPEN, MayaFlux::Core::OPENING, MayaFlux::Core::EndpointInfo::remote_address, MayaFlux::Core::EndpointInfo::remote_port, start_accept(), start_connect(), and MayaFlux::Core::EndpointInfo::state.

Here is the call graph for this function: